Files
src
build.gradle
gradle.properties
manifest.kod
settings.gradle
Code
14 719
src/main/java/es/kodari/tragaperras/Tragaperras.java
package es.kodari.tragaperras;
import net.fabricmc.api.ModInitializer;
import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
import net.fabricmc.fabric.api.event.player.PlayerBlockBreakEvents;
import net.fabricmc.fabric.api.loot.v3.LootTableEvents;
import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
import net.minecraft.commands.Commands;
import net.minecraft.network.chat.Component;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.server.permissions.Permissions;
import net.minecraft.tags.BlockTags;
import net.minecraft.tags.ItemTags;
import net.minecraft.world.entity.EntitySpawnReason;
import net.minecraft.world.entity.EntityTypes;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.storage.LevelResource;
import net.minecraft.world.level.storage.loot.parameters.LootContextParams;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Tragaperras implements ModInitializer {
private static final String DEFAULT_FIRST = "Fácil\nNormal\nDifícil\nCreepers eléctricos";
private static final String DEFAULT_SECOND = "Sin armadura\nSolo herramientas de piedra\nSin escudo";
private static boolean electricCreepers;
private static final Set<String> activeChanges = new HashSet<>();
private static final Set<String> supportedChanges = Set.of(
"Árboles sin brotes", "Ender Pearls más dañinas",
"Arañas de Cueva al romper telarañas", "Daño de Lava y Fuego",
"Daño de Caída", "Daño de Fuego y Lava multiplicado",
"Endermite con 100 de daño", "Enderman con 100 de daño",
"Regeneración Natural desactivada", "Ahogamiento aumentado");
public static boolean changeEnabled(String name) {
return activeChanges.contains(name);
}
public static boolean electricCreepersEnabled() {
return electricCreepers;
}
private static Path electricCreepersFile(MinecraftServer server) {
return server.getWorldPath(LevelResource.ROOT).resolve("tragaperras").resolve("creepers_electricos.txt");
}
@Override
public void onInitialize() {
ServerLifecycleEvents.SERVER_STARTED.register(server -> electricCreepers = Files.exists(electricCreepersFile(server)));
ServerLifecycleEvents.SERVER_STOPPED.register(server -> electricCreepers = false);
ServerLifecycleEvents.SERVER_STARTED.register(server -> {
activeChanges.clear();
Path file = server.getWorldPath(LevelResource.ROOT).resolve("tragaperras").resolve("cambios.txt");
try {
if (Files.exists(file)) activeChanges.addAll(Files.readAllLines(file, StandardCharsets.UTF_8));
} catch (IOException e) {
throw new IllegalStateException("No se pudieron cargar los cambios de dificultad", e);
}
});
ServerLifecycleEvents.SERVER_STOPPED.register(server -> activeChanges.clear());
LootTableEvents.MODIFY_DROPS.register((holder, context, drops) -> {
var state = context.getOptional(LootContextParams.BLOCK_STATE);
if (changeEnabled("Árboles sin brotes") && state != null && state.is(BlockTags.LEAVES, block -> true)) {
drops.removeIf(drop -> drop.is(ItemTags.SAPLINGS));
}
});
PlayerBlockBreakEvents.AFTER.register((level, player, pos, state, blockEntity) -> {
if (changeEnabled("Arañas de Cueva al romper telarañas") && state.is(Blocks.COBWEB)
&& level instanceof ServerLevel serverLevel && level.getRandom().nextFloat() < 0.25f) {
EntityTypes.CAVE_SPIDER.spawn(serverLevel, pos, EntitySpawnReason.TRIGGERED);
}
});
PayloadTypeRegistry.clientboundPlay().register(ReelPacket.TYPE, ReelPacket.CODEC);
PayloadTypeRegistry.serverboundPlay().register(ReelPacket.TYPE, ReelPacket.CODEC);
CommandRegistrationCallback.EVENT.register((dispatcher, context, selection) -> dispatcher.register(
Commands.literal("ruleta")
.requires(source -> source.permissions().hasPermission(Permissions.COMMANDS_MODERATOR))
.executes(ctx -> {
ServerPlayer player = ctx.getSource().getPlayerOrException();
List<String> options = load(player);
ServerPlayNetworking.send(player, new ReelPacket("open", options));
return 1;
})
));
ServerPlayNetworking.registerGlobalReceiver(ReelPacket.TYPE, (packet, context) -> {
ServerPlayer player = context.player();
if (!player.permissions().hasPermission(Permissions.COMMANDS_MODERATOR)) return;
if (packet.action().equals("save")) {
if (packet.reels().size() < 2 || packet.reels().size() > 4) return;
List<String> options = packet.reels().stream().map(Tragaperras::normalize).toList();
if (options.stream().anyMatch(String::isEmpty)) {
player.sendSystemMessage(Component.literal("Cada carrete necesita al menos una opción."));
return;
}
try {
for (String option : options) ReelOptions.parse(option);
} catch (IllegalArgumentException e) {
player.sendSystemMessage(Component.literal("Configuración inválida: " + e.getMessage()));
return;
}
try {
Path directory = player.level().getServer().getWorldPath(LevelResource.ROOT).resolve("tragaperras");
Files.createDirectories(directory);
for (int i = 0; i < options.size(); i++) {
Files.writeString(directory.resolve("carrete" + (i + 1) + ".txt"), options.get(i), StandardCharsets.UTF_8);
}
Files.writeString(directory.resolve("cantidad.txt"), Integer.toString(options.size()), StandardCharsets.UTF_8);
ServerPlayNetworking.send(player, new ReelPacket("saved", options));
} catch (IOException e) {
player.sendSystemMessage(Component.literal("No se pudo guardar la ruleta: " + e.getMessage()));
}
} else if (packet.action().equals("spin") || packet.action().equals("spin_private")) {
List<String> options = load(player);
List<String> results = options.stream().map(ReelOptions::choose).toList();
Set<String> updatedChanges = new HashSet<>(activeChanges);
for (String result : results) {
for (String change : supportedChanges) {
if (change.equalsIgnoreCase(result)) updatedChanges.add(change);
}
}
if (!updatedChanges.equals(activeChanges)) {
try {
Path file = context.server().getWorldPath(LevelResource.ROOT).resolve("tragaperras").resolve("cambios.txt");
Files.createDirectories(file.getParent());
Files.write(file, updatedChanges, StandardCharsets.UTF_8);
activeChanges.clear();
activeChanges.addAll(updatedChanges);
} catch (IOException e) {
player.sendSystemMessage(Component.literal("No se pudieron guardar los cambios de dificultad: " + e.getMessage()));
}
}
if (!electricCreepers && results.stream().anyMatch(result -> result.equalsIgnoreCase("Creepers eléctricos"))) {
try {
Path file = electricCreepersFile(context.server());
Files.createDirectories(file.getParent());
Files.writeString(file, "activado\n", StandardCharsets.UTF_8);
electricCreepers = true;
} catch (IOException e) {
player.sendSystemMessage(Component.literal("No se pudo activar Creepers eléctricos: " + e.getMessage()));
}
}
for (ServerPlayer other : context.server().getPlayerList().getPlayers()) {
if (packet.action().equals("spin_private") && other != player) continue;
if (ServerPlayNetworking.canSend(other, ReelPacket.TYPE)) {
if (other != player) ServerPlayNetworking.send(other, new ReelPacket("open", options));
ServerPlayNetworking.send(other, new ReelPacket("result", results));
} else {
other.sendSystemMessage(Component.literal("Ruleta: " + String.join(" | ", results)));
}
}
}
});
}
private static String normalize(String text) {
return text.lines().map(String::strip).filter(s -> !s.isEmpty()).reduce((a, b) -> a + "\n" + b).orElse("");
}
private static List<String> load(ServerPlayer player) {
Path directory = player.level().getServer().getWorldPath(LevelResource.ROOT).resolve("tragaperras");
int count = 2;
try {
count = Math.clamp(Integer.parseInt(Files.readString(directory.resolve("cantidad.txt"), StandardCharsets.UTF_8).strip()), 2, 4);
} catch (IOException | NumberFormatException ignored) {
}
List<String> options = new ArrayList<>();
for (int i = 0; i < count; i++) {
options.add(read(directory.resolve("carrete" + (i + 1) + ".txt"), i == 0 ? DEFAULT_FIRST : DEFAULT_SECOND));
}
return options;
}
private static String read(Path path, String fallback) {
try {
if (!Files.exists(path)) return fallback;
String value = normalize(Files.readString(path, StandardCharsets.UTF_8));
ReelOptions.parse(value);
return value;
} catch (IOException | IllegalArgumentException e) {
return fallback;
}
}
}

















