YDM’s Glare
### YDM’s Glare for FORGE/FABRIC
Get the Glare to your game!
It will show you areas that are dark enough for monsters to spawn.
It does so by flying to dangerously dark areas and then throwing a hissy fit.
With the glare by your side, you’ll know that each tantrum might lead to monsters too!
– can be tamed and breed with glow berries.
– it glares at you
– if you want a mob to spawn in another mods biome:
You have to change the biome_name line to:
biome_name = “modid:name_of_the_biome”
For example with Biomes O’ Plenty:
biome_name = “biomesoplenty:cherry_blossom_grove”
To let it spawn in more biomes you have to put a comma (,) between the biome names like this:
biome_name = “modid:name_of_the_biome,minecraft:desert,minecraft:forest”
In the fabric version you dont have to write the modid.
(You have to restart the game to let the config changes happen)
In 1.19 the config for spawn settings was replaced with biome tag and biome modifier json files.
These can be found under the data folder in the jar.
If you find any errors please let me know.
Thanks for downloading my mod!
Yaysa 8x
Yaysa 8x is a resource pack created to bring a fun, cute, and modern style to Minecraft with a palette of only 89 total colors! Wow!
This pack is good for many different building styles.
Perhaps it can also help you reduce lag?
• Please note that this pack has many unfinished textures currently, but is continually being worked on
Also available on:
[CurseForge](https://www.curseforge.com/minecraft/texture-packs/yaysa-8x)
[PlanetMinecraft](https://www.planetminecraft.com/texture-pack/yaysa-8x-a-fun-cute-and-modern-resource-pack-for-minecraft/)
❤️ Support ❤️
https://ko-fi.com/poiqzy
—
#### Please include either one where it makes sense and is appropriate! 🙂
[“Yaysa 8x”](https://modrinth.com/resourcepack/yaysa-8x) by poiqzy is licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)
**or**
“Yaysa 8x” by poiqzy is licensed under CC BY 4.0
https://modrinth.com/resourcepack/yaysa-8x
https://creativecommons.org/licenses/by/4.0/
Yet Another Vampire Origin
Hey, you. Yeah, you there. You’re looking for vampire stuff, huh? But your friends wouldn’t like you being near-unkillable, dealing so much damage you can’t ever be defeated? Follow me, I’ve got something that might be up your alley…
# Yet Another Vampire Origin
Hey, don’t be deterred by the name. Plenty of love and care went into this, all right? This Origin datapack was designed to be **roughly as powerful** as the existing, base origins, without any outrageous extras.
## Powers
Let’s get into why you’re actually here- what makes this origin unique?
– [+] Outside of the sun, you’re very proficient with your predator abilities. You move faster, mine faster, and can see perfectly in the dark.
– [+] At will, you can remain at exactly the height you are at- or hover a bit higher, *menacingly~!*
– [+] You do not take fall damage.
– [+] At will, you can teleport a short distance, leaving a red trail behind you.
– [+] As an undead creature, you do not need to breathe, letting you swim without worry.
– [+] If someone looks into your eyes, they may find they can’t look away… Sneaking and looking at creatures inflicts Slowness upon them…
– [-] …which is quite useful, as the only food you can eat without growing nauseous is fresh blood. Sneak and right-click on living entities to drink from them, dealing them a small amount of damage to restore your hunger shanks.
– [-] The bright glare of the sun *weakens* you significantly; trading your speed and strength for slowness, mining fatigue and weakness.
– [-] Wooden stakes are not the only wood you fear- *any* weapon fashioned from wood is highly effective at taking you out.
– [-] As an undead creature, Smite affects you, making a wooden sword potentially even *more* dangerous. Additionally, the effects of Instant Health and Instant Damage are reversed, and you cannot profit from Regeneration… *or* Wither, for that matter.
– [-] You must be invited into spaces gated off by doors, fence gates, or trapdoors- or force your way through! Doors take longer to break and will make a lot of noise, though.
This datapack supports [Campanion](https://www.curseforge.com/minecraft/mc-mods/campanion) and [Medieval Weapons](https://www.curseforge.com/minecraft/mc-mods/medievalweapons) right out of the box. Feel free to suggest new mods to support over on the Issue Tracker!
Yarn Mapping Provider
# Yarn Mapping Provider Description
Yarn mapping is a project that aims to create a human-readable mapping file for the Minecraft codebase. Mapping files are used to translate obfuscated class, field, and method names to their original names.
Minecraft’s codebase is obfuscated, which means that the names of classes, fields, and methods are intentionally obfuscated to make it more difficult for others to understand and modify the code. This is done for legal reasons and to prevent cheating in multiplayer environments.
However, this obfuscation can make it difficult for developers to read and understand the code. Mapping files provide a way to translate the obfuscated names to their original names, making it easier to read and understand the code.
## Features
– Automatically download mapping file.
– Provide “named” mapping to [MappingResolver](https://maven.fabricmc.net/docs/fabric-loader-0.14.14/net/fabricmc/loader/api/MappingResolver.html) without having to use development environment. But runtime namespace still the same.
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*
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.
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](https://modrinth.com/shader/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
—
