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

## ⚙️ Configuration

The `config.yml` file allows you to customize every aspect of the TPA system.

—

YARRP

Has it ever bothered you that so much configuration of blocks, items, recipes,
and now even enchantments is defined in untyped JSON files? Well then you should
probably just use
data generation which
is much more battle tested and even used by Mojang for the Vanilla data. _But_,
if you _also_ want to be able to adjust the data dynamically or want some things
to be configurable, then this might just be the thing for you. YARRP is inspired
by ARRP and
BRRP but written from the ground up with an
easy to use Kotlin API. It allows you to create resource packs (i.e. both data
packs and asset packs) at runtime, so you don’t need to have JSON files ready
for all possible options.

## Usage

To add YARRP as a dependency, add the following to your `build.gradle.kts`:

“`kotlin
repositories {
// you can use either one
maven(“https://jitpack.io”)
maven(“https://api.modrinth.com/maven”)
}

dependencies {
// replace the versions and loader as needed. the loader is one of `fabric` or `neoforge`
modImplementation(“com.github.RubixDev.YARRP:yarrp-mc1.21.1-fabric:v0.2.0”) // when using jitpack
modImplementation(“maven.modrinth:yarrp:0.2.0+1.21.1-fabric”) // when using modrinth maven
}
“`

Don’t forget to also list YARRP as a dependency in your `fabric.mod.json` and
`neoforge.mods.toml` files.

You can then use YARRP by creating a pack and adding it to one of the register
callbacks. Here’s an example:

“`kotlin
object MyModResources {
// call this in your mod initializer
fun register() {
YarrpCallbacks.register(PackPosition.AFTER_VANILLA, ResourceType.SERVER_DATA) {
add(PACK)
}
}

@JvmField
val PACK = RuntimeResourcePack(
RuntimeResourcePack.createInfo(
Identifier.of(“modid”, “my_runtime_pack”),
Text.of(“Pack Title”),
“pack version”, // should probably be set to the version of your mod
),
RuntimeResourcePack.createMetadata(Text.of(“pack description”)),
)

val MY_ENCHANTMENT: RegistryKey = PACK.addEnchantment(
Identifier.of(“modid”, “my_enchantment”),
Enchantment.definition(
// this dummy type can be used to create a RegistryEntryList from a given TagKey
// but should only be used for adding resources to a runtime pack
DummyHolderSet(ItemTags.LEG_ARMOR_ENCHANTABLE),
5,
3,
Enchantment.leveledCost(5, 8),
Enchantment.leveledCost(55, 8),
2,
AttributeModifierSlot.LEGS,
),
)

init {
if (MyModSettings.myEnchantmentIsTreasure) {
PACK.addTag(EnchantmentTags.TREASURE) { add(MY_ENCHANTMENT) }
} else {
PACK.addTag(EnchantmentTags.NON_TREASURE) { add(MY_ENCHANTMENT) }
}

if (MyModSettings.enableRecipe) {
PACK.addRecipeAndAdvancement(
Identifier.of(“modid”, “my_recipe”),
ShapedRecipeJsonBuilder.create(RecipeCategory.MISC, Items.DIAMOND, 64)
.criterion(“tick”, TickCriterion.Conditions.createTick())
.pattern(“//”)
.pattern(“//”)
.input(‘/’, Items.STICK),
)
}
}
}
“`

Full API documentation can be found at
yarrp.rubixdev.de.

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: ![](https://jitpack.io/#YouHaveTrouble/YardWatchAPI)

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 Resources

Addon for Simple Resources based on
jackson-dataformats-text which adds support for “`.yml“`/“`.yaml“` files
for both minecraft and custom-registered resources.

Simply place this mod in your mods folder (SimpleResources version 2.1.0 or higher required) and all resources can now
be specified in the YAML format.

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*

Yamete Ghast

This texture pack makes the ghast make a funny face when it throws a fireball.
This pack does not require Optifine or EMF, ETF, or ETF to work.
It works on versions lower than 1.21.5.

YamatoPlugin

# YamatoPlugin

YamatoPlugin adds a custom Yamato sword to your Minecraft server

The sword is made for fast combat and gives players several active abilities, ultimate charge from kills, and a configurable item description. It fits well for PvP servers, RPG servers, private servers, and any setup where you want one clean custom weapon without extra plugin dependencies

## Features

* Custom Yamato sword
* Active combat abilities
* Ultimate charge from kills
* Charge progress shown in the item lore
* Configurable damage and cooldowns
* Editable item name and description
* Editable plugin messages
* Works without required dependencies

## Commands

`/yamato give`
Gives Yamato to yourself.

`/yamato give `
Gives Yamato to another player.

`/yamato reload`
Reloads the plugin config.

## Permission

`yamato.admin`

This permission is required for the Yamato command. Server operators have it by default

## Compatibility

* Minecraft 1.20.5 to 1.21.1
* Java 21 or newer
* Spigot, Paper and Purpur

## Installation

1. Download the jar file
2. Put it into your server plugins folder
3. Start or restart the server
4. Edit `plugins/YamatoPlugin/config.yml` if needed
5. Use `/yamato give`

## Configuration

Most important parts can be changed in `config.yml`, including the sword name, material, item description, ability damage, cooldowns, ultimate charge and messages

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

—
![Have a nice stay.](https://cdn.modrinth.com/data/CGMMa4Ji/images/cd24a8e8a426232247eb39ff57ee454b946a3dd9.png)

Yamakashi skateboards

## For correct work you need Optifine or CITResewn

Rename your sword “Огрызок”, “Алмаз”, “Кроссовок”, “Пивас” to make it a skateboard.
If you hold the object in your other hand, it will be behind your back.

![This is an image](https://cdn.modrinth.com/data/qEL3uWG5/images/e91d9d83a1f8fa7eb4901abcfd55b6e5869b2892.png)

Y’all It’s Winter!

A resource pack that makes the world appear snowy!
Sister pack to Y’all It’s Fall!!
Also available for Bedrock Edition.

**Features:**

* Grass Blocks become snowy regardless of whether or not they’re under a snow block.
* Ground cover and other foliage also becomes snowy.
* The backs of Sniffers and other mossy mobs become snowy.

**Known Issues:**

* The particles for certain leaf blocks are tinted green under certain circumstances. This is fixed with Polytone.
* Short Grass and other bits of foliage make snow sounds due to limitations in Java Edition.
* Actual snowfall is still exclusive to snowy biomes due to limitations in resource packs.

Special thanks to ShockMicro and/or Ancientkingg (and the Vanilla Tweaks team) for the fix to Java Edition cloud fog for the Trails and Tales panorama, which has been removed form the current version of the pack but is still present in older versions.