Yellow Netherite

## 📖 Description

## ✨ Preview

Yellow Knockback Swords

Make swords enchanted with knockback become yellow!

Requires CIT Resewn or Optifine

Simply drag into your resource pack folder, extract, and enable it and put it at the top of your packs.

Yellow Hearts

Always Yellow Hearts
—
**Brighten up your Minecraft experience with yellow hearts!**

This resource pack transforms the default red heart textures into a cheerful yellow hue. Whether your hearts are full, half-full, or empty, they will always display in a vibrant yellow, offering a fresh visual twist to your health bar.

**Features:**
* All heart icons are changed to yellow.
* Consistent yellow appearance for full, half, and empty states.
* Purely aesthetic change – no gameplay modifications.
* Compatible with various Minecraft versions.

Enjoy a splash of sunshine on your health bar!

Yellow Enchant Glint

🟨Yellow Enchant Glint
–
Mostly suitable for 1.15~latest version, though can be used in earlier version with less effect, which could not fixed in resource pack way.

[Click this to view alternatives.](https://modrinth.com/collection/lR5x3kC0)

ℹStatement
–
This work is authorized for non-commercial purposes only.
Proper attribution to the original author and a clear link to the source must be provided.
Unauthorized reuploading, redistribution and commercial utilization are strictly prohibited.
Distortion, defamation or any act that damages reputation shall not be permitted.
Any disputes arising from improper use shall be solely borne by the user, and the original author shall bear no responsibility therefor.
All Rights Reserved.
– _In the event of discrepancies statements contained in older versions, the above statements shall prevail._

Check my profile if you want to view more Resource Pack Projects.<3

Yellow Crits

**Changes critical hit to yellow**

—

Tired of boring brownish-gray critical hits? Then try spicing up your game with something new!


Yellow Cobwebs

Changes the texture in minecraft/textures/block/cobweb.png to be yellow while keeping the three shades in the original cobweb texture.

Original shades:

– #FFFFFF (bright)
– #E4E9E9 (mid)
– #C4CED2 (dark)

New shades:

– #FFC700 (bright)
– #E7B400 (mid)
– #CC9F00 (dark)

YeeeesMOTD

Customized server motd and random icon, it can use player’s head as server icon,like this:

)

also use player’s name as motd description, and random icon

everything is up to you

for more information please go to github: https://github.com/RTAkland/YeeeesMOTD

YardWatch

# YardWatch (for server owners)
Implementation of [YardWatchAPI](https://github.com/YouHaveTrouble/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](https://github.com/YouHaveTrouble/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](https://github.com/YouHaveTrouble/YardWatchAPI/blob/master/readme.md)!

You can also request a temporary implementation within this plugin [here](https://github.com/YouHaveTrouble/YardWatch/issues/new?assignees=&labels=enhancement&projects=&template=implementation-request.yml&title=%5BNEW+IMPLEMENTATION%5D%3A+).

# 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](https://github.com/YouHaveTrouble/YardWatch).

# 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](https://github.com/Yorick-06/SimpleResources) based on
[jackson-dataformats-text](https://github.com/FasterXML/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*