YChatManager
# YChatManager
Plugin for chat management, formatting, anti-spam etc. Requires at least **Paper**, won’t work on Spigot or Bukkit.
# Features
### Chat formatting
– Custom chat format with MiniMessage, PlaceholderAPI and Vault.
– Custom displayname format also with MM, PAPI and Vault.
– Per permission colors, formats and MiniMessage tags to use in messages.
### Chat culture
– Anti swear, flood, caps
– Allowed message RegEx pattern
– Message cooldown
– Command cooldown
### Private messages
– With receive sound
– And socialspy for admins
### Other
– Custom nicknames using simple command, where every MiniMessage tag and legacy format is available per permission.
– Clear chat command.
– Join, quit and death messages, also with an option to disable them
– Fully customizable messages with lang file, supporting PlaceholderAPI and MiniMessage
– Commands with tab completions
– API for developers
# Documentation
You can read about plugin’s permissions, placeholders etc. on the wiki page.
# Media
# Integrity with other plugins
I make these plugins for me, according to my needs, meaning, I don’t search for every possible plugin that I don’t care about, that could be somehow better integrated with mine. But, if you care about better integration between this plugin and some other, then just let me know through Discord or GitHub and I will see what I can do.
Same goes for any features that you think may be missing. If something isn’t outside the scope of the plugin, then I’ll probably do it.
# License
This project uses GNU GPLv3 license.
YATPAS
YATPAS is a simple but robust Player-to-Player Teleport (TPA) system for Bukkit/Spigot/Paper servers. It features clickable requests, configurable cooldowns, timeouts, and automatic cancellation upon movement or damage, ensuring a balanced gameplay experience.
***
## 🇮🇹 IMPORTANT NOTE ON LANGUAGE
The default language for the messages inside the plugin’s `config.yml` is **Italian**. You can easily translate all messages to English or any other language by editing the `messages:` section of the configuration file.
***
## ✨ Key Features
* **Clickable Requests:** Players can accept or deny TPA requests with a single click.
* **Correct TPA/TPAHERE Logic:** Supports both teleporting to another player (`/tpa`) and calling a player to your location (`/tpahere`).
* **Warmup:** Configurable time before the actual teleport, which is cancelled if the player moves or takes damage.
* **Cooldown & Timeout:** Limits request spam and ensures requests expire automatically.
* **Customizable Messages:** All messages are fully configurable via `config.yml`.
## 📦 Commands
| Command | Alias | Description | Permission |
| :— | :— | :— | :— |
| `/tpa ` | | Requests to teleport to the specified player. | `yatpas.use.tpa` |
| `/tpahere ` | | Requests the specified player to teleport to you. | `yatpas.use.tpahere` |
| `/tpaccept` | | Accepts the pending TPA request. | `yatpas.use.tpaccept` |
| `/tpdeny` | | Denies the pending TPA request. | `yatpas.use.tpdeny` |
| `/tpacancel` | | Cancels your outgoing TPA request. | `yatpas.use.tpacancel` |
## ⚙️ Configuration
The `config.yml` file allows you to customize every aspect of the TPA system.
| Config Key | Description | Default Value |
| :— | :— | :— |
| `teleport-warmup-seconds` | Time in seconds before the teleport occurs. | `5` |
| `tpa-cooldown-seconds` | Cooldown between sending two TPA requests. | `2` |
| `request-timeout-seconds` | Time before a TPA request expires. | `60` |
| `cancel-on-move` | `true` to cancel warmup if the player moves. | `true` |
| `cancel-on-damage` | `true` to cancel warmup if the player takes damage. | `true` |
| `messages.prefix` | Prefix displayed in all messages. | `&3YATPAS&8» &f` |
—
YARMM
Another menu plugin, yaaay
# Examples
## Fully Customizable & Dynamic Items
Whether you want dynamic item names, lore, slots, damage, player head, shield color, banner pattern, potion effect, firework effect, light level, crossbow projectile… bundle inventory? You can have it all! And all are refreshed basically instantly thanks to TAB’s handling of placeholders (can be configured in its config).
You can also use TAB’s animations with the change-interval that you want to display custom data.
Menu: https://paste.helpch.at/yayeretiwa.less
TAB’s animations.yml: https://paste.helpch.at/gikidelemo.makefile
## Prompts
# Plugin Convertion
At this time, YARMM only supports converting menus from DeluxeMenus.
Almost everything is converted except for the meta action & requirement (will be added to ConditionalActions at some point)
To convert menus, simply run /yarmm convert DeluxeMenus (plugin not required on the server, only the folder) and everything in the `/plugins/DeluxeMenus/gui_menus` folder will be converted (regardless of whether they’re registered in DM’s config.yml or not)
# Dependencies
**This plugin depends on both TAB and ConditionalActions** (and by extension PAPI, yes I know that makes 3 dependencies, sorry XD)
TAB allows for instant refreshing of item properties (including material) as well as mennu title; ConditionalActions lets you execute actions on click depending on conditions.
You have access to both TAB & PlaceholderAPI placeholders.
YardWatch
# YardWatch (for server owners)
Implementation of YardWatchAPI for common protection plugins. If any of supported plugins implements the API itself, then this plugin will stop providing its implementation to allow the
plugin to take over.
If you’re a developer looking for information how to implement YardWatchAPI in your plugin, see
YardWatchAPI
## Requirements
– Java 17
– Minecraft 1.16+
## Implementations for:
– GriefPrevention (v16+)
– WorldGuard (7.0.0+)
– LWCX
– FactionsUUID
– SuperiorSkyBlock
– Towny
– PlotSquared (6.0.0+)
## Plugin you’re using is not implementing YardWatchAPI?
Contact the plugin developer and send them here!
You can also request a temporary implementation within this plugin here.
# YardWatchAPI (for developers)
API to unify protection plugins for minecraft bukkit servers to allow easy protection queries without having to import
10 different plugin apis with separate implementations.
Current version: 
If you’re looking for a plugin implementing YardWatchAPI for common protection plugins, see YardWatch plugin.
# Usage
### Import the api using dependency manager
In any case of usage you will need to import the API. Replace `VERSION` with current version tag. You should also adjust your `` to `provided` if you’re not implementing the api and just querying it.
#### Maven
“`xml
jitpack.io
https://jitpack.io
com.github.YouHaveTrouble
YardWatchAPI
VERSION
compile
“`
#### Gradle
“`gradle
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
mavenCentral()
maven { url ‘https://jitpack.io’ }
}
}
dependencies {
compileOnly ‘com.github.YouHaveTrouble:YardWatchAPI:VERSION’
}
“`
## For plugins wanting to see if something is protected
### Check if player can break a block
Example handling of block breaking check. There’s no need to depend on any plugins for this.
“`java
public boolean canBreakBlock(Player player, Block block) {
ServicesManager servicesManager = getServer().getServicesManager();
Collection> protections = servicesManager.getRegistrations(Protection.class);
for (RegisteredServiceProvider protection : protections) {
if (protection.getProvider().canBreakBlock(player, block.getState(true))) continue;
return false; // if any protection plugin disallowed breaking the block, return false
}
// If all protection plugins allowed breaking the block, return true
return true;
}
“`
## For protection plugins
### Depend on YardWatch plugin
You can optionally softdepend and check if YardWatch is present to add an optional integration.
“`yml
depend:
– “YardWatch”
“`
### Implement Protection interface
Implement all the methods required by the interface
“`java
public class YourPluginProtection implements Protection {}
“`
### Register your implementation as a service
“`java
@Override
public void onEnable() {
getServer().getServicesManager().register(
Protection.class,
new YourPluginProtection(),
this,
ServicePriority.Normal
);
}
“`
YAML Config
## YAML Config: A Minecraft Configuration Mod
### Overview
YAML Config is a powerful Minecraft configuration mod that enables mod developers to create and manage configuration settings using the YAML file format. It offers a user-friendly GUI, extensive support for data types, and robust networking for client-server synchronization.
### Features
* **YAML File Format:** YAML Config utilizes the YAML file format, known for its readability and ease of use.
* **GUI Interface:** A well-designed GUI allows players to easily navigate and edit their configuration settings.
* **Extensive Data Type Support:** The mod supports a wide range of data types, including:
* **Primitive Types:** `boolean`, `int`, `float`, `double`, `String`, `ResourceLocation`, `Registry`
* **Collections:** `List`, `Map`
* **Date and Time:** `LocalDateTime`
* **Server-Client Synchronization:** Changes made to configurations on the server are automatically synchronized to clients, ensuring consistency across the gameplay experience.
* **Modpack Support:** The mod is designed to work seamlessly with existing modpacks, offering a flexible and expandable configuration system.
* **Validation and Error Handling:** The mod includes robust validation and error handling, ensuring that configurations meet the expected requirements.
### Installation and Usage
#### Installation
1. **Download the mod:** Download the latest version of YAML Config from the mod’s official website, CurseForge, or Modrinth.
2. **Place the mod file:** Move the downloaded JAR file into the “mods” folder within your Minecraft directory.
3. **Launch Minecraft:** Start Minecraft and join a world.
#### Usage
1. **Open the Configs Screen:** Press “F12” on your keyboard to open the Configs screen.
2. **Navigate to the Config:** The Configs Screen displays a list of available configurations. Select the mod whose configuration you want to modify.
3. **Edit Config Entries:** The Config Screen displays the available settings. Each entry includes:
* **Title:** The name of the setting.
* **Input Field:** A field for editing the value.
* **Reset Button:** A button for resetting the value back to its default.
4. **Save Changes:** Click the “Save Changes” button to save your modifications. The mod will automatically save the changes to the configuration file and synchronize them with other players on the server (if applicable).
### Development
#### Creating Configurations
**1. Define a Config Class:**
* Create a new Java class within your mod’s codebase that represents your mod’s configuration.
“`java
public class MyModConfig {
public static IConfig config;
public static IConfigEntry debug;
public static void init() {
ConfigBuilder builder = new ConfigBuilder(MyMod.MOD_ID, “mymod-config”, ConfigExtension.YAML, ConfigType.CLIENT);
}
}
“`
**2. Define Config Entries:**
* Use the `ConfigBuilder` class to define the settings for your configuration.
* Choose the appropriate data type for each entry using the `define*` methods.
“`java
// Example of defining a boolean entry:
debug = builder.defineBoolean(“debug”, false);
// Example of defining an integer entry with range:
intEntry = builder.defineInteger(“intEntry”, 10, 0, 100); // Min 0, Max 100
// Example of defining a string entry with pattern:
stringEntry = builder.defineString(“stringEntry”, “test”, “test\d+”);
// Example of defining a registry entry:
registryEntry = builder.defineRegistry(“registryEntry”, Blocks.GRASS_BLOCK, BuiltInRegistries.BLOCK);
// Example of defining a list:
stringListEntry = builder.defineStringList(“stringListEntry”, List.of(“test1”, “test2”, “test3”), 3, 10); // Min 3, Max 10
// Example of defining a map:
integerMapEntry = builder.defineIntegerMap(“integerMapEntry”, Map.of(“test1”, 1, “test2”, 2, “test3”, 3), 3, 10); // Min 3, Max 10
“`
**3. Build the Configuration:**
* Call the `build()` method on the `ConfigBuilder` to create your configuration.
* Store the configuration in a static field for easy access within your mod’s code.
“`java
public MyModConfig() {
ConfigBuilder builder = new ConfigBuilder(“mymod”, “mymod-config”, ConfigExtension.YAML, ConfigType.CLIENT);
// … define config entries
config = builder.build();
}
“`
**4. Access Config Values in Your Code:**
* Use the `get()` method to retrieve the current value of a config entry.
* Use the `set()` method to modify the value of a config entry.
“`java
// Example:
boolean debugEnabled = MyModConfig.debug.get(); // Retrieve the current value of the “debug” setting
if (debugEnabled) {
// Perform debug-related actions
}
MyModConfig.intEntry.set(25); // Set the value of the “intEntry” to 25
“`
#### Config Type
* **`ConfigType.CLIENT`:** Client-side configurations are specific to the client who has installed the mod. They are not shared with other players on the server.
* **`ConfigType.SERVER`:** Server-side configurations are specific to dedicated servers. They will not be used on single player worlds and are not synced to the players on the server.
* **`ConfigType.COMMON`:** Common configurations are shared between both clients and the server. They can be edited on the server by editing the config file directly and restarting the server or by editing the values using the in-game GUI and saving the changes.
#### Using Custom Data Types
* Use the `IConfigEntryType` interface to register custom data types with the YAML Config mod.
* Implement a custom serializer for handling the serialization and deserialization of your custom data type.
#### Modpack Configuration
* If you are creating a modpack, you can use YAML Config to define the configuration settings for your modpack.
* Place the configuration file for your modpack in the “config” folder within your modpack’s directory.
#### Examples
“`java
// Example: Basic client-side configuration
public class MyModConfig {
public static IConfig config;
public static IConfigEntry debug;
public static IConfigEntry testInt;
public static void init() {
ConfigBuilder builder = new ConfigBuilder(“mymod”, “mymod-config”, ConfigExtension.YAML, ConfigType.CLIENT);
debug = builder.defineBoolean(“debug”, false) // default false.
.withComments(“Whether debug mode is enabled for the mod.”);
testInt = builder.defineInteger(“testInt”, 10, 0, 100); // default 10, min 0 and max 100.
config = builder.build();
}
}
“`
YAML API
# YAML API
YAML API is a specialized library that simplifies working with YAML configuration files in Bukkit/Spigot/Paper plugins. It provides a robust and consistent interface for loading, saving, updating, and managing YAML-based configurations, along with advanced mapping capabilities for configuration sections and configurable units.
—
## Overview
The **YAML API** package offers a set of tools designed to handle YAML configuration files efficiently. It abstracts the complexity of file I/O and reflection-based configuration parsing, allowing you to focus on using configuration data in your plugin.
Key components include:
– **YAMLFile**: A class to load, save, and update YAML configuration files.
– **ResourceUtils**: Utility methods for handling resources and file operations.
– **Configurable & ConfigurableFile**: Interfaces and classes that provide easy access to the underlying `FileConfiguration`.
– **ConfigurableUnit**: An interface representing a configuration unit, useful for handling permissions or groups in the configuration.
– **Mappable, SectionMappable, UnitMappable & HashMappable**: A set of interfaces and classes for mapping configuration sections and units into Java collections.
– **YAMLUpdater**: A class that updates YAML files by merging default values and preserving comments.
—
## Key Features
– **Unified Configuration Management**:
Provides a consistent API for reading, writing, and updating YAML configuration files.
– **Dynamic Mapping and Conversion**:
Supports mapping configuration sections to custom units and collections, making it easier to work with complex configuration structures.
– **Resource and File Utilities**:
Includes helper classes to simplify file loading, resource saving, and directory management.
– **Comment Preservation and Updates**:
YAMLUpdater handles merging of default configuration values while preserving existing comments.
– **Reflection-Based Parsing**:
Uses reflection to dynamically access configuration sections and values, ensuring compatibility across server versions.
—
## Usage Example
Below is an example demonstrating how to use the YAML API to load, update, and work with configuration files.
### Example: Using ConfigurableFile and YAMLFile
“`java
package com.example.myplugin;
import me.croabeast.file.ConfigurableFile;
import me.croabeast.file.YAMLFile;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.IOException;
public class MyPlugin extends JavaPlugin {
private ConfigurableFile config;
@Override
public void onEnable() {
try {
// Create a new configuration file located in the “config” folder
config = new ConfigurableFile(this, “config”, “settings”)
// Optionally, override methods to control updatability or other behaviors
{
@Override
public boolean isUpdatable() {
// Retrieve the “update” key from the configuration to decide if updates are allowed
return get(“update”, false);
}
};
// Save the default configuration if not present
config.saveDefaults();
// Update the configuration file (merges defaults and preserves comments)
config.update();
} catch (IOException e) {
e.printStackTrace();
}
// Access configuration values
String prefix = config.get(“lang-prefix”, “&e MyPlugin »&7”);
getLogger().info(“Language prefix: ” + prefix);
}
}
“`
### Example: Working with Mappable and SectionMappable
“`java
package com.example.myplugin;
import me.croabeast.file.SectionMappable;
import me.croabeast.file.ConfigurableFile;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.plugin.java.JavaPlugin;
public class MyPlugin extends JavaPlugin {
private ConfigurableFile config;
@Override
public void onEnable() {
try {
config = new ConfigurableFile(this, “config”, “settings”);
config.saveDefaults();
config.update();
} catch (Exception e) {
e.printStackTrace();
}
// Assume we have a configuration section “advancements”
ConfigurationSection section = config.getConfiguration().getConfigurationSection(“advancements”);
if (section != null) {
// Create a SectionMappable from the configuration section
SectionMappable.Set sectionMap = SectionMappable.asSet(section.getValues(false));
// Process the mapped configuration as needed
getLogger().info(“Loaded advancements: ” + sectionMap);
}
}
}
“`
—
## Maven / Gradle Installation
To include YAML API to the project, add the following repository and dependency to your build configuration. Replace `${version}` with the desired version tag.
### Maven
Add the repository and dependency to your `pom.xml`:
“`xml
croabeast-repo
https://croabeast.github.io/repo/
me.croabeast
YAML-API
${version}
compile
“`
### Gradle
Add the repository and dependency to your `build.gradle`:
“`groovy
repositories {
maven {
url “https://croabeast.github.io/repo/”
}
}
dependencies {
implementation “me.croabeast:YAML-API:${version}”
}
“`
Replace `${version}` with the appropriate module version.
—
## Conclusion
**YAML API** is a powerful library for managing YAML configurations in your Bukkit/Spigot/Paper plugins. It streamlines file operations, mapping, and updates while preserving comments and ensuring compatibility across server versions. Whether you are building simple configuration systems or working with complex, nested settings, YAML API provides the tools you need to efficiently manage your plugin’s configuration.
Happy coding!
— *CroaBeast*
YAML
Yet Another Math Library is a math library (wow so unexpected) specifically designed for speed.
Documentation can be found HERE.
Current Features
– Functions
– Trigonometry
– Cosine
– Sine
– Tangent
– Factorial
– Absolute Value (coming soon)
– Constants
– Pi
– Euler’s Number
– Tau
– Sqrt 2
– Phi
– Sequences
– Fibonacci sequence
YAMB – SmallAnt Lockout Port
This is a datapack that ports over 200 objectives from SmallAnt’s Lockout mod into Yet Another Bingo. Just drop the datapack into the server’s world folder and you’re good to go!
To use the objectives, type `/bingo filter +smallant` or look for “SmallAnt Default” under Difficulty>Customize>Filter on the lobby menu.
Recommended Bingo Settings:
There is a resource pack available as well, recommended for use by vanilla clients not using the mod. It simply adds the icons to the bingo board.
RESOURCE PACK IS FOR VANILLA ONLY, IT WILL HAVE NO EFFECT ON MODDED CLIENTS
# Resource Pack Examples
Without Resource Pack:
With Resource Pack:
Yamato Gun
Item to be added:
– Bullet
– YG-1 (Gun)
– YG-2
– YG-3
– Sakai Gun
This mod requires Fabric API (Fabric) and MCPitanLib
Adds a simple gun to kill enemies. You can kill mobs more easily.
This mod is in development and currently adds 2 guns and ammo.
Shoot on left-click.
Shooting on right-click will increase attack power.
It can be reloaded with R and cannot be refilled unless ammo is in inventory.
It supports from 1.18 to 1.20.1.
Check REI/JEI for the recipe.
We plan to add more guns in the future.
Yamashita Shimejize 🍄
## Installation
Place the ZIP file in the `shaderpacks` directory.
Do not extract the `shaders` folder from the archive.
## Description
Yamashita Shimejize is a stylized fork of Miniature Shader that pushes the miniature look far beyond pixelated shadows. The pack extends that chunky pixel-art language across lighting, fog, water, weather, reflections, and sky effects while keeping the scene readable and atmospheric.
Features:
– Pixelated shadows, posterized lighting, fog banding, and blocky reflections
– Enhanced two-layer clouds with custom cloud shadows
– Heat haze and emissive glow from lava, fire, torches, and lanterns
– Motion blur, godrays, bloom, chromatic aberration, pixel-art lens flare, pixel-art rain-on-lens droplets with adjustable opacity, and optional depth-aware Depth of Field with adjustable strength, from a subtle miniature softness to a macro-style photo look
– Inkblot-style post-rain puddles with water-like reflections on flat terrain
– Aurora, post-rain rainbow, shooting stars
– Pixel foliage wind with 16×16, 32×32, and 64×64 texture-pack matching modes
—
