This commit adds the environment variable "PAPI_BLOCKED_EXPANSIONS"
which can contain a case insensitive, comma separated list of blocked
expansions.
Expansions on this list can no longer be downloaded using commands.
This commit changes two lines but fixes the replacement of cased
placeholders with non-cased ones that was accidentally happening.
This was partially fixed in a few previous commits, but not fully as
it was still replacing failed placeholder matches.
* Update development from master (#662)
* Add contributing and expansion section
* Start using new Issue template system
* Create bug_report.yml
* Rename feature_request.md to feature_request_old.md
* Create feature_request.yml
* fix unique name
* Update feature_request_old.md
* Add Checkboxes
* Add checkboxes
* disable default issue body
* Delete bug_report_old.md
* Delete feature_request_old.md
* Rename bug_report_new.yml to bug_report.yml
* Check if deleting this fixed the PR...
* Use description in favour of about
* improve feature_request.md
* Update bug_report.yml
* Assign "Type: Issue (Unconfirmed)" label
* Use lists and not comma-separated string
* Update feature_request.yml
* Use id option for error and dump fields
* Add field for logs
* Remove deprecated issue_body type
* Update feature_request.yml
* Improve description of bug_report.yml
* Initial 1.17 Changes
* add render
* Revert build.gradle dependencies change
* Fixed duplicate files
* Initial test on adventure
* started moving to pure adventure
* finished kyori impl
* added 1.17 to nmsversion (what does this even do)
* removed dev for release
* added dev back
Co-authored-by: PiggyPiglet <PiggyPiglet@users.noreply.github.com>
Co-authored-by: darbyjack <admin@glaremasters.me>
Co-authored-by: PiggyPiglet <noreply@piggypiglet.me>
* Update dependencies of PlaceholderAPI
* Add missing trailing /
Co-authored-by: PiggyPiglet <PiggyPiglet@users.noreply.github.com>
Co-authored-by: darbyjack <admin@glaremasters.me>
Co-authored-by: PiggyPiglet <noreply@piggypiglet.me>
* Update Javadoc documentation
* More comments... a lot more!
* Remove Gson
* Implemented working version for 1.8.8 - 1.16.3
* Improve ExpansionsLoadedEvent's docs
* 2021 🥳
* Add contributing and expansion section
* Fix invalid link tag
* Start using new Issue template system
* Create bug_report.yml
* Rename feature_request.md to feature_request_old.md
* Create feature_request.yml
* should it use setBracketPlaceholders??
* fix unique name
* Update feature_request_old.md
* Add Checkboxes
* Add checkboxes
* disable default issue body
* Delete bug_report_old.md
* Delete feature_request_old.md
* Rename bug_report_new.yml to bug_report.yml
* Check if deleting this fixed the PR...
* Use description in favour of about
* improve feature_request.md
* Update bug_report.yml
* Assign "Type: Issue (Unconfirmed)" label
* Use lists and not comma-separated string
* Update feature_request.yml
* Use id option for error and dump fields
* Add field for logs
* Update Copyright
~ Fixed a typo and updated missed files from #543
* Re-add removed code
That should actually NOT be here...
* Undo renaming of boolean
* Remove deprecated issue_body type
* Update feature_request.yml
* Improve description of bug_report.yml
* Build jars on PR (Compile and build validation)
* Initial 1.17 Changes
* Extracted URLClassLoader out of try-with-resources block
* Close URLClassLoader if Expansion class was not found
* Build against Java 8, 11 and 16
* adoPt
I always make that mistake...
* add render
* Cleanup build.gradle
(cherry picked from commit 7750ba7033)
* Remove the @NotNull's because they are overridden by expansion devs anyways, and it turns out people can make them null anyways. This adds a hashcode check and pretty error for it.
(cherry picked from commit f5386d4ca5)
* Fix version checker to compare the individual semver numbers instead of combining it together.
(cherry picked from commit ef5cd9d376)
* Update src/main/java/me/clip/placeholderapi/updatechecker/UpdateChecker.java
Co-authored-by: Andre_601 <11576465+Andre601@users.noreply.github.com>
(cherry picked from commit ccf4f59343)
* Re-add NotNull's
(cherry picked from commit 2bfd8e7e5e)
* Removed nullcheck from hashcode, and moved it up the chain.
* POJO to help with checking that expansions have all required methods implemented.
* Add method implementation checking and nullchecking for fields.
* Appease the Pigman
* Revert build.gradle dependencies change
* Fixed duplicate files
* Sync Dev with master (#659)
* Add contributing and expansion section
* Start using new Issue template system
* Create bug_report.yml
* Rename feature_request.md to feature_request_old.md
* Create feature_request.yml
* fix unique name
* Update feature_request_old.md
* Add Checkboxes
* Add checkboxes
* disable default issue body
* Delete bug_report_old.md
* Delete feature_request_old.md
* Rename bug_report_new.yml to bug_report.yml
* Check if deleting this fixed the PR...
* Use description in favour of about
* improve feature_request.md
* Update bug_report.yml
* Assign "Type: Issue (Unconfirmed)" label
* Use lists and not comma-separated string
* Update feature_request.yml
* Use id option for error and dump fields
* Add field for logs
* Remove deprecated issue_body type
* Update feature_request.yml
* Improve description of bug_report.yml
* Initial 1.17 Changes
* add render
* Revert build.gradle dependencies change
* Fixed duplicate files
Co-authored-by: PiggyPiglet <PiggyPiglet@users.noreply.github.com>
Co-authored-by: darbyjack <admin@glaremasters.me>
* Initial test on adventure
* started moving to pure adventure
* finished kyori impl
* added 1.17 to nmsversion (what does this even do)
* removed dev for release
* added dev back
* Switch to differen wiki action
Co-authored-by: darbyjack <admin@glaremasters.me>
Co-authored-by: ElijahRus250 <64851720+ElijahRus250@users.noreply.github.com>
Co-authored-by: PiggyPiglet <PiggyPiglet@users.noreply.github.com>
Co-authored-by: Huynh Tien <huynhqtienvtag@gmail.com>
Co-authored-by: Vaishnav Anil <vaishnavanil7th@gmail.com>
Co-authored-by: Starmism <iamstarmism@gmail.com>
Co-authored-by: PiggyPiglet <noreply@piggypiglet.me>
renamed rawcost to fullcost.
added costmax
```%tokenenchant_<enchantment>_costmax% : cost to increment the enchantmnt level to its maax one from the current level
%tokenenchant_<enchantment>_fullcostmax% : cost to enchant the max level from 0 level
%tokenenchant_<enchantment>_fullcost_<X>% : cost to enchant the <X> level from 0 level
```
* Add contributing and expansion section
* Start using new Issue template system
* Create bug_report.yml
* Rename feature_request.md to feature_request_old.md
* Create feature_request.yml
* fix unique name
* Update feature_request_old.md
* Add Checkboxes
* Add checkboxes
* disable default issue body
* Delete bug_report_old.md
* Delete feature_request_old.md
* Rename bug_report_new.yml to bug_report.yml
* Check if deleting this fixed the PR...
* Use description in favour of about
* improve feature_request.md
* Update bug_report.yml
* Assign "Type: Issue (Unconfirmed)" label
* Use lists and not comma-separated string
* Update feature_request.yml
* Use id option for error and dump fields
* Add field for logs
* Remove deprecated issue_body type
* Update feature_request.yml
* Improve description of bug_report.yml
* Initial 1.17 Changes
* add render
* Revert build.gradle dependencies change
* Fixed duplicate files
* Initial test on adventure
* started moving to pure adventure
* finished kyori impl
* added 1.17 to nmsversion (what does this even do)
* removed dev for release
* added dev back
Co-authored-by: PiggyPiglet <PiggyPiglet@users.noreply.github.com>
Co-authored-by: darbyjack <admin@glaremasters.me>
Co-authored-by: PiggyPiglet <noreply@piggypiglet.me>
* Attempt at fixing 413
This is my (miserable) attempt at fixing #413
These changes basically fix some potential threading issues and (probably) #413
Local tests went fine for me, but more tests are required.
* Remove delay, fixed -> cached thread pool
* Refactored `TimeUtil` utility class.
* Minimized `TimeUtil#getRemaining`.
* Fixed a bug regarding how days and hours were calculated in `TimeUtil#getTime`.
* Ditched the use of `int`s and use `long`s instead.
* Implemented `int`-taking methods because my dumb ass didn't think it would break.
* First step to make automated wiki action
* Add wiki folder and files
* Only trigger on master branch
* Add dump command
* Update Plugins-using-PlaceholderAPI.md
* Create README.md
* Update README.md
* Ignore the readme file
* Update files from wiki
* Update wiki pages
* began rewriting command system
* began rewriting command system
* updated formatting
* added new info command
* added new reload command
* updated new parse command to support all three parsing types
* added new commands to command router
* deleted old unused commands
* removed parserel
* added new expansion register and unregister commands
* deleted unused commands
* fixed annotation order
* added labels helper to command
* updated alias method to return an immutable view
* updated params param with unmodifiable annotation
* updated router to build an immutable map of the commands
* began rewriting command system
* updated formatting
* added new info command
* added new reload command
* updated new parse command to support all three parsing types
* added new commands to command router
* deleted old unused commands
* removed parserel
* added new expansion register and unregister commands
* deleted unused commands
* fixed annotation order
* added labels helper to command
* updated alias method to return an immutable view
* updated params param with unmodifiable annotation
* updated router to build an immutable map of the commands
* updated plugin class to use new command router
* updated switch to break on parse match
* updated register completions to suggest file names
* updated router to allow entering labels in any case
* updated parse command to send message to players as components
* added command dispatching parsing
* moved new commands into local package
* added helper functions for filtering and suggesting
* updated imports, updated tab completion to use helper functions
* added start of ecloud commands
* replace ecloud enable and disable commands with single toggle command evaluator
* deleted unused commands
* updated commands to use helper functions for suggesting
* updated downloading to use completablefuture, updated all methods to use streams exclusively
* updated to use the config instead of a null check
* deleted old commands system
* finished new command system
* updated to use new method from cloud manager
* fixed annotation ordering and added missing annotations
* updated ecloud subcommands to have a more specific permission
* updated plugin.yml with the new permissions, (and also fixed its formatting)
* fixed annotations intellij missed
* this should probably be there...
* added abstracted replacer api, and both char and regex based implementations
* added test dependencies for jmh and junit
* added unit tests and benchmarks for the replacer implementations
* updated replacers to accept specific closure types, added test to verify malformed placeholder handling
* updated jmh to 1.23, updated junit to 5.6.2
* Save Cacheable expansions data on shutdown
* Prepare for 1.16
* 1.16.1 is out apparently
* Further fixes, still not done
* Inline JSONMessages & fix for 1.16
* Done :O
* Done for real now, (hopefully)
* Changed to static instead of DI for plugin instance
* Cleanup
* Modified tab completions. Removed extra command.
* Apparently this is needed
* Started cleaning stuff up
basically just pushing so I can continue on laptop
* did more cleaning, probs like half way done
* more cleaning. reverted back to a min arg system somewhat similar to what frosty had, but less boilerplate.
* Started debugging and fixing runtime/compile errors
* Fixed bugs, still needs thorough testing
* Re-enable metrics
* relocated stuff again
* - Remove json message relocation
- uncomment other relocations
- reformat pom
- remove useless scope declaration
- Fix metrics constructor
- Switch commands to use inline json message
Co-authored-by: iGabyTM <contactgabytm@gmail.com>
Co-authored-by: darbyjack <admin@glaremasters.me>
Co-authored-by: PiggyPiglet <noreply@piggypiglet.me>
By default plugins are loaded later. (post world) This complicates hooking into PlaceholderAPI from other plugins that load directly at startup as PlaceholderAPI isn't available yet at that point.
* Updated README.md
Added a bit of formatting, some links, and the PAPI logo.
Information on contributing and developing expansions still needs to be added, but that could possibly be added into the Wiki?
* Updated README.md
Added link to the logo image, and moved CI link to the end of the file.
This branch is home of the [PlaceholderAPI Wiki's][wiki] source.
It allows us to properly manage the wiki and it allows you to contribute changes to it.
## Contributing to the Wiki
Contributions to the wiki are always welcome, granted they follow specific rules and guidelines to ensure a consistent styling across all pages.
Please read this readme file carefully, as it contains important information on how you contribute to the wiki and what to look out for.
### Prerequisites
This readme file will cover the basics of using Git, GitHub and MkDocs, but it is highly recommended to learn about these tools yourself before contributing, to avoid possible issues.
If you have questions about any of those, do not hesitate to ask. We will try to assist you as good as we can.
Before you now start working on the wiki should make sure that the following has been done already:
- You installed and configured Git.
- You installed and configured Python. At least 3.10 is required for MkDocs to work.
- You installed MkDocs and all required dependencies. You can just install `mkdocs-material` through pip and all necessary dependencies will be included.
Should the above be completed can we start with the process of contributing to this wiki.
### 1. Fork the Repository
> **Already have a fork?** Skip to the [next step!](#2-switch-target-branch)
You need to make a fork of the PlaceholderAPI Repository in order to make your changes to it.
To create a fork, click the button on the top right that says "Fork". This will open a new page where you can set specific options such as the name of the fork (Defaults to the name of this repository), the account/organization this repo should be forked to and whether only the master branch should be included.
It is crucial to set ``Copy the `master` branch only`` to **not** be checked, or else the wiki branch won't be included in your fork.

Once you confirm the fork will a copy of the repository be created under the user/organization you chose. This process should only take a few seconds and you will be automatically redirected to your fork after it completed.
You can now move on to the next step.
### 2. Switch target branch
By default will you be on the default branch of the repository (`master`). To now get to the wiki branch, click the button that says `master` (Located to the left of the text reading `n Branches`).
A dropdown should open with all the branches you included during the forking. Select the `wiki` branch in the list to switch to it.
This text indicates that your fork is outdated and should be updated with the latest changes from the original repository. There should be a button labeled `Update branch` that you can press to update your fork's `wiki` branch.
It is recommended to clone your fork to your PC to utilize tools such as MkDocs' live-preview to see the changes made.
To clone your fork to your PC, first choose where it should be cloned towards. Cloning the repository will create a new folder with the repository's content in it, so if you choose to clone into a folder named `GitHub` will this result in `GitHub/PlaceholderAPI` being created.
Copy the below command and execute it in your git-bash console (Replace `<user>` with the user/organization name of your fork):
```sh
$ git clone -b wiki https://github.com/<user>/PlaceholderAPI
```
This will clone the repository onto your PC with the `wiki` branch being selected by default.
You should now navigate into your cloned repository in the git-bash console using `cd PlaceholderAPI`.
### 5. Create a new branch (Recommended)
This step is optional, but recommended to keep the main wiki branch clean from any changes, which avoids possible merge conflicts in the future.
To create a new branch, execute the command below (Replace `<branch>` with the branch name you want to use):
```sh
$ git checkout -b <branch>
```
> [!TIP]
> In case you already created a branch on GitHub before cloning the repository can you use `git switch <branch>` to switch to this branch.
### 6. Make your changes
It is now time to make your changes. It is recommended to use MkDocs and its live-preview feature to see your changes applied in real time whenever you save a file.
To use the live-preview, run `mkdocs serve` in the same folder where the `mkdocs.yml` file is located. This should start a server on `http://127.0.0.1:8000` that you can open in your browser. You can also append the `--open` argument to the command to make MkDocs open the preview directly, avoiding the need of having to open it yourself.
Should the command not work, check that you actually installed MkDocs and any required dependencies. The easiest way is to just execute `pip install mkdocs-material` to download the Material for MkDocs theme alongside additional dependencies, including MkDocs.
To cancel the live preview, simply press <kbd>Ctrl</kbd>+<kbd>C</kbd> in the git-bash terminal to shut the live preview server down.
#### Markdown Formatting Rules
> [!IMPORTANT]
> Please also see the [Wiki Structure](#wiki-structure) section for more details on the formatting!
MkDocs utilizes Python-Markdown, a Python library used for parsing Markdown into HTML. This library follows very specific rules in regards to Makrkdown formattings that you need to keep in mind while editing files.
Here are some noteworthy points:
- Lists require an empty line before themself to be rendered as such. This means that a list cannot start directly after some text, but needs a gap before itself.
- New lines in lists (No matter if ordered or unordered) need to have an indent of 4 spaces.
- This indent also applies to nested list entries.
- In certain situations will you also need to keep an empty line between the list entry and the new line.
- Links to other files should be relative and also include the file name itself. They will be parsed into proper `a` tags pointing to the page when rendered.
In addition are extensions used to further enhance the default markdown formatting with additional features. Such features include:
- Admonition blocks (Also known as callouts. [[Documentation][admo-docs]])
- Details (`<details>` HTML tag. [[Documentation][details-docs]])
- Tabs (Way of displaying different content you can toggle between. [[Documentation][tabs-docs]])
- Automatic linking of issues, PRs, discussions using `!<id>`, `#<id>` and `?<id>` respectively (Uses [MagicLink extension][ml-docs])
### 7. Commit and push your changes
Once you're happy with your changes is it time to commit them back to your fork on GitHub to then PR to the upstream repository.
To commit your changes, you may first need to add the files to commit. To do this, run `git add <file-path>` where `<file-path>` is the path to the modified file relative to the repository's root.
As an example, changing `placeholder-list.md` would require you to execute `git add docs/users/placeholder-list.md`.
If you're sure that only files that should be commited got changed can you use `git add .` to add all changed files.
Once this step is done can you execute `git commit`. Doing so will open a text editor where you can write the commit message in. Try to keep it short and simple. You can also append the `-m` argument followed by text inside double quotes to the command to directly set the commit message without having to use a text editor.
Once your changes got committed will you need to execute `git push`. In case you created a new branch in your local repository will you need to add `--set-upstream origin <branch>` with `<branch>` being the name of the branch you want to use on your fork on GitHub.
Your changes should now be on your GitHub Fork.
### 8. Create a Pull request
Your final step now is to make a Pull request to the original repository. GitHub should already give you a prompt regarding recent changes on your branch.
Clicking the "Compare & pull request" button will open a diff view page showing a comparison between your changes and the branch of the upstream. You can double check that it targets the upstream by checking that there is a `base repository` option pointing to `PlaceholderAPI/PlaceholderAPI`. Should there only be a `base` option does it mean that you target branches on your own repository. To fix this, click the text that says "compare across forks" to toggle. You can then select `PlaceholderAPI/PlaceholderAPI` as the `base repository` and `head repository` to your fork.
By default does GitHub select the `master` branch as the default. Change it to `wiki` while also changing the branch of your fork to whatever you made your changes on (Should be selected by default).
Should there be changes that can be merged will the "Create pull request" button light up, allowing you to make a pull request.
Press the button, fill out the title and body of the pull request and create it.
Congratulations! You made a Pull request for the wiki!
----
## Wiki Structure
The wiki has specific rules in regards to its own structure. This is to keep a level of consistency across all pages when viewed at in their raw (unparsed) form.
### General Rules
The following rules apply to all pages:
1. Unordered lists always use `-` and not `*` to avoid confusion with `*italic text*`
2. Links to other pages always need to be relative, meaning they should not start with `/`.
3. An empty line between a header (Any level) and text should be set.
### Placeholder List Rules
The following rules apply specifically to entries in the [Placeholder List][placeholder-list] page:
1. Entries need to be in alphabetical order.
- Should an entry with the name already exist will you need to add yours after it.
2. An entry follows this specific format:
````markdown
### [<name>](<link>)
/// <command>
///
<text>
```
<placeholders>
```
````
- `<name>` is the name of the Placeholder expansion you add.
- `<link>` is a link to the plugin this expansion is made for. If the expansion is not for a plugin should no link be added (Only `- ### <name>` be used).
- Links to spigot pages need to be sanitized, meaning a link such as `https://www.spigotmc.org/resources/placeholderapi.6245/` becomes `https://www.spigotmc.org/resources/6245/`
- `<command>` needs to be replaced with one of the following values, depending on how the expansion can be added:
- Should your expansion be built-in into a Plugin, add `integrated | Built into Plugin`
- Should your expansion be obtainable via the [`/papi ecloud download`][download-command] command, add `command | papi ecloud download <name of expansion>`
- Should your expansion only be downloadable via external sources (i.e. a GitHub Release), add `download | <link to download>`
- `<text>` is an optional text that can be used to point to extra documentation. Please keep it short and simple.
- `<placeholders>` would be all available placeholders. Each entry should be on a new line.
- Please avoid explicit examples and instead use `<>` and `[]` to indicate required or optional values (i.e. instead of `%expansion_SomePlayer%` it would be `%expansion_<player>%`)
3. Make sure to also add an entry to the list at the top of the page, linking to your entry.
4. Should your entry have entries before and/or after it will you need to add horizontal lines (`----`) to separate yours from these entries. Keep an empty line between the horizontal line and any entry.
> A [online tool][papi-list-gen] exists for your convenience to create the markdown for a new entry.
### Plugins using PlaceholderAPI Rules
The following rules apply specifically to entries in the [Plugins using PlaceholderAPI][plugins-using-placeholderapi] page:
1. Entries need to be in alphabetical order.
- Should an entry with the name already exist will you need to add yours after it.
2. An entry follows this specific format:
````markdown
- [<name>](<link>)
- [?] Supports placeholders.
- [?] Provides own placeholders. [<link>]
````
- `<name>` is the name of the Plugin you add.
- `<link>` is a link to the Plugin page. Should no plugin page exist can a GitHub repo or no link (Just `- <name>`) be used instead.
- Links to spigot pages need to be sanitized, meaning a link such as `https://www.spigotmc.org/resources/placeholderapi.6245/` becomes `https://www.spigotmc.org/resources/6245/`
- `[?]` needs to be replaced with either `[x]` or `[ ]` depending on if the statement is true or not.
- `Supports placeholders.` means that the Plugin allows the usage of any placeholder through PlaceholderAPI in its messages, settings, etc.
- `Provides own placeholders.` means that a Placeholder expansion is available that provides placeholders through PlaceholderAPI for this plugin.
- `<link>` should be replaced with one of two possible options, depending on whether there is a placeholder expansion listed in the [Placeholder List][placeholder-list] page.
- In case there is one should `[**Link**](placeholder-list.md#<expansion>)`, where `<expansion>` being the name used in the list, be used.
- In case there is no entry should `Link` be used.
> A [online tool][plugin-list-gen] exists for your convenience to create the markdown for a new entry.
description:How to create configurable expansions in Hytale.
---
# Hytale's Configurable<T> Interface
Unlike in spigot, in Hytale PAPI does not forward through Hytale's configuration API and instead implements its own. Effectively you'll be required to create a class representing your configuration section in PlaceholderAPI's main config.yml, and PAPI will handle the rest.
public CoolExpansionConfig(String test, String dateFormat) {
this.test = test;
this.dateFormat = dateFormat;
}
public String test() {
return test;
}
public String dateFormat() {
return dateFormat;
}
}
```
Your config class needs to represent your config structure exactly. The only difference is in naming, in the above example, dateFormat will be converted to snake case (date_format) when reading the yaml. The above class will look like this in PAPI's config:
Once created, we need to tell PAPI about it. In your PlaceholderExpansion class, implement `Configurable<CoolExpansionConfig>`, you'll then need to also implement the 2 required methods.
```java { .annotate title="CoolExpansion.java" }
public final class CoolExpansion extends PlaceholderExpansion implements Configurable<CoolExpansionConfig> {
@Override
public Class<CoolExpansionConfig> provideConfigType() {
return CoolExpansionConfig.class;
}
@Override
public CoolExpansionConfig provideDefault() {
return new CoolExpansionConfig("wew", "dd/mm/yyyy");
}
@Override
public String onPlaceholderRequest(PlayerRef player, String params) {
final CoolExpansionConfig config = getExpansionConfig(CoolExpansion.class);
return switch(params) {
case "test" -> config.test();
case "date_format" -> config.dateFormat();
default -> null;
};
}
}
```
That's pretty much it. PAPI will generate the default yaml from the values you provide in `provideDefault()` and write it to the PAPI config, then whenever your expansion starts it'll read the values from the config and put them into a CoolExpansionConfig object accessible via `PlaceholderExpansion<T>.getExpansionConfig(Class<T extends Configurable<T>>)`
description:Comprehensive guide on how to create a PlaceholderExpansion for other plugins to use through PlaceholderAPI.
---
# Creating a PlaceholderExpansion
/// warning | Important
These pages cover the creation of a PlaceholderExpansion for both Spigot/Paper-based and Hytale Servers!
Unless mentioned otherwise the provided code examples function for both platform types.
Please always check code blocks for :material-plus-circle: Icons with additional info!
///
This page will cover how you can create your own [`PlaceholderExpansion`][placeholderexpansion] which you can either integrate into your own plugin (Recommended) or [upload to the eCloud](expansion-cloud.md).
It's worth noting that PlaceholderAPI relies on expansions being installed. PlaceholderAPI only acts as the core replacing utility while the expansions allow other plugins to use any installed placeholder in their own messages.
You can download expansions either directly from the eCloud yourself, or download them through the [download command of PlaceholderAPI](../users/commands.md#papi-ecloud-download).
- [Making an Internal Expansion](#making-an-internal-expansion)
- [Full Example](#full-example-internal)
- [Register your Expansion](#register-your-expansion)
- [Making an External Expansion](#making-an-external-expansion)
- [Full Example (Without Dependency)](#full-example-external-no-dependency)
- [Full Example (With Dependency)](#full-example-external-dependency)
- [Making a relational Expansion](#making-a-relational-expansion)
- [Full Example](#full-example-relational)
## Getting started
For starters, you need to decide what type of [`PlaceholderExpansion`][placeholderexpansion] you want to create. There are various ways to create an expansion. This page will cover the most common ones.
### Common Expansion Parts
All shown examples will share the same common parts that belong the the [`PlaceholderExpansion`][placeholderexpansion] class.
In order to not repeat the same basic info for each method throughout this page, and to greatly reduce the overall length, we will cover the most basic/necessary ones here.
#### Basic PlaceholderExpansion Structure
/// note |
Tab the :material-plus-circle: icons in the code block below for additional information.
public class SomeExpansion extends PlaceholderExpansion {
@Override
@NotNull
public String getAuthor() {
return "Author"; // (1)
}
@Override
@NotNull
public String getIdentifier() {
return "example"; // (2)
}
@Override
@NotNull
public String getVersion() {
return "1.0.0"; // (3)
}
// These methods aren't overriden by default.
// You have to override one of them.
@Override
public String onRequest(OfflinePlayer player, @NotNull String params) {
// (4)
}
@Override
public String onPlaceholderRequest(Player player, @NotNull String params) {
// (5)
}
@Override
public String onPlaceholderRequest(PlayerRef player, @NotNull String params) {
// (6)
}
}
```
1. This method allows you to set the name of the expansion's author. May not be null.
2. The identifier is the part in the placeholder that is between the first `%` (or `{` for bracket placeholders) and the first `_`.
The identifier may not be null nor contain `%`, `{`, `}` or `_`.
If you still want to use them in your expansion name, override the `getName()` method.
3. This method returns the version of the expansion. May not be null.
Due to it being a string are you not limited to numbers alone, but it is recommended to stick with a number pattern.
PlaceholderAPI uses this String to compare with the latest version on the eCloud (if uploaded to it) to see if a new version is available.
If your expansion is included in a plugin, this does not matter.
4. Called by PlaceholderAPI to have placeholder values parsed.
When not overriden will call `onPlaceholderRequest(Player, String)`, converting the OfflinePlayer to a Player if possible or else providing `null`.
Using this method is recommended for the usage of the OfflinePlayer, allowing to use data from a player without their presence being required.
**Parameters**:
- `player` - Nullable OfflinePlayer instance to parse placeholders against.
- `params` - Non-null String representing the part of the placeholder after the first `_` and before the closing `%` (or `}` for bracket placeholders).
5. Called by PlaceholderAPI through `onRequest(OfflinePlayer, String)` to have placeholder values parsed.
When not overriden will return `null`, which PlaceholderAPI will understand as an invalid Placeholder.
**Parameters**:
- `player` - Nullable Player instance to parse placeholders against.
- `params` - Non-null String representing the part of the placeholder after the first `_` and before the closing `%` (or `}` for bracket placeholders).
6. **Note:** Only exists for the Hytale Version of PlaceholderAPI!
Called by PlaceholderAPI through `onPlaceholderRequest(PlayerRef, String)` to have placeholder values parsed.
When `null` is returned will PlaceholderAPI treat it as invalid placeholder and return it unchanged.
**Parameters:**
- `player` - PlayerRef instance to parse placeholders against.
- `params` - Non-null String representing the part of the placeholder after the first `_` and before the closing `%` (or `}` for bracket placeholders).
/// note
Overriding `onRequest(OfflinePlayer, String)` or `onPlaceholderRequest(Player, String)` is not required if you [create relational placeholders](#making-a-relational-expansion).
///
----
## Making an Internal Expansion
Internal PlaceholderExpansions are classes directly integrated in the plugin they depend on.
This method of creating a PlaceholderExpansion is recommended as it has the following benefits:
- No `canRegister()` method override required. Since your expansion is part of the plugin it depends on is this override not required.
- Easier access to plugin data. Using dependency injection, you can more easily access data of your plugin such as config values.
/// warning | Important!
Internal PlaceholderExpansions are not automatically registered by PlaceholderAPI, due to them not being a separate jar file located in the expansion folder.
Please see the [Regsister your Expansion](#register-your-expansion) section for more details.
You are also required to override and set `persist()` to `true`. This tells PlaceholderAPI to not unload your expansion during plugin reload, as it would otherwise unregister your expansion, making it no longer work.
///
/// details | Full Example
attrs: { id: full-example-internal }
type: example
//// note | Important Notes
- Please see the [Basic PlaceholderExpansion Structure](#basic-placeholderexpansion-structure) section for an explanation of all common methods in this example.
- The below example is for a Spigot/Paper-based setup.
For a Hytale server, replace `me.clip` imports with `at.helpch` and replace `OfflinePlayer` with `PlayerRef` (Including the import).
Tab the :material-plus-circle: icons in the code block below for additional information.
if (Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) { // (1)
new SomeExpansion(this).register(); // (2)
}
}
}
```
1. We check that PlaceholderAPI is present and enabled on the server, or else we would get Exceptions.
Also, make sure you [set PlaceholderAPI as depend or softdepend](using-placeholderapi.md#set-placeholderapi-as-softdepend) in your plugin's `plugin.yml` file!
2. This registers our expansion in PlaceholderAPI. It also gives the Plugin class as dependency injection to the Expansion class, so that we can use it.
if (HytaleServer.get().getPluginManager().getPlugin(PluginIdentifier.fromString("HelpChat:PlaceholderAPI")) != null) {
new SomeExpansion(this).register();
}
}
}
```
///
----
## Making an External Expansion
External Expansions are separate Jar files located inside PlaceholderAPI's `expansions` folder, that contain the [`PlaceholderExpansion`][placeholderexpansion] extending class.
It is recommended to only make external Expansions for the following situations.
- Your expansion does not rely on a plugin.
- Your expansion depends on a plugin and you can't directly include it (Plugin is not your own).
Should the above cases not match your situation, meaning your expansion is for a plugin you maintain, is the creation of an [internal Expansion](#making-an-internal-expansion) recommended.
Some benefits of an external expansion include automatic (re)loading of your expansion by PlaceholderAPI and having the option to [upload it to the eCloud](expansion-cloud.md) allowing the download of it through the [`/papi ecloud download` command](../users/commands.md#papi-ecloud-download).
Downsides include a more tedious setup in terms of checking for a required plugin being present.
- Please see the [Basic PlaceholderExpansion Structure](#basic-placeholderexpansion-structure) section for an explanation of all common methods in this example.
- The below example is for a Spigot/Paper-based setup.
For a Hytale server, replace `me.clip` imports with `at.helpch` and replace `OfflinePlayer` with `PlayerRef` (Including the import).
Tab the :material-plus-circle: icons in the code block below for additional information.
////
This is an example expansion without any plugin dependency.
public class SomeExpansion extends PlaceholderExpansion {
@Override
@NotNull
public String getAuthor() {
return "Author";
}
@Override
@NotNull
public String getIdentifier() {
return "example";
}
@Override
@NotNull
public String getVersion() {
return "1.0.0";
}
@Override
public String onRequest(OfflinePlayer player, @NotNull String params) {
if (params.equalsIgnoreCase("placeholder1")) {
return "text1";
}
if (params.equalsIgnoreCase("placeholder2")) {
return "text2";
}
return null; // (1)
}
}
```
1. Reaching this means that an invalid params String was given, so we return `null` to tell PlaceholderAPI that the placeholder was invalid.
///
/// details | Full Example (With Dependency)
attrs: { id: full-example-external-dependency }
type: example
//// note | Important Notes
- Please see the [Basic PlaceholderExpansion Structure](#basic-placeholderexpansion-structure) section for an explanation of all common methods in this example.
- The below example is for a Spigot/Paper-based setup.
For a Hytale server, replace `me.clip` imports with `at.helpch` and replace `OfflinePlayer` with `PlayerRef` (Including the import).
Tab the :material-plus-circle: icons in the code block below for additional information.
////
This is an example expansion with a plugin dependency.
1. We set the value of this instance in the `canRegister()` method, which means that it can't be set to be final.
2. The name of the plugin this expansion depends on.
It is recommended to set this, as it would result in PlaceholderAPI reporting any missing plugin for your expansion.
3. **Note:** This only works on a Spigot/Paper-based server. A equivalent for Hytale servers is not yet known.
This does two things:
1. It sets the `plugin` instance to `SomePlugin` using Bukkit's PluginManager to retrieve a JavaPlugin instance that is cast to `SomePlugin`.
2. It checks if the retrieved instance is not null. If it is will this result in `canRegister()` returning false, resulting in PlaceholderAPI not loading our expansion.
4. Example of accessing data of the plugin's `config.yml` file.
5. Example of accessing data of the plugin's `config.yml` file.
6. Reaching this means that an invalid params String was given, so we return `null` to tell PlaceholderAPI that the placeholder was invalid.
///
----
## Making a relational Expansion
/// note | Notes
- Relational Placeholders always start with `rel_` to properly identify them. This means that if you make a relational placeholder called `friends_is_friend` would the full placeholder be `%rel_friends_is_friend%`.
- For Hytale, replace any mention of `Player` with `PlayerRef` and update any Imports in the code to `at.helpch` and related Hytale ones.
///
Relational PlaceholderExpansions are special in that they take two players as input, allowing you to give outputs based on their relation to each other.
To create a relational expansion you will need to implement the [`Relational`][relational] interface into your expansion. You also still need to extend the [`PlaceholderExpansion`][placeholderexpansion] class.
Implementing this interface will add the `onPlaceholderRequest(Player, Player, String)` with the first two arguments being the first and second player to use and the third argument being the content after the second `_` and before the final `%` (Or `}` if bracket placeholders are used) in the placeholder.
/// details | Full Example
attrs: { id: full-example-relational }
type: example
//// note |
Please see the [Basic PlaceholderExpansion Structure](#basic-placeholderexpansion-structure) section for an explanation of all common methods in this example.
Tab the :material-plus-circle: icons in the code block below for additional information.
////
This is a complete example of using relational placeholders.
For the sake of simplicity are we using the [internal Expansion setup](#making-an-internal-expansion) here and assume that `SomePlugin` offers a `areFriends(Player, Player)` method that returns true or false based on if the players are friends or not.
public String onPlaceholderRequest(Player one, Player two, String identifier) {
if (one == null || two == null) {
return null; // (5)
}
if (identifier.equalsIgnoreCase("friends")) { // (6)
if (plugin.areFriends(one, two)) {
return ChatColor.GREEN + one.getName() + " and " + two.getName() + " are friends!";
} else {
return ChatColor.RED + one.getName() + " and " + two.getName() + " are not friends!";
}
}
return null; // (7)
}
}
```
1. Mockup plugin used to showcase the use of dependency injection to access specific plugin related data.
2. We can use the authors set in the plugin's `plugin.yml` file as the authors of this expansion.
3. Since our expansion is internal can this version be the same as the one defined in the plugin's `plugin.yml` file.
4. This needs to be set, or else will PlaceholderAPI unregister our expansion during a plugin reload.
5. Our placeholder requires both players to be present, so if either one is not will this return null.
6. In case the identifier matches (Meaning the placeholder is `%rel_example_friends%` or `{rel_example_friends}`) will we check if Player one and two are friends through our plugin's `areFriends(Player, Player)` method.
Should they be friends, return green text saying they are and else return red text saying they aren't.
7. Reaching this means that an invalid params String was given, so we return `null` to tell PlaceholderAPI that the placeholder was invalid.
Don't forget to [register your expansion](#register-your-expansion).
description:Information about PlaceholderAPI's expansion cloud, including how to submit your own expansion or update it.
---
# eCloud
## About
PlaceholderAPI uses an expansion-cloud (A website that has all kinds of expansions stored), to download jar files, that contain the placeholders for it to use.
The expansion-cloud can be seen under https://ecloud.placeholderapi.com
## How it works
PlaceholderAPI connects to the ecloud on startup of your server, to check if the cloud is available and how many expansions are available on it.
If you run [`/papi ecloud download <expansion>`](../users/commands.md#papi-ecloud-download), PlaceholderAPI will connect to the site to first check if the specified expansion exists and then downloads it if it does.
/// note
PlaceholderAPI can only download expansions that are verified on the eCloud. Any unverified expansion needs to be downloaded manually.
///
You can disable the connection to the cloud by setting `cloud_enabled` in the config.yml to false.
## Adding your own expansion
You can add your own expansion to the expansion-cloud for others to use.
In order to do that, you have to follow those steps:
1. Make sure you have created a seperate jar file as described in the [Creating a PlaceholderExpansion](creating-a-placeholderexpansion.md) page.
2. Create an account on the site, or log in, if you already have one.
3. Click on `Expansions` and then on [`Upload New`](https://ecloud.placeholderapi.com/expansions/new/).
4. Fill out the required information. `Source URL` and `Dependency URL` are optional and would link to the source code and any dependency (plugin) of your expansion respectively.
5. Click on the button that says `Choose an file...` and select the jar of your expansion.
/// warning |
**Important!**
Make sure, that the name of the jar file contains the same version like you set in the version field.
///
6. Click on `Submit Expansion`
Your expansion is now uploaded and will be reviewed by a moderator.
If everything is ok will your expansion be approved and will be available on the ecloud for PlaceholderAPI*.
/// info | Note for Hosts
You can block specific expansions from being downloaded using the `PAPI_BLOCKED_EXPANSIONS` environment variable.
Just define it with a value of comma-separated expansion names that should not be downloadable by PlaceholderAPI.
This feature exists since version 2.11.4 of PlaceholderAPI.
///
## Updating your expansion
Before you update, please note the following:
Updating your expansion will automatically make it unverified, requiring a site moderator to verify it again. This was made to combat malware from being uploaded and distributed.
To update your expansion, you first have to go to the list of [your expansions](https://ecloud.placeholderapi.com/expansions/manage/).
For that click on `Expansions` and select `Your Expansions`.
After that, follow those steps:
1. Click the name of the expansion, that you want to update.
2. Click on the button that says `Version`
3. Click on `Add Version`
4. Fill out the fields and upload the new jar.
/// warning |
**Important!**
Make sure, that the name of the jar file contains the same version like you set in the version field.
///
5. Click on `Save Changes`
Your version should now be uploaded to the eCloud. You can now ask a responsible staff member on the [HelpChat Discord](https://discord.gg/helpchat) to review your expansion to get it re-verified. Please remain patient and polite when asking.
## Downloading a specific expansion version
In some cases, you may want to use a specific, older version of an expansion. Such a case could be for example, when you run an old server version and the newest version of an expansion uses methods that aren't available on that particular server version, causing compatability issues.
For that case is there a way, to download a specific version of expansion. You can download the expansion either manually, or through PlaceholderAPI itself.
Here is how you can do it for each.
### Download with PlaceholderAPI
This is the easiest of both methods since it requires the least amount of effort.
Run the following command in-game or in your console to download a specific version:
To find out, what versions are available for the expansion, run [`/papi ecloud info <expansion>`](../users/commands.md#papi-ecloud-info).
After you downloaded the specific version, run [`/papi reload`](../users/commands.md#papi-reload) to refresh the installed expansions.
### Download manually
To download an expansion manually, you first have to connect to the website and go to the expansion of your choice.
There, you click on the button that says `Version` and click on the download-icon of the version you want to download.
Finally, stop your server, upload the jar to the folder in `/plugins/PlaceholderAPI/expansions` (Make sure to delete the old jar, if there's already one) and start the server again.
description:Pages aimed at plugin developers who want to use PlaceholderAPI in their own plugin or want to make their own PlaceholderExpansion.
---
# Dev Guides
The pages listed under this section are meant for developers of plugins who want to either create PlaceholderExpansions or want to otherwise work with PlaceholderAPI (i.e. supporting external placeholders through it).
----
<div class="grid cards hide-list" markdown>
- ### Using PlaceholderAPI
----
Guide on how to use PlaceholderAPI in your own plugin.
- [:octicons-chevron-right-16: Go to Page](using-placeholderapi.md)
- ### Creating a PlaceholderExpansion
----
Comprehensive guide on how to create a PlaceholderExpansion for other plugins to use through PlaceholderAPI.
- [:octicons-chevron-right-16: Go to Page](creating-a-placeholderexpansion.md)
- ### Using the Hytale Configuration API
----
How to create a configurable expansion for Hytale
- [:octicons-chevron-right-16: Go to Page](configuration-api-hytale.md)
- ### eCloud
----
Information about PlaceholderAPI's expansion cloud, including how to submit your own expansion or update it.
- [:octicons-chevron-right-16: Go to Page](expansion-cloud.md)
description:Guide on how to use PlaceholderAPI in your own plugin.
---
# Using PlaceholderAPI
This page is about using PlaceholderAPI in your own plugin, to either let other plugins use your plugin, or just use placeholders from other plugins in your own.
Please note, that the examples in this page are only available for **PlaceholderAPI 2.10.0 (1.0.0 for Hytale version) or newer**!
## First steps
### Add PlaceholderAPI to your Project
Before you can actually make use of PlaceholderAPI, you first have to import it into your project.
Use the below code example matching your project type and dependency manager.
/// details | What is `{papiVersion}`/`{papiHytaleVersion}`?
type: question
Using Javascript, `{papiVersion}` and `{papiHytaleVersion}` is replaced with the latest available API version of PlaceholderAPI for Minecraft and Hytale respectively.
Should you see the placeholder as-is does it mean that you either block Javascript, or that the version couldn't be obtained in time during page load.
You can always find the latest version matching the API version on the [releases tab](https://github.com/PlaceholderAPI/PlaceholderAPI/releases) of the GitHub Repository.
///
### Set PlaceholderAPI as (soft)depend
Next step is to go to your plugin.yml or paper-plugin.yml and add PlaceholderAPI as a depend or softdepend, depending (no pun intended) on if it is optional or not.
/// tab | :simple-spigotmc: plugin.yml
//// tab | Optional dependency
///// note |
Tab the :material-plus-circle: icons in the code block below for additional information.
/////
```{ .yaml .annotate title="plugin.yml" }
name: ExamplePlugin
version: 1.0
author: author
main: com.example.plugin.ExamplePlugin
softdepend: ["PlaceholderAPI"] # (1)
```
1. This sets PlaceholderAPI as an optional dependency for your plugin.
////
//// tab | Required dependency
///// note |
Tab the :material-plus-circle: icons in the code block below for additional information.
/////
```{ .yaml .annotate title="plugin.yml" }
name: ExamplePlugin
version: 1.0
author: author
main: com.example.plugin.ExamplePlugin
depend: ["PlaceholderAPI"] # (1)
```
1. This sets PlaceholderAPI as a required dependency for your plugin.
Tab the :material-plus-circle: icons in the code block below for additional information.
/////
```{ .yaml .annotate title="paper-plugin.yml" }
name: ExamplePlugin
version: 1.0
author: author
main: com.example.plugin.ExamplePlugin
dependencies:
server:
PlaceholderAPI:
load: BEFORE # (1)
required: false
```
1. Load order is relative to the Dependency.
This means that in this example, PlaceholderAPI is loaded **before** your plugin.
////
//// tab | Required dependency
///// note |
Tab the :material-plus-circle: icons in the code block below for additional information.
/////
```{ .yaml .annotate title="paper-plugin.yml" }
name: ExamplePlugin
version: 1.0
author: author
main: com.example.plugin.ExamplePlugin
dependencies:
server:
PlaceholderAPI:
load: BEFORE # (1)
required: true
```
1. Load order is relative to the Dependency.
This means that in this example, PlaceholderAPI is loaded **before** your plugin.
////
///
/// tab | manifest.json (Hytale)
//// tab | Optional dependency
```{ .json .annotate title="manifest.json" }
{
"Group": "com.example",
"Name": "ExamplePlugin",
"Version": "1.0",
"Main": "com.example.plugin.ExamplePlugin",
"OptionalDependencies": {
"HelpChat:PlaceholderAPI": ">=1.0.8"
}
}
```
////
//// tab | Required dependency
```{ .json .annotate title="manifest.json" }
{
"Group": "com.example",
"Name": "ExamplePlugin",
"Version": "1.0",
"Main": "com.example.plugin.ExamplePlugin",
"Dependencies": {
"HelpChat:PlaceholderAPI": ">=1.0.8"
}
}
```
////
///
## Adding placeholders to PlaceholderAPI
A full guide on how to create expansions can be found on the [Creating a PlaceholderExpansion](creating-a-placeholderexpansion.md) page.
## Setting placeholders in your plugin
PlaceholderAPI offers the ability, to automatically parse placeholders from other plugins within your own plugin, giving the ability for your plugin to support thousands of other placeholders without depending on each plugin individually.
To use placeholders from other plugins in your own plugin, you simply have to [(soft)depend on PlaceholderAPI](#set-placeholderapi-as-softdepend) and use the `setPlaceholders` method.
It is also important to point out, that any required plugin/dependency for an expansion has to be on the server and enabled, or the `setPlaceholders` method will just return the placeholder itself (do nothing).
/// info | New since 2.12.0
Starting with version 2.12.0 is it now possible to provide Components from the Adventure library to have placeholders parsed in.
In order to use this new feature are the following things required to be true:
- Your plugin runs on a Paper-based Server. Spigot-based servers will not work!
- You use `PAPIComponent` instead of `PlaceholderAPI` to parse Components.
///
/// tab | Spigot, Paper, ...
The following is an example plugin that sends `%player_name% joined the server! They are rank %vault_rank%` as the Join message, having the placeholders be replaced by PlaceholderAPI.
//// note |
The below example assumes a **soft dependency** on PlaceholderAPI to handle PlaceholderAPI not being present more decently.
Tab the :material-plus-circle: icons in the code block below for additional information.
////
```{ .java .annotate title="JoinExample.java" }
package com.example.plugin;
import me.clip.placeholderapi.PlaceholderAPI;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.plugin.java.JavaPlugin;
import me.clip.placeholderapi.PlaceholderAPI;
public class JoinExample extends JavaPlugin implements Listener {
@Override
public void onEnable() {
if (Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) {
1. We check that PlaceholderAPI is present and enabled to then register events to handle (See below).
2. In case PlaceholderAPI is not present are we reporting this issue and disable the plugin.
3. Using `PlaceholderAPI.setPlaceholders(Player, String)` we can parse `%placeholder%` text in the provided String, should they have a matching expansion and said expansion return a non-null String.
In our example are we providing a text containing `%player_name%` and `%vault_rank%` to be parsed, which require the Player and Vault expansion respectively.
Example output: `Notch joined the server! They are rank Admin`
//// info | New since 2.12.0
Using `placeholderapi-papi` and `PAPIComponents` instead of `PlaceholderAPI` allows you to parse placeholders inside Adventure Components.
////
///
/// tab | Hytale
The following is an example plugin that modifies the chat to include a format before player messages. It relies on the [Player Expansion](https://ecloud.placeholderapi.com/expansions/player-hytale/), [Luckperms Expansion](https://ecloud.placeholderapi.com/expansions/luckperms-hytale/), and [HyFaction Expansion](https://ecloud.placeholderapi.com/expansions/hyfaction/).
//// info | Thread Safety Warning
Due to Hytale's api design, certain components can only be accessed by specific threads. For full compatibility with placeholderapi, you need to call setPlaceholders on the world thread the player is in. `player.getWorld().execute(() -> )`
By default for player commands, you're already going to be on the world thread so it's not so much of an issue, but you do need to consider it if you're trying to do async work and then call PAPI, e.g. async player chat.
1. We tell the server to call `onPlayerChat` whenever a `PlayerChatEvent` fires.
2. PlaceholderAPI offers multiple `setPlaceholders` methods that can either return a `String` or a `Message` object, depending on your needs.
Note that these methods require input of the same type: `setPlaceholders(PlayerRef, String)` for String and `setPlaceholders(PlayerRef, Message)` for Messages.
description:List of frequently asked questions and their answers.
---
# FAQ
Here are frequently asked questions about stuff related to PlaceholderAPI.
## What is an Expansion?
An expansion (or PlaceholderExpansion) refers to either a jar file or part of a plugin that provides placeholders to use through PlaceholderAPI itself.
Whether said expansion is a separate jar file or part of a plugin depends on the expansion itself and its main purpose.
Expansions that are separate jar files can be found on the eCloud and are downloadable through [`/papi ecloud download <expansion>`](users/commands.md#papi-ecloud-download) if the expansion is verified.
## It only shows `%placeholder%` and not the variable
When a plugin or [`/papi parse me %placeholder%`](users/commands.md#papi-parse) only returns the placeholder itself and no value should you check for the following things:
- ### The expansion is actually installed.
Some expansions may not be integrated into a plugin or don't even have a plugin to depend on, meaning that they may be their own separate jar file that you have to download.
Such expansions can usually be found on the eCloud of PlaceholderAPI and be downloaded using the [`/papi ecloud download <expansion>`](users/commands.md#papi-ecloud-download) command.
Whether an expansion is available on the eCloud or not can be found out in the [Placeholder List](users/placeholder-list/index.md) with any expansion displaying a papi command being downlodable.
- ### Plugin actually supports PlaceholderAPI
It can happen that the plugin you use to display the placeholder in doesn't support PlaceholderAPI. In such a case check, if the parse command returns the actual value of a placeholder.
If that is the case while the plugin is still displaying the placeholder, can this be an indicator of the plugin not supporting PlaceholderAPI.
You can find a list of plugins supporting PlaceholderAPI [here](users/plugins-using-placeholderapi/index.md).
Just make sure that "Supports placeholders" has a check mark in front of it.
- ### No typo in the placeholder
Double-check that the placeholder you set doesn't contain a typo. You can use [`/papi ecloud placeholders <expansion>`](users/commands.md#papi-ecloud-placeholders) (replace `<expansion>` with the name of the expansion) to get a list of all the placeholders the expansion may have.
Keep in mind that this only works for separate expansions on the eCloud and not for those that are loaded by plugins.
Additionally can the placeholder list from the eCloud be outdated. It is recommended to check the [Placeholder List](users/placeholder-list/index.md) or see if there is any documentation for the placeholders you want to use.
- ### Plugin is enabled
If an expansion depends on a plugin, make sure you have the plugin installed and that it is enabled (Shows green in `/pl`).
## I can't download the expansion
Make the following checks:
1. The connection to the eCloud (Located at https://api.extendedclip.com) is not blocked through a firewall or your server host.
2. The expansion you want to use is actually on the eCloud. Some expansions are included in a plugin directly.
3. The expansion is verified. Only verified expansions can be downloaded through PlaceholderAPI's download command. This is a security measure to prevent the spread of malware.
If the above checks are all fine and you still can't get the expansion through the download command, consider downloading it manually.
To do that, head to the expansion's page on the ecloud, download the jar file and put it into `/plugins/PlaceholderAPI/expansions/` before using [`/papi reload`](users/commands.md#papi-reload).
## How can other plugins use my placeholders with PlaceholderAPI?
See the [Using PlaceholderAPI](developers/using-placeholderapi.md) page.
## Can I help on this wiki?
You sure can!
We welcome contributions to our wiki by everyone. If you found a typo or want to improve this wiki in another way, head over to the [Wiki's readme file][readme] to find out about how you can contribute towards this wiki.
## PlaceholderAPI is posting an error about an outdated expansion?
```
[00:00:01 ERROR]: [PlaceholderAPI] Failed to load Expansion class <expansion> (Is a dependency missing?)
This wiki gives you information on how to create placeholders in your plugin that can be used in other plugins, how to use other placeholders inside your plugin, or how to make an expansion.
It also has a community-curated list of all available Placeholder expansions and their placeholders.
## Navigation
<div class="grid cards hide-list" markdown>
- ### :material-account-file-text: User Guides
----
Pages aimed at server owners who want to utilize PlaceholderAPI.
description:Fixing blocked connections to the PlaceholderAPI Expansion Cloud (eCloud).
---
# eCloud connection blocked
If you cannot download expansions via PlaceholderAPI, your server may be unable to reach the PlaceholderAPI Expansion Cloud (eCloud). This is usually caused by a network restriction by your host, firewall, or ISP.
## Symptoms
Common signs include:
- You were directed to this page via an in-game message.
If you use shared hosting or a managed host, you may not be able to change firewall rules yourself. Contact your host and ask them to allow outbound HTTPS requests to the domains listed above.
### 2) Check firewalls / filters you control
If you manage your own server, check any outbound filtering:
- OS firewall rules (Windows Firewall / `ufw` / `iptables`)
- Router/datacenter firewall rules
- DNS filtering
### 3) Manually install expansions (works even if the eCloud is blocked)
If unblocking is not an option, you can download expansions manually:
1. Go to https://ecloud.placeholderapi.com/
2. Open the expansion you want.
3. Download the `.jar`.
4. Put it into your server’s `plugins/PlaceholderAPI/expansions/` folder.
5. Run [`/papi reload`](../users/commands.md#papi-reload) (or restart the server).
## Quick connectivity checks (optional)
If you have access to the machine running the server, these checks from a terminal or command prompt can help confirm a block.
```bash
curl -I https://ecloud.placeholderapi.com/api/v3/
curl -I https://api.extendedclip.com/v2/
```
If these commands fail on the server but work on your own PC/network, the server host or datacenter network is most likely blocking outbound connections.
## Still stuck?
If you need help, join the [Discord Server](https://discord.gg/helpchat) and share:
- What you've tried
- The full console error from the download attempt
does it mean that the Server you're using PlaceholderAPI on does not have Gson included.
This is often the case for servers running 1.8 or older. To fix this, make sure to use at least 1.8.8 as that version does include the required dependency.
## Expansions won't work
If one or multiple expansions don't work, make sure you checked the following:
- You executed `/papi reload` after downloading the expansion(s).
- Any required plugin is installed and enabled.
- The expansion is valid (See next sections).
## `Failed to load expansion class <expansion> ...`
### `- One of its properties is null which is not allowed`
When this error appears does it mean that either `getAuthor()`, `getIdentifier()` or `getVersion()` in the expansion return `null` which is not allowed.
In such a case, contact the developer of the expansion and inform them about this issue and that it should be fixed.
### `(Is a dependency missing?)`
This error is given whenever the expansion cannot be loaded, which often happens due to a missing dependency (required plugin) or because creating an expansion instance failed.
The only thing you can do is to provide the full error so that we can check if the issue is caused by PlaceholderAPI (More unlikely) or by the expansion.
## Some player placeholders aren't working on Hytale
Due to Hytale's concurrency setup and PlaceholderAPI design choices, certain player placeholders require a particular parsing implementation on the dev side. If you're a plugin user and placeholders like %player_health% aren't working, but work fine when using `/papi parse me %player_health%`, chances are the plugin you're using has incorrectly implemented PlaceholderAPI support.
To access certain player data, placeholders need to be parsed in the world thread of the player.
```java
finalWorldworld=player.getWorld();
world.execute(()->{
PlaceholderAPI.setPlaceholders(/* set placeholders here */);
These commands are used to parse placeholders into their respective values. Useful for debugging.
#### `/papi bcparse`
/// info |
**Description**:
Parses placeholders of a String and broadcasts the result to all players.
**Arguments**:
-`<player|me|--null>` - The Player to parse values of the placeholder (Use `me` for yourself and `--null` to force a null player (Useful for consoles)).
-`<text>` - Text with placeholders to parse.
**Example**:
```
/papi bcparse funnycube My name is %player_name%!
```
///
#### `/papi cmdparse`
/// info |
**Description**:
Parses placeholders of a String and executes it as a command.
**Arguments**:
-`<player|me|--null>` - The Player to parse values of the placeholder (Use `me` for yourself and `--null` to force a null player (Useful for consoles)).
-`<text>` - Text with placeholders to parse and execute as command (Don't include the `/` for the command).
**Example**:
```
/papi cmdparse funnycube say My name is %player_name%!
```
///
#### `/papi parse`
/// info |
**Description**:
Parses the placeholders in a given text and shows the result.
**Arguments**:
-`<player|me|--null>` - The Player to parse values of the placeholder (Use `me` for yourself and `--null` to force a null player (Useful for consoles)).
-`<text>` - Text with placeholders to parse.
**Example**:
```
/papi parse funnycube My group is %vault_group%
```
///
#### `/papi parserel`
/// info |
**Description**:
Parses a relational placeholder.
**Arguments**:
-`<player1|me>` - The first player (Use `me` for yourself).
-`<player2|me>` - the second player to compare with (Use `me` for yourself).
These commands all start with `/papi ecloud` and are used for things related about the [Expansion Cloud](../developers/expansion-cloud.md).
Only executing `/papi ecloud` without any arguments will list all commands available for it.
#### `/papi ecloud clear`
/// info |
**Description**:
Clears the cache for the eCloud.
///
#### `/papi ecloud disable`
/// info |
**Description**:
Disables the connection to the eCloud.
///
#### `/papi ecloud download`
/// info |
**Description**:
Allows you to download an expansion from the eCloud
**Arguments**:
-`<expansion>` - The expansion to download.
-`[version]` - The specific version of the expansion to download (Optional)
**Example**:
```
/papi ecloud download Vault
/papi ecloud download Vault 1.5.2
```
///
#### `/papi ecloud enable`
/// info |
**Description**:
Enables the connection to the eCloud
///
#### `/papi ecloud info`
/// info |
**Description**:
Gives information about a specific Expansion.
**Arguments**:
-`<expansion>` - The Expansion to retrieve information from.
-`[version]` - The Expansion's version to get information from.
**Example**:
```
/papi ecloud info Vault
```
///
#### `/papi ecloud list`
/// info |
**Description**:
Lists either all Expansions on the eCloud, only those by a specific author or only those that you have [installed](#papi-ecloud-download).
Installed Expansions show as green in the list and Expansions that are installed and have an update available show as gold.
**Arguments**:
-`<all|<author>|installed>` - List all Expansions, Expansions of a specific author or all Expnansions you have installed.
**Example**:
```
/papi ecloud list all
/papi ecloud list clip
/papi ecloud list installed
```
///
#### `/papi ecloud placeholders`
/// info |
**Description**:
List all placeholders of an Expansion.
**Arguments**:
-`<expansion>` - The Expansion to list placeholders of.
**Example**:
```
/papi ecloud placeholders Vault
```
///
#### `/papi ecloud refresh`
/// info |
**Description**:
Refresh the cached data from the eCloud.
///
#### `/papi ecloud status`
/// info |
**Description**:
Displays the actual Status of the eCloud.
///
----
### Expansion Commands
These commands can be used to manage the expansions that you have currently installed.
#### `/papi info`
/// info |
**Description**:
Gives you information about the specified Expansion.
**Argument(s)**:
-`<expansion>` - The Expansion to get info from (Needs to be registered and active).
**Example**:
```
/papi info Vault
```
///
#### `/papi list`
/// info |
**Description**:
Lists all active/registered expansions.
This is different to [/papi ecloud list installed](#papi-ecloud-list) in the fact, that it also includes expansions that were installed through a plugin (That aren't a separate jar-file) and it also doesn't show which one have updates available.
///
#### `/papi register`
/// info |
**Description**:
Registers an expansion from a specified filename.
This is useful in cases, where you downloaded the expansion manually and don't want to restart the server.
The file needs to be inside `/plugins/PlaceholderAPI/expansions`.
**Arguments**:
-`<filename>` - The file to register (including the file-extension).
**Example**:
```
/papi register MyExpansion.jar
```
///
#### `/papi unregister`
/// info |
**Description**:
Unregisters the specified expansion.
**Arguments**:
-`<filename>` - The expansion to unregister.
**Example**:
```
/papi unregister MyExpansion.jar
```
///
----
### Other Commands
These are other commands of PlaceholderAPI that don't fit any of the above categories.
#### `/papi dump`
/// info |
**Description**:
Pastes useful information from PlaceholderAPI such as plugin version, server version and installed expansions to https://paste.helpch.at for simple sharing and support.
///
#### `/papi help`
/// info |
**Description**:
Displays all the commands PlaceholderAPI currently offers.
///
#### `/papi reload`
/// info |
**Description**:
Reloads the config settings.
You need to use this command after [downloading Expansions](#papi-ecloud-download) from the eCloud or they won't be properly registered.
///
#### `/papi version`
/// info |
**Description**:
Shows the current version and authors of PlaceholderAPI.
PlaceholderAPI is home of countless community-made Placeholder Expansions.
To help you find the expansion you need, we are providing official placeholder lists that include available PlaceholderAPI expansions and their placeholders for both Minecraft (Spigot, Paper, etc.) and Hytale.
<div class="grid cards" markdown>
- ## [Minecraft](minecraft.md)
----
Placeholder list for the Minecraft version of PlaceholderAPI.
- ## [Hytale](hytale.md)
----
Placeholder list for the Hytale version of PlaceholderAPI.
description:List of Plugins that support PlaceholderAPI and/or provide their own placeholders to use.
---
# Hytale
This here is a list of all plugins supporting the Hytale version of PlaceholderAPI by either having their own placeholders added, or just allowing other placeholders to be used.
If your plugin isn't shown here and you want it to be added, [read the Wiki README](https://github.com/PlaceholderAPI/PlaceholderAPI/blob/wiki/README.md) on how you can submit your changes.
This page contains two sections listing plugins that support PlaceholderAPI, either having their own placeholders added, or by just allowing other placeholders to be used. Browse the sections below to find plugins and their available placeholders for each platform.
<div class="grid cards" markdown>
- ## [Minecraft](minecraft.md)
----
Plugins using the Minecraft version of PlaceholderAPI.
- ## [Hytale](hytale.md)
----
Plugins Using the Hytale version of PlaceholderAPI.
description:User Guide on how to use placeholders in a plugin.
---
# Using Placeholders
This page is intended for server owners or server staff who want to learn how to use placeholders in a plugin.
If you're a developer and would like to learn how to provide placeholders or support placeholders from other plugins in your own, check out [Using PlaceholderAPI](../developers/using-placeholderapi.md).
## Prerequisites
Before you can use placeholders should you check a few things first.
### Plugin supports PlaceholderAPI
The first and most important thing is, to find out if the plugin you want to use placeholders in is actually supporting PlaceholderAPI.
Chat-plugins such as EssentialsXChat do not natively support PlaceholderAPI and instead require separate plugins to "inject" the parsed placeholders into the final chat message.
One way to check, if a Plugin is supporing PlaceholderAPI, is to check the [Plugins using PlaceholderAPI](plugins-using-placeholderapi/index.md) page.
If the plugin is listed and if the `Supports placeholders` text has a check, does it mean that PlaceholderAPI support is available.
If the plugin isn't listed, can you usually check its plugin page, or any other source of information, such as a wiki, for clues on if PlaceholderAPI is supported.
### Proper Internet connection
PlaceholderAPI connects towards an eCloud located under https://api.extendedclip.com to retrieve information about placeholder expansions, but also to download said expansions from it.
Make sure that your server is allowing external connections to the above URL. If it doesn't, and you're using a host, contact their support and ask them to whitelist this URL.
/// info | Info for hosts
PlaceholderAPI provides and checks for a specific Environment variable to block the download of specific expansions.
Should you as a host want to block the download of specific expansions, add the `PAPI_BLOCKED_EXPANSIONS` Environment variable containing a comma-separated list of expansion names that PlaceholderAPI should not be able to download.
This feature exists since version 2.11.4 of PlaceholderAPI
///
## Download/Get Expansion
The way PlaceholderAPI's system works, allows a Placeholder Expansion and its corresponding placeholders to either be included within a plugin (If placeholder requires said plugin) or to be available as a separate jar file on the eCloud of PlaceholderAPI.
Depending on what type you have, will you need to do some extra steps to use the placeholder from the Placeholder Expansion.
One way to find out, if an Expansion is included or separate, is to check the [Placeholder List](placeholder-list/index.md) page for any entry of it.
If it exists on the page, can you check the infobox right below the title of the Expansion for one of the following cases:
-`papi ecloud download <expansion>`: The expansion is on the ecloud and needs to be downloaded using the [`/papi ecloud download` command](commands.md#papi-ecloud-download).
-`Built into Plugin`: The expansion is part of the plugin it depends on and doesn't require any steps to install, unless stated otherwise.
- *A URL*: The Expansion needs to be downloaded from a separate source (i.e. a GitHub Release). You need to manually download and move the jar into the expansions folder.
You can check what expansions are loaded by running `/papi list`.
## Use Expansion
Using the placeholders of the Expansion is a straigh forward process.
Simply put the right placeholder format (i.e. `%player_name%`) inside whatever configuration option supports it. Please refer to any manuals or wikis a plugin may offer about what options support placeholders.
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.