diff --git a/libraries/packets/build.gradle.kts b/libraries/packets/build.gradle.kts index 070eb2b2..28466e08 100644 --- a/libraries/packets/build.gradle.kts +++ b/libraries/packets/build.gradle.kts @@ -21,6 +21,7 @@ dependencies { compileOnly("io.papermc.paper:paper-api:1.21.8-R0.1-SNAPSHOT") implementation(project(":libraries:packets:packets-api")) + implementation(project(":libraries:packets:implementations:1_21_9")) implementation(project(":libraries:packets:implementations:1_21_6")) implementation(project(":libraries:packets:implementations:1_21_5")) implementation(project(":libraries:packets:implementations:1_21_4")) diff --git a/libraries/packets/implementations/1_21_6/build.gradle.kts b/libraries/packets/implementations/1_21_6/build.gradle.kts index ba6a17b6..357fa509 100644 --- a/libraries/packets/implementations/1_21_6/build.gradle.kts +++ b/libraries/packets/implementations/1_21_6/build.gradle.kts @@ -9,8 +9,6 @@ dependencies { paperweight.paperDevBundle("1.21.7-R0.1-SNAPSHOT") compileOnly(project(":libraries:packets:packets-api")) -// compileOnly("com.fancyinnovations:fancymc:1.21.6-pre2") - testImplementation(project(":libraries:packets")) testImplementation(project(":libraries:packets:packets-api")) testImplementation("org.junit.jupiter:junit-jupiter-api:5.12.2") diff --git a/libraries/packets/implementations/1_21_9/build.gradle.kts b/libraries/packets/implementations/1_21_9/build.gradle.kts new file mode 100644 index 00000000..077ba437 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/build.gradle.kts @@ -0,0 +1,23 @@ +plugins { + id("java-library") + id("io.papermc.paperweight.userdev") +} + +paperweight.reobfArtifactConfiguration = io.papermc.paperweight.userdev.ReobfArtifactConfiguration.MOJANG_PRODUCTION + +dependencies { + paperweight.paperDevBundle("1.21.9-rc1-R0.1-SNAPSHOT") + compileOnly(project(":libraries:packets:packets-api")) + + testImplementation(project(":libraries:packets")) + testImplementation(project(":libraries:packets:packets-api")) + testImplementation("org.junit.jupiter:junit-jupiter-api:5.12.2") + testImplementation("org.junit.jupiter:junit-jupiter-engine:5.12.2") + testImplementation("org.junit.platform:junit-platform-console-standalone:1.12.2") +} + +tasks { + test { + useJUnitPlatform() + } +} \ No newline at end of file diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundAddEntityPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundAddEntityPacketImpl.java new file mode 100644 index 00000000..16fe4785 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundAddEntityPacketImpl.java @@ -0,0 +1,48 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundAddEntityPacket; +import de.oliver.fancysitula.api.utils.AngelConverter; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.network.protocol.game.ClientboundAddEntityPacket; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.phys.Vec3; +import org.bukkit.craftbukkit.util.CraftNamespacedKey; +import org.bukkit.entity.EntityType; + +import java.util.UUID; + +public class ClientboundAddEntityPacketImpl extends FS_ClientboundAddEntityPacket { + + public ClientboundAddEntityPacketImpl(int entityId, UUID entityUUID, EntityType entityType, double x, double y, double z, float yaw, float pitch, float headYaw, int velocityX, int velocityY, int velocityZ, int data) { + super(entityId, entityUUID, entityType, x, y, z, yaw, pitch, headYaw, velocityX, velocityY, velocityZ, data); + } + + @Override + public Object createPacket() { + net.minecraft.world.entity.EntityType vanillaType = BuiltInRegistries.ENTITY_TYPE.getValue(CraftNamespacedKey.toMinecraft(entityType.getKey())); + + return new ClientboundAddEntityPacket( + entityId, + entityUUID, + x, + y, + z, + AngelConverter.degreesToVanillaByte(pitch), + AngelConverter.degreesToVanillaByte(yaw), + vanillaType, + data, + new Vec3(velocityX, velocityY, velocityZ), + AngelConverter.degreesToVanillaByte(headYaw) + ); + } + + @Override + public void sendPacketTo(FS_RealPlayer player) { + ClientboundAddEntityPacket packet = (ClientboundAddEntityPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundClearDialogPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundClearDialogPacketImpl.java new file mode 100644 index 00000000..f7fb5425 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundClearDialogPacketImpl.java @@ -0,0 +1,22 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundClearDialogPacket; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import net.minecraft.network.protocol.common.ClientboundClearDialogPacket; +import net.minecraft.server.level.ServerPlayer; + +public class ClientboundClearDialogPacketImpl extends FS_ClientboundClearDialogPacket { + @Override + public Object createPacket() { + return ClientboundClearDialogPacket.INSTANCE; + } + + @Override + protected void sendPacketTo(FS_RealPlayer player) { + ClientboundClearDialogPacket packet = (ClientboundClearDialogPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundCreateOrUpdateTeamPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundCreateOrUpdateTeamPacketImpl.java new file mode 100644 index 00000000..4fdabfcc --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundCreateOrUpdateTeamPacketImpl.java @@ -0,0 +1,128 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundCreateOrUpdateTeamPacket; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import io.papermc.paper.adventure.PaperAdventure; +import net.minecraft.ChatFormatting; +import net.minecraft.network.protocol.game.ClientboundSetPlayerTeamPacket; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.scores.PlayerTeam; +import net.minecraft.world.scores.Scoreboard; +import net.minecraft.world.scores.Team; + +public class ClientboundCreateOrUpdateTeamPacketImpl extends FS_ClientboundCreateOrUpdateTeamPacket { + + private static final Scoreboard SCOREBOARD = new Scoreboard(); + + public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, CreateTeam createTeam) { + super(teamName, createTeam); + } + + public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, RemoveTeam removeTeam) { + super(teamName, removeTeam); + } + + public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, UpdateTeam updateTeam) { + super(teamName, updateTeam); + } + + public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, AddEntity addEntity) { + super(teamName, addEntity); + } + + public ClientboundCreateOrUpdateTeamPacketImpl(String teamName, RemoveEntity removeEntity) { + super(teamName, removeEntity); + } + + @Override + public Object createPacket() { + return switch (method) { + case CREATE_TEAM -> createCreateTeamPacket(); + case REMOVE_TEAM -> createRemoveTeamPacket(); + case UPDATE_TEAM -> createUpdateTeamPacket(); + case ADD_ENTITY -> createAddEntityPacket(); + case REMOVE_ENTITY -> createRemoveEntityPacket(); + }; + } + + private Object createCreateTeamPacket() { + if (createTeam == null) { + return null; + } + + PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName); + playerTeam.setDisplayName(PaperAdventure.asVanilla(createTeam.getDisplayName())); + playerTeam.setAllowFriendlyFire(createTeam.isAllowFriendlyFire()); + playerTeam.setSeeFriendlyInvisibles(createTeam.isCanSeeFriendlyInvisibles()); + playerTeam.setNameTagVisibility(Team.Visibility.valueOf(createTeam.getNameTagVisibility().getName())); + playerTeam.setCollisionRule(PlayerTeam.CollisionRule.valueOf(createTeam.getCollisionRule().getName())); + playerTeam.setColor(ChatFormatting.getById(createTeam.getColor().getId())); + playerTeam.setPlayerPrefix(PaperAdventure.asVanilla(createTeam.getPrefix())); + playerTeam.setPlayerSuffix(PaperAdventure.asVanilla(createTeam.getSuffix())); + for (String entity : createTeam.getEntities()) { + playerTeam.getPlayers().add(entity); + } + + return ClientboundSetPlayerTeamPacket.createAddOrModifyPacket(playerTeam, true); + } + + private Object createRemoveTeamPacket() { + if (removeTeam == null) { + return null; + } + + PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName); + return ClientboundSetPlayerTeamPacket.createRemovePacket(playerTeam); + } + + private Object createUpdateTeamPacket() { + if (updateTeam == null) { + return null; + } + + PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName); + playerTeam.setDisplayName(PaperAdventure.asVanilla(updateTeam.getDisplayName())); + playerTeam.setAllowFriendlyFire(updateTeam.isAllowFriendlyFire()); + playerTeam.setSeeFriendlyInvisibles(updateTeam.isCanSeeFriendlyInvisibles()); + playerTeam.setNameTagVisibility(Team.Visibility.valueOf(updateTeam.getNameTagVisibility().getName())); + playerTeam.setCollisionRule(PlayerTeam.CollisionRule.valueOf(updateTeam.getCollisionRule().getName())); + playerTeam.setColor(ChatFormatting.getById(updateTeam.getColor().getId())); + playerTeam.setPlayerPrefix(PaperAdventure.asVanilla(updateTeam.getPrefix())); + playerTeam.setPlayerSuffix(PaperAdventure.asVanilla(updateTeam.getSuffix())); + + return ClientboundSetPlayerTeamPacket.createAddOrModifyPacket(playerTeam, true); + } + + private Object createAddEntityPacket() { + if (addEntity == null) { + return null; + } + + PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName); + for (String entity : addEntity.getEntities()) { + playerTeam.getPlayers().add(entity); + } + return ClientboundSetPlayerTeamPacket.createMultiplePlayerPacket(playerTeam, addEntity.getEntities(), ClientboundSetPlayerTeamPacket.Action.ADD); + } + + private Object createRemoveEntityPacket() { + if (removeEntity == null) { + return null; + } + + PlayerTeam playerTeam = new PlayerTeam(SCOREBOARD, teamName); + for (String entity : removeEntity.getEntities()) { + playerTeam.getPlayers().add(entity); + } + return ClientboundSetPlayerTeamPacket.createMultiplePlayerPacket(playerTeam, removeEntity.getEntities(), ClientboundSetPlayerTeamPacket.Action.REMOVE); + } + + @Override + protected void sendPacketTo(FS_RealPlayer player) { + ClientboundSetPlayerTeamPacket packet = (ClientboundSetPlayerTeamPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundPlayerInfoRemovePacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundPlayerInfoRemovePacketImpl.java new file mode 100644 index 00000000..196af3b4 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundPlayerInfoRemovePacketImpl.java @@ -0,0 +1,30 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundPlayerInfoRemovePacket; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import net.minecraft.network.protocol.game.ClientboundPlayerInfoRemovePacket; +import net.minecraft.server.level.ServerPlayer; + +import java.util.List; +import java.util.UUID; + +public class ClientboundPlayerInfoRemovePacketImpl extends FS_ClientboundPlayerInfoRemovePacket { + + public ClientboundPlayerInfoRemovePacketImpl(List uuids) { + super(uuids); + } + + @Override + public Object createPacket() { + return new ClientboundPlayerInfoRemovePacket(uuids); + } + + @Override + public void sendPacketTo(FS_RealPlayer player) { + ClientboundPlayerInfoRemovePacket packet = (ClientboundPlayerInfoRemovePacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundPlayerInfoUpdatePacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundPlayerInfoUpdatePacketImpl.java new file mode 100644 index 00000000..5a9108ef --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundPlayerInfoUpdatePacketImpl.java @@ -0,0 +1,54 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundPlayerInfoUpdatePacket; +import de.oliver.fancysitula.versions.v1_21_9.utils.GameProfileImpl; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import io.papermc.paper.adventure.PaperAdventure; +import net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.level.GameType; + +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.List; + +public class ClientboundPlayerInfoUpdatePacketImpl extends FS_ClientboundPlayerInfoUpdatePacket { + + public ClientboundPlayerInfoUpdatePacketImpl(EnumSet actions, List entries) { + super(actions, entries); + } + + @Override + public Object createPacket() { + EnumSet vanillaActions = EnumSet.noneOf(ClientboundPlayerInfoUpdatePacket.Action.class); + for (FS_ClientboundPlayerInfoUpdatePacket.Action action : actions) { + vanillaActions.add(ClientboundPlayerInfoUpdatePacket.Action.valueOf(action.name())); + } + + List entries = new ArrayList<>(); + for (Entry entry : this.entries) { + entries.add(new ClientboundPlayerInfoUpdatePacket.Entry( + entry.uuid(), + GameProfileImpl.asVanilla(entry.profile()), + entry.listed(), + entry.latency(), + GameType.byId(entry.gameMode().getId()), + PaperAdventure.asVanilla(entry.displayName()), + true, + -1, + null // TODO: Add ChatSession support + )); + } + + return new ClientboundPlayerInfoUpdatePacket(vanillaActions, entries); + } + + @Override + public void sendPacketTo(FS_RealPlayer player) { + ClientboundPlayerInfoUpdatePacket packet = (ClientboundPlayerInfoUpdatePacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundRemoveEntitiesPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundRemoveEntitiesPacketImpl.java new file mode 100644 index 00000000..75da2788 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundRemoveEntitiesPacketImpl.java @@ -0,0 +1,37 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundRemoveEntitiesPacket; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import net.minecraft.network.protocol.game.ClientboundRemoveEntitiesPacket; +import net.minecraft.server.level.ServerPlayer; + +import java.util.List; + +public class ClientboundRemoveEntitiesPacketImpl extends FS_ClientboundRemoveEntitiesPacket { + + /** + * @param entityIds IDs of the entities to remove + */ + public ClientboundRemoveEntitiesPacketImpl(List entityIds) { + super(entityIds); + } + + @Override + public Object createPacket() { + int[] ids = new int[this.entityIds.size()]; + for (int i = 0; i < this.entityIds.size(); i++) { + ids[i] = this.entityIds.get(i); + } + + return new ClientboundRemoveEntitiesPacket(ids); + } + + @Override + public void sendPacketTo(FS_RealPlayer player) { + ClientboundRemoveEntitiesPacket packet = (ClientboundRemoveEntitiesPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundRotateHeadPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundRotateHeadPacketImpl.java new file mode 100644 index 00000000..816839d8 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundRotateHeadPacketImpl.java @@ -0,0 +1,38 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundRotateHeadPacket; +import de.oliver.fancysitula.api.utils.AngelConverter; +import de.oliver.fancysitula.api.utils.reflections.ReflectionUtils; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import net.minecraft.network.protocol.game.ClientboundRotateHeadPacket; +import net.minecraft.server.level.ServerPlayer; + +public class ClientboundRotateHeadPacketImpl extends FS_ClientboundRotateHeadPacket { + + public ClientboundRotateHeadPacketImpl(int entityId, float headYaw) { + super(entityId, headYaw); + } + + @Override + public Object createPacket() { + ClientboundRotateHeadPacket packet = null; + + try { + packet = ReflectionUtils.createUnsafeInstance(ClientboundRotateHeadPacket.class); + ReflectionUtils.setFinalField(packet, "entityId", entityId); + ReflectionUtils.setFinalField(packet, "yHeadRot", AngelConverter.degreesToVanillaByte(headYaw)); + } catch (Exception e) { + e.printStackTrace(); + } + return packet; + } + + @Override + public void sendPacketTo(FS_RealPlayer player) { + ClientboundRotateHeadPacket packet = (ClientboundRotateHeadPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundSetEntityDataPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundSetEntityDataPacketImpl.java new file mode 100644 index 00000000..9e6f774f --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundSetEntityDataPacketImpl.java @@ -0,0 +1,67 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundSetEntityDataPacket; +import de.oliver.fancysitula.api.utils.reflections.ReflectionUtils; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import io.papermc.paper.adventure.PaperAdventure; +import net.kyori.adventure.text.Component; +import net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket; +import net.minecraft.network.syncher.SynchedEntityData; +import net.minecraft.server.level.ServerPlayer; +import org.bukkit.block.BlockState; +import org.bukkit.craftbukkit.block.CraftBlockState; +import org.bukkit.inventory.ItemStack; + +import java.util.ArrayList; +import java.util.List; + +public class ClientboundSetEntityDataPacketImpl extends FS_ClientboundSetEntityDataPacket { + + public ClientboundSetEntityDataPacketImpl(int entityId, List entityData) { + super(entityId, entityData); + } + + @Override + public Object createPacket() { + List> dataValues = new ArrayList<>(); + for (EntityData data : entityData) { + try { + Class entityClass = Class.forName(data.getAccessor().entityClassName()); + net.minecraft.network.syncher.EntityDataAccessor accessor = ReflectionUtils.getStaticField(entityClass, data.getAccessor().accessorFieldName()); + + Object vanillaValue = data.getValue(); + + if (data.getValue() == null) { + continue; + } + + if (data.getValue() instanceof Component c) { + vanillaValue = PaperAdventure.asVanilla(c); + } + + if (data.getValue() instanceof ItemStack i) { + vanillaValue = net.minecraft.world.item.ItemStack.fromBukkitCopy(i); + } + + if (data.getValue() instanceof BlockState b) { + vanillaValue = ((CraftBlockState) b).getHandle(); + } + + dataValues.add(SynchedEntityData.DataValue.create(accessor, vanillaValue)); + } catch (ClassNotFoundException | NoSuchFieldException | IllegalAccessException e) { + e.printStackTrace(); + } + } + + return new ClientboundSetEntityDataPacket(entityId, dataValues); + } + + @Override + public void sendPacketTo(FS_RealPlayer player) { + ClientboundSetEntityDataPacket packet = (ClientboundSetEntityDataPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundSetEquipmentPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundSetEquipmentPacketImpl.java new file mode 100644 index 00000000..5a44bc19 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundSetEquipmentPacketImpl.java @@ -0,0 +1,45 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import com.mojang.datafixers.util.Pair; +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundSetEquipmentPacket; +import de.oliver.fancysitula.api.utils.FS_EquipmentSlot; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.entity.EquipmentSlot; +import org.bukkit.craftbukkit.inventory.CraftItemStack; +import org.bukkit.inventory.ItemStack; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +public class ClientboundSetEquipmentPacketImpl extends FS_ClientboundSetEquipmentPacket { + + public ClientboundSetEquipmentPacketImpl(int entityId, Map equipment) { + super(entityId, equipment); + } + + @Override + public Object createPacket() { + List> slots = new ArrayList<>(); + + for (Map.Entry entry : equipment.entrySet()) { + EquipmentSlot equipmentSlot = net.minecraft.world.entity.EquipmentSlot.byName(entry.getKey().name().toLowerCase()); + net.minecraft.world.item.ItemStack itemStack = CraftItemStack.asNMSCopy(entry.getValue()); + + slots.add(Pair.of(equipmentSlot, itemStack)); + } + + return new ClientboundSetEquipmentPacket(entityId, slots); + } + + @Override + public void sendPacketTo(FS_RealPlayer player) { + ClientboundSetEquipmentPacket packet = (ClientboundSetEquipmentPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundSetPassengersPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundSetPassengersPacketImpl.java new file mode 100644 index 00000000..228ffead --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundSetPassengersPacketImpl.java @@ -0,0 +1,45 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundSetPassengersPacket; +import de.oliver.fancysitula.api.utils.reflections.ReflectionUtils; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import net.minecraft.network.protocol.game.ClientboundSetPassengersPacket; +import net.minecraft.server.level.ServerPlayer; + +import java.util.List; + +public class ClientboundSetPassengersPacketImpl extends FS_ClientboundSetPassengersPacket { + + public ClientboundSetPassengersPacketImpl(int entityId, List passengers) { + super(entityId, passengers); + } + + + @Override + public Object createPacket() { + int[] passengers = new int[this.passengers.size()]; + for (int i = 0; i < this.passengers.size(); i++) { + passengers[i] = this.passengers.get(i); + } + + try { + ClientboundSetPassengersPacket packet = ReflectionUtils.createUnsafeInstance(ClientboundSetPassengersPacket.class); + ReflectionUtils.setFinalField(packet, "vehicle", entityId); + ReflectionUtils.setFinalField(packet, "passengers", passengers); + return packet; + } catch (Exception e) { + e.printStackTrace(); + } + + return null; + } + + @Override + public void sendPacketTo(FS_RealPlayer player) { + ClientboundSetPassengersPacket packet = (ClientboundSetPassengersPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundShowDialogPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundShowDialogPacketImpl.java new file mode 100644 index 00000000..e9629545 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundShowDialogPacketImpl.java @@ -0,0 +1,276 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.dialogs.FS_CommonDialogData; +import de.oliver.fancysitula.api.dialogs.FS_Dialog; +import de.oliver.fancysitula.api.dialogs.FS_DialogAction; +import de.oliver.fancysitula.api.dialogs.actions.FS_CommonButtonData; +import de.oliver.fancysitula.api.dialogs.actions.FS_DialogActionButton; +import de.oliver.fancysitula.api.dialogs.actions.FS_DialogCustomAction; +import de.oliver.fancysitula.api.dialogs.body.FS_DialogBody; +import de.oliver.fancysitula.api.dialogs.body.FS_DialogItemBody; +import de.oliver.fancysitula.api.dialogs.body.FS_DialogTextBody; +import de.oliver.fancysitula.api.dialogs.inputs.*; +import de.oliver.fancysitula.api.dialogs.types.FS_ConfirmationDialog; +import de.oliver.fancysitula.api.dialogs.types.FS_DialogListDialog; +import de.oliver.fancysitula.api.dialogs.types.FS_MultiActionDialog; +import de.oliver.fancysitula.api.dialogs.types.FS_NoticeDialog; +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundShowDialogPacket; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import io.papermc.paper.adventure.PaperAdventure; +import net.kyori.adventure.key.Key; +import net.kyori.adventure.text.minimessage.MiniMessage; +import net.minecraft.core.Holder; +import net.minecraft.core.HolderSet; +import net.minecraft.nbt.CompoundTag; +import net.minecraft.network.chat.Component; +import net.minecraft.network.protocol.common.ClientboundShowDialogPacket; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.dialog.*; +import net.minecraft.server.dialog.action.Action; +import net.minecraft.server.dialog.action.CustomAll; +import net.minecraft.server.dialog.body.DialogBody; +import net.minecraft.server.dialog.body.ItemBody; +import net.minecraft.server.dialog.body.PlainMessage; +import net.minecraft.server.dialog.input.*; +import net.minecraft.server.level.ServerPlayer; +import org.bukkit.craftbukkit.inventory.CraftItemStack; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public class ClientboundShowDialogPacketImpl extends FS_ClientboundShowDialogPacket { + + public ClientboundShowDialogPacketImpl(FS_Dialog dialog) { + super(dialog); + } + + @Override + public Object createPacket() { + Holder holder = Holder.direct(toNms(dialog)); + return new ClientboundShowDialogPacket(holder); + } + + @Override + protected void sendPacketTo(FS_RealPlayer player) { + ClientboundShowDialogPacket packet = (ClientboundShowDialogPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } + + private Dialog toNms(FS_Dialog dialog) { + if (dialog instanceof FS_NoticeDialog notice) { + return noticeToNms(notice); + } else if (dialog instanceof FS_ConfirmationDialog confirmation) { + return confirmationToNms(confirmation); + } else if (dialog instanceof FS_DialogListDialog dialogList) { + return dialogListToNms(dialogList); + } else if (dialog instanceof FS_MultiActionDialog multiActionDialog) { + return multiActionDialogToNms(multiActionDialog); + } + + return null; + } + + private Dialog noticeToNms(FS_NoticeDialog notice) { + CommonDialogData common = commonToNms(notice.getDialogData()); + ActionButton actionButton = actionButtonToNms(notice.getActionButton()); + + return new NoticeDialog(common, actionButton); + } + + private Dialog confirmationToNms(FS_ConfirmationDialog notice) { + CommonDialogData common = commonToNms(notice.getDialogData()); + ActionButton yes = actionButtonToNms(notice.getYesButton()); + ActionButton no = actionButtonToNms(notice.getNoButton()); + + return new ConfirmationDialog(common, yes, no); + } + + private Dialog dialogListToNms(FS_DialogListDialog dialogList) { + CommonDialogData common = commonToNms(dialogList.getDialogData()); + List> dialogs = new ArrayList<>(); + + for (FS_Dialog dialog : dialogList.getDialogs()) { + dialogs.add(Holder.direct(toNms(dialog))); + } + + HolderSet dialogSet = HolderSet.direct(dialogs); + + Optional exitButton = dialogList.getExitButton() != null ? + Optional.of(actionButtonToNms(dialogList.getExitButton())) : + Optional.empty(); + + return new DialogListDialog(common, dialogSet, exitButton, dialogList.getColumns(), dialogList.getButtonWidth()); + } + + private Dialog multiActionDialogToNms(FS_MultiActionDialog multiActionDialog) { + CommonDialogData common = commonToNms(multiActionDialog.getDialogData()); + List actionButtons = new ArrayList<>(); + + for (FS_DialogActionButton actionButton : multiActionDialog.getActions()) { + actionButtons.add(actionButtonToNms(actionButton)); + } + + Optional exitAction = multiActionDialog.getExitAction() != null ? + Optional.of(actionButtonToNms(multiActionDialog.getExitAction())) : + Optional.empty(); + + return new MultiActionDialog(common, actionButtons, exitAction, multiActionDialog.getColumns()); + } + + private CommonDialogData commonToNms(FS_CommonDialogData dialogData) { + Component title = PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(dialogData.getTitle())); + + Optional externalTitle = dialogData.getExternalTitle() != null ? + Optional.of(PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(dialogData.getExternalTitle()))) : + Optional.empty(); + + return new CommonDialogData( + title, + externalTitle, + dialogData.isCanCloseWithEscape(), + dialogData.isPause(), + actionToNms(dialogData.getAfterAction()), + bodyToNms(dialogData.getBody()), + inputsToNms(dialogData.getInputs()) + ); + } + + private DialogAction actionToNms(FS_DialogAction dialogAction) { + return switch (dialogAction) { + case CLOSE -> DialogAction.CLOSE; + case NONE -> DialogAction.NONE; + case WAIT_FOR_RESPONSE -> DialogAction.WAIT_FOR_RESPONSE; + }; + } + + private List bodyToNms(List bodies) { + List nmsBodies = new ArrayList<>(); + + for (FS_DialogBody body : bodies) { + if (body instanceof FS_DialogTextBody textBody) { + nmsBodies.add(new PlainMessage( + PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(textBody.getText())), + textBody.getWidth() + )); + } else if (body instanceof FS_DialogItemBody itemBody) { + Optional description = itemBody.getDescription() != null ? + Optional.of(new PlainMessage( + PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(itemBody.getDescription().getText())), + itemBody.getDescription().getWidth() + )) : + Optional.empty(); + + nmsBodies.add(new ItemBody( + CraftItemStack.asNMSCopy(itemBody.getItem()), + description, + itemBody.isShowDecorations(), + itemBody.isShowTooltip(), + itemBody.getWidth(), + itemBody.getHeight() + )); + } + } + + return nmsBodies; + } + + private List inputsToNms(List inputs) { + List nmsInputs = new ArrayList<>(); + + for (FS_DialogInput input : inputs) { + String key = input.getKey(); + + InputControl control = null; + if (input.getControl() instanceof FS_DialogBooleanInput booleanInput) { + control = new BooleanInput( + PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(booleanInput.getLabel())), + booleanInput.isInitial(), + booleanInput.getOnTrue(), + booleanInput.getOnFalse() + ); + } else if (input.getControl() instanceof FS_DialogNumberRangeInput numberRangeInput) { + control = new NumberRangeInput( + numberRangeInput.getWidth(), + PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(numberRangeInput.getLabel())), + numberRangeInput.getLabelFormat(), + new NumberRangeInput.RangeInfo( + numberRangeInput.getStart(), + numberRangeInput.getEnd(), + numberRangeInput.getInitial() != null ? Optional.of(numberRangeInput.getInitial()) : Optional.empty(), + numberRangeInput.getStep() != null ? Optional.of(numberRangeInput.getStep()) : Optional.empty() + ) + ); + } else if (input.getControl() instanceof FS_DialogSingleOptionInput singleOptionInput) { + List nmsEntries = new ArrayList<>(); + for (FS_DialogSingleOptionInput.Entry entry : singleOptionInput.getEntries()) { + nmsEntries.add(new SingleOptionInput.Entry( + entry.getId(), + entry.getDisplay() != null ? Optional.of(PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(entry.getDisplay()))) : Optional.empty(), + entry.isInitial() + )); + } + + control = new SingleOptionInput( + singleOptionInput.getWidth(), + nmsEntries, + PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(singleOptionInput.getLabel())), + singleOptionInput.isLabelVisible() + ); + } else if (input.getControl() instanceof FS_DialogTextInput textInput) { + control = new TextInput( + textInput.getWidth(), + PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(textInput.getLabel())), + textInput.isLabelVisible(), + textInput.getInitial(), + textInput.getMaxLength(), + Optional.empty() + ); + } + + nmsInputs.add(new Input(key, control)); + } + + return nmsInputs; + } + + private ActionButton actionButtonToNms(FS_DialogActionButton actionButton) { + CommonButtonData buttonData = commonButtonDataToNms(actionButton.getButtonData()); + + Action action = null; + if (actionButton.getAction() instanceof FS_DialogCustomAction customAction) { + Key idKey = Key.key("fancysitula", customAction.getId()); + ResourceLocation idLocation = PaperAdventure.asVanilla(idKey); + + Optional additions; + if (customAction.getAdditions() != null) { + CompoundTag tag = new CompoundTag(); + customAction.getAdditions().forEach(tag::putString); + additions = Optional.of(tag); + } else { + additions = Optional.empty(); + } + + action = new CustomAll(idLocation, additions); + } + + Optional optionalAction = action != null ? + Optional.of(action) : + Optional.empty(); + + return new ActionButton(buttonData, optionalAction); + } + + private CommonButtonData commonButtonDataToNms(FS_CommonButtonData commonButtonData) { + Component label = PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(commonButtonData.getLabel())); + Optional tooltip = commonButtonData.getTooltip() != null ? + Optional.of(PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(commonButtonData.getTooltip()))) : + Optional.empty(); + int width = commonButtonData.getWidth(); + + return new CommonButtonData(label, tooltip, width); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundTeleportEntityPacketImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundTeleportEntityPacketImpl.java new file mode 100644 index 00000000..8c0b5478 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/packets/ClientboundTeleportEntityPacketImpl.java @@ -0,0 +1,43 @@ +package de.oliver.fancysitula.versions.v1_21_9.packets; + +import de.oliver.fancysitula.api.entities.FS_RealPlayer; +import de.oliver.fancysitula.api.packets.FS_ClientboundTeleportEntityPacket; +import de.oliver.fancysitula.versions.v1_21_9.utils.VanillaPlayerAdapter; +import net.minecraft.network.protocol.game.ClientboundTeleportEntityPacket; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.entity.PositionMoveRotation; +import net.minecraft.world.phys.Vec3; + +import java.util.Set; + +public class ClientboundTeleportEntityPacketImpl extends FS_ClientboundTeleportEntityPacket { + + public ClientboundTeleportEntityPacketImpl(int entityId, double x, double y, double z, float yaw, float pitch, boolean onGround) { + super(entityId, x, y, z, yaw, pitch, onGround); + } + + @Override + public Object createPacket() { + ClientboundTeleportEntityPacket packet = new ClientboundTeleportEntityPacket( + entityId, + new PositionMoveRotation( + new Vec3(x, y, z), + Vec3.ZERO, + yaw, + pitch + ), + Set.of(), + onGround + ); + + return packet; + } + + @Override + public void sendPacketTo(FS_RealPlayer player) { + ClientboundTeleportEntityPacket packet = (ClientboundTeleportEntityPacket) createPacket(); + + ServerPlayer vanillaPlayer = VanillaPlayerAdapter.asVanilla(player.getBukkitPlayer()); + vanillaPlayer.connection.send(packet); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/utils/GameProfileImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/utils/GameProfileImpl.java new file mode 100644 index 00000000..993d1127 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/utils/GameProfileImpl.java @@ -0,0 +1,33 @@ +package de.oliver.fancysitula.versions.v1_21_9.utils; + +import com.mojang.authlib.GameProfile; +import de.oliver.fancysitula.api.utils.FS_GameProfile; + +import java.util.Map; + +public class GameProfileImpl { + + public static GameProfile asVanilla(FS_GameProfile gameProfile) { + GameProfile gf = new GameProfile(gameProfile.getUUID(), gameProfile.getName()); + + for (Map.Entry entry : gameProfile.getProperties().entrySet()) { + FS_GameProfile.Property property = entry.getValue(); + + gf.properties().put(entry.getKey(), new com.mojang.authlib.properties.Property(property.name(), property.value(), property.signature())); + } + + return gf; + } + + public static FS_GameProfile fromVanilla(GameProfile gameProfile) { + FS_GameProfile fsGameProfile = new FS_GameProfile(gameProfile.id(), gameProfile.name()); + + for (Map.Entry entry : gameProfile.properties().entries()) { + com.mojang.authlib.properties.Property property = entry.getValue(); + + fsGameProfile.getProperties().put(entry.getKey(), new FS_GameProfile.Property(property.name(), property.value(), property.signature())); + } + + return fsGameProfile; + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/utils/PacketListenerImpl.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/utils/PacketListenerImpl.java new file mode 100644 index 00000000..62f9d866 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/utils/PacketListenerImpl.java @@ -0,0 +1,110 @@ +package de.oliver.fancysitula.versions.v1_21_9.utils; + +import de.oliver.fancysitula.api.packets.FS_ServerboundCustomClickActionPacket; +import de.oliver.fancysitula.api.packets.FS_ServerboundPacket; +import de.oliver.fancysitula.api.utils.FS_PacketListener; +import io.netty.channel.Channel; +import io.netty.channel.ChannelHandlerContext; +import io.netty.handler.codec.MessageToMessageDecoder; +import io.papermc.paper.adventure.PaperAdventure; +import net.minecraft.nbt.StringTag; +import net.minecraft.network.protocol.Packet; +import net.minecraft.network.protocol.common.ServerboundCustomClickActionPacket; +import net.minecraft.server.level.ServerPlayer; +import org.bukkit.craftbukkit.entity.CraftPlayer; +import org.bukkit.entity.Player; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class PacketListenerImpl extends FS_PacketListener { + + private static final String PIPELINE_NAME = "fancysitula-packet-injector"; + + public PacketListenerImpl(FS_ServerboundPacket.Type packet) { + super(packet); + } + + @Override + public void inject(Player player) { + ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle(); + + Channel channel = serverPlayer.connection.connection.channel; + + if (channel.pipeline().get(PIPELINE_NAME) != null) { + return; + } + + channel.pipeline().addAfter("decoder", PIPELINE_NAME, new MessageToMessageDecoder>() { + @Override + protected void decode(ChannelHandlerContext ctx, Packet msg, List out) { + out.add(msg); + + FS_ServerboundPacket.Type packetType = getPacketType(msg); + if (packetType == null) { + return; // Unsupported packet type + } + + if (packet == FS_ServerboundPacket.Type.ALL) { + FS_ServerboundPacket fsPacket = convert(packetType, msg); + PacketReceivedEvent packetReceivedEvent = new PacketReceivedEvent(fsPacket, player); + listeners.forEach(listener -> listener.accept(packetReceivedEvent)); + return; + } + + if (packet == packetType) { + FS_ServerboundPacket fsPacket = convert(packetType, msg); + PacketReceivedEvent packetReceivedEvent = new PacketReceivedEvent(fsPacket, player); + listeners.forEach(listener -> listener.accept(packetReceivedEvent)); + } + } + }); + } + + private FS_ServerboundPacket.Type getPacketType(Packet packet) { + String className = packet.getClass().getSimpleName(); + for (FS_ServerboundPacket.Type type : FS_ServerboundPacket.Type.values()) { + if (type.getPacketClassName().equalsIgnoreCase(className)) { + return type; + } + } + + return null; + } + + private FS_ServerboundPacket convert(FS_ServerboundPacket.Type type, Packet packet) { + switch (type) { + case CUSTOM_CLICK_ACTION -> { + ServerboundCustomClickActionPacket customClickActionPacket = (ServerboundCustomClickActionPacket) packet; + + Map payload = new HashMap<>(); + if (customClickActionPacket.payload().isPresent() && customClickActionPacket.payload().get().asCompound().isPresent()) { + customClickActionPacket.payload().get().asCompound().get().forEach((k, v) -> { + if (v.getType().getName().equals(StringTag.TYPE.getName())) { + if (v.asString().isPresent()) { + payload.put(k, v.asString().get()); + } + } else if (v.getType().getName().equals(net.minecraft.nbt.ByteTag.TYPE.getName())) { + if (v.asBoolean().isPresent()) { + payload.put(k, String.valueOf(v.asBoolean().get())); + } else if (v.asByte().isPresent()) { + payload.put(k, String.valueOf(v.asByte().get())); + } + } else { + payload.put(k, v.toString()); + } + }); + } + + return new FS_ServerboundCustomClickActionPacket( + type, + PaperAdventure.asAdventure(customClickActionPacket.id()), + payload + ); + } + // Add more cases for other packet types as needed + default -> throw new IllegalArgumentException("Unsupported packet type: " + type); + } + } +} diff --git a/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/utils/VanillaPlayerAdapter.java b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/utils/VanillaPlayerAdapter.java new file mode 100644 index 00000000..811ce518 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/main/java/de/oliver/fancysitula/versions/v1_21_9/utils/VanillaPlayerAdapter.java @@ -0,0 +1,12 @@ +package de.oliver.fancysitula.versions.v1_21_9.utils; + +import net.minecraft.server.level.ServerPlayer; +import org.bukkit.craftbukkit.entity.CraftPlayer; +import org.bukkit.entity.Player; + +public class VanillaPlayerAdapter { + + public static ServerPlayer asVanilla(Player p) { + return ((CraftPlayer) p).getHandle(); + } +} diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundAddEntityPacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundAddEntityPacketImplTest.java new file mode 100644 index 00000000..1d960809 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundAddEntityPacketImplTest.java @@ -0,0 +1,64 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import de.oliver.fancysitula.api.utils.AngelConverter; +import net.minecraft.network.protocol.game.ClientboundAddEntityPacket; +import org.bukkit.entity.EntityType; + +import java.util.UUID; + +class ClientboundAddEntityPacketImplTest { + + //TODO: Fix this test (registry problems) + // @Test + void createPacket() { + int entityId = 10000; + UUID entityUUID = UUID.randomUUID(); + EntityType entityType = EntityType.PIG; + + double x = 5; + double y = 57; + double z = 203; + + float yaw = 142; + float pitch = 247; + float headYaw = 90; + + int velocityX = 0; + int velocityY = 0; + int velocityZ = 0; + + int data = 0; + + ClientboundAddEntityPacketImpl packet = new ClientboundAddEntityPacketImpl( + entityId, + entityUUID, + entityType, + x, + y, + z, + yaw, + pitch, + headYaw, + velocityX, + velocityY, + velocityZ, + data + ); + + ClientboundAddEntityPacket createdPacket = (ClientboundAddEntityPacket) packet.createPacket(); + + assert createdPacket.getId() == entityId; + assert createdPacket.getUUID().equals(entityUUID); + assert createdPacket.getType().getDescriptionId().equals(entityType.getKey().getKey()); + assert createdPacket.getX() == x; + assert createdPacket.getY() == y; + assert createdPacket.getZ() == z; + assert createdPacket.getYRot() == AngelConverter.degreesToVanillaByte(yaw); + assert createdPacket.getXRot() == AngelConverter.degreesToVanillaByte(pitch); + assert createdPacket.getYHeadRot() == AngelConverter.degreesToVanillaByte(headYaw); + assert createdPacket.getXa() == velocityX; + assert createdPacket.getYa() == velocityY; + assert createdPacket.getZa() == velocityZ; + assert createdPacket.getData() == data; + } +} \ No newline at end of file diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundClearDialogPacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundClearDialogPacketImplTest.java new file mode 100644 index 00000000..5496c66d --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundClearDialogPacketImplTest.java @@ -0,0 +1,14 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import org.junit.jupiter.api.Test; + +public class ClientboundClearDialogPacketImplTest { + + @Test + void createPacket() { + ClientboundClearDialogPacketImpl packet = new ClientboundClearDialogPacketImpl(); + assert packet.createPacket() != null : "Packet creation failed"; +// assert packet.equals(ClientboundClearDialogPacket.INSTANCE); + } + +} diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundPlayerInfoRemovePacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundPlayerInfoRemovePacketImplTest.java new file mode 100644 index 00000000..697ed995 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundPlayerInfoRemovePacketImplTest.java @@ -0,0 +1,22 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import net.minecraft.network.protocol.game.ClientboundPlayerInfoRemovePacket; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.UUID; + +class ClientboundPlayerInfoRemovePacketImplTest { + + @Test + void createPacket() { + List uuids = List.of(UUID.randomUUID(), UUID.randomUUID()); + + ClientboundPlayerInfoRemovePacketImpl packet = new ClientboundPlayerInfoRemovePacketImpl(uuids); + ClientboundPlayerInfoRemovePacket vanillaPacket = (ClientboundPlayerInfoRemovePacket) packet.createPacket(); + + for (UUID uuid : uuids) { + assert vanillaPacket.profileIds().contains(uuid); + } + } +} \ No newline at end of file diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundPlayerInfoUpdatePacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundPlayerInfoUpdatePacketImplTest.java new file mode 100644 index 00000000..fae3abba --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundPlayerInfoUpdatePacketImplTest.java @@ -0,0 +1,61 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import de.oliver.fancysitula.api.packets.FS_ClientboundPlayerInfoUpdatePacket; +import de.oliver.fancysitula.api.utils.FS_GameProfile; +import de.oliver.fancysitula.api.utils.FS_GameType; +import net.kyori.adventure.text.Component; +import net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.List; +import java.util.UUID; + +class ClientboundPlayerInfoUpdatePacketImplTest { + + @Test + void createPacket() { + // Setup packet + EnumSet actions = EnumSet.noneOf(FS_ClientboundPlayerInfoUpdatePacket.Action.class); + actions.add(FS_ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER); + actions.add(FS_ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME); + actions.add(FS_ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED); + + FS_GameProfile gameProfile = new FS_GameProfile(UUID.randomUUID(), "Test name"); + boolean listed = true; + int latency = 42; + FS_GameType gameMode = FS_GameType.SURVIVAL; + Component displayName = Component.text("Test displayname"); + + List entries = new ArrayList<>(); + entries.add(new FS_ClientboundPlayerInfoUpdatePacket.Entry( + gameProfile.getUUID(), + gameProfile, + listed, + latency, + gameMode, + displayName + )); + + ClientboundPlayerInfoUpdatePacketImpl packet = new ClientboundPlayerInfoUpdatePacketImpl(actions, entries); + + ClientboundPlayerInfoUpdatePacket createdPacket = (ClientboundPlayerInfoUpdatePacket) packet.createPacket(); + + assert createdPacket.entries().size() == 1; + assert createdPacket.actions().size() == 3; + + // check entry + ClientboundPlayerInfoUpdatePacket.Entry entry = createdPacket.entries().getFirst(); + assert entry.profile().getId().equals(gameProfile.getUUID()); + assert entry.profile().getName().equals(gameProfile.getName()); + assert entry.listed() == listed; + assert entry.latency() == latency; + assert entry.gameMode().getId() == gameMode.getId(); + + // check actions + assert createdPacket.actions().contains(ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER); + assert createdPacket.actions().contains(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME); + assert createdPacket.actions().contains(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED); + } +} \ No newline at end of file diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundRemoveEntitiesPacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundRemoveEntitiesPacketImplTest.java new file mode 100644 index 00000000..71cee44b --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundRemoveEntitiesPacketImplTest.java @@ -0,0 +1,20 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import net.minecraft.network.protocol.game.ClientboundRemoveEntitiesPacket; +import org.junit.jupiter.api.Test; + +import java.util.List; + +class ClientboundRemoveEntitiesPacketImplTest { + + @Test + void createPacket() { + List entityIds = List.of(95, 120, 154, 187); + + ClientboundRemoveEntitiesPacketImpl packet = new ClientboundRemoveEntitiesPacketImpl(entityIds); + ClientboundRemoveEntitiesPacket createdPacket = (ClientboundRemoveEntitiesPacket) packet.createPacket(); + + assert createdPacket.getEntityIds().size() == entityIds.size(); + assert createdPacket.getEntityIds().containsAll(entityIds); + } +} \ No newline at end of file diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundRotateHeadPacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundRotateHeadPacketImplTest.java new file mode 100644 index 00000000..749d1f0f --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundRotateHeadPacketImplTest.java @@ -0,0 +1,20 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import de.oliver.fancysitula.api.utils.reflections.ReflectionUtils; +import net.minecraft.network.protocol.game.ClientboundRotateHeadPacket; +import org.junit.jupiter.api.Test; + +class ClientboundRotateHeadPacketImplTest { + + @Test + void createPacket() throws Exception { + int entityId = 184; + float headYaw = 45; + + ClientboundRotateHeadPacketImpl packet = new ClientboundRotateHeadPacketImpl(entityId, (byte) headYaw); + ClientboundRotateHeadPacket createdPacket = (ClientboundRotateHeadPacket) packet.createPacket(); + + assert ReflectionUtils.getField(createdPacket, "entityId").equals(entityId); + assert createdPacket.getYHeadRot() == headYaw; + } +} \ No newline at end of file diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetEntityDataPacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetEntityDataPacketImplTest.java new file mode 100644 index 00000000..ac55023b --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetEntityDataPacketImplTest.java @@ -0,0 +1,28 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import de.oliver.fancysitula.api.packets.FS_ClientboundSetEntityDataPacket; +import de.oliver.fancysitula.api.utils.entityData.FS_TextDisplayData; +import net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket; + +import java.util.List; + +class ClientboundSetEntityDataPacketImplTest { + + //TODO: Fix this test (using registry) +// @Test + void createPacket() { + int entityId = 712; + List entityData = List.of( + new FS_ClientboundSetEntityDataPacket.EntityData( + FS_TextDisplayData.TEXT, + "Hello, World!" + ) + ); + + ClientboundSetEntityDataPacketImpl packet = new ClientboundSetEntityDataPacketImpl(entityId, entityData); + ClientboundSetEntityDataPacket createdPacket = (ClientboundSetEntityDataPacket) packet.createPacket(); + + assert createdPacket.id() == entityId; + assert createdPacket.packedItems().size() == 1; + } +} \ No newline at end of file diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetEquipmentPacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetEquipmentPacketImplTest.java new file mode 100644 index 00000000..64784728 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetEquipmentPacketImplTest.java @@ -0,0 +1,28 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import de.oliver.fancysitula.api.utils.FS_EquipmentSlot; +import net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket; +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; + +import java.util.Map; + +class ClientboundSetEquipmentPacketImplTest { + + //TODO: Fix this test (registry problems) + // @Test + void createPacket() { + // Setup packet + Map equipment = Map.of( + FS_EquipmentSlot.MAINHAND, new ItemStack(Material.DIAMOND_SWORD), + FS_EquipmentSlot.OFFHAND, new ItemStack(Material.SHIELD), + FS_EquipmentSlot.HEAD, new ItemStack(Material.DIAMOND_HELMET) + ); + + ClientboundSetEquipmentPacketImpl packet = new ClientboundSetEquipmentPacketImpl(42, equipment); + ClientboundSetEquipmentPacket createdPacket = (ClientboundSetEquipmentPacket) packet.createPacket(); + + assert createdPacket.getEntity() == 42; + assert createdPacket.getSlots().size() == 3; + } +} \ No newline at end of file diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetPassengersPacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetPassengersPacketImplTest.java new file mode 100644 index 00000000..03ee3a01 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundSetPassengersPacketImplTest.java @@ -0,0 +1,28 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import net.minecraft.network.protocol.game.ClientboundSetPassengersPacket; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; + +public class ClientboundSetPassengersPacketImplTest { + + @Test + void createPacket() { + // Setup packet + int vehicleID = 712; + List passengers = new ArrayList<>(); + passengers.add(571); + passengers.add(572); + + ClientboundSetPassengersPacketImpl packet = new ClientboundSetPassengersPacketImpl(vehicleID, passengers); + ClientboundSetPassengersPacket createdPacket = (ClientboundSetPassengersPacket) packet.createPacket(); + + // Check packet + assert createdPacket.getVehicle() == vehicleID; + assert createdPacket.getPassengers().length == 2; + assert createdPacket.getPassengers()[0] == 571; + assert createdPacket.getPassengers()[1] == 572; + } +} diff --git a/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundTeleportEntityPacketImplTest.java b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundTeleportEntityPacketImplTest.java new file mode 100644 index 00000000..215e51d8 --- /dev/null +++ b/libraries/packets/implementations/1_21_9/src/test/java/de/oliver/fancysitula/versions/v1_21_6/packets/ClientboundTeleportEntityPacketImplTest.java @@ -0,0 +1,30 @@ +package de.oliver.fancysitula.versions.v1_21_6.packets; + +import net.minecraft.network.protocol.game.ClientboundTeleportEntityPacket; +import org.junit.jupiter.api.Test; + +class ClientboundTeleportEntityPacketImplTest { + + @Test + void createPacket() { + int entityId = 4313; + double x = 15.0; + double y = 57.0; + double z = -27.0; + float yaw = 90.0f; + float pitch = 45.0f; + boolean onGround = true; + + ClientboundTeleportEntityPacketImpl packet = new ClientboundTeleportEntityPacketImpl(entityId, x, y, z, yaw, pitch, onGround); + ClientboundTeleportEntityPacket createdPacket = (ClientboundTeleportEntityPacket) packet.createPacket(); + + assert createdPacket != null; + assert createdPacket.id() == entityId; + assert createdPacket.change().position().x == x; + assert createdPacket.change().position().y == y; + assert createdPacket.change().position().z == z; + assert createdPacket.change().xRot() == pitch; + assert createdPacket.change().yRot() == yaw; + assert createdPacket.onGround() == onGround; + } +} \ No newline at end of file diff --git a/libraries/packets/packets-api/src/main/java/de/oliver/fancysitula/api/utils/ServerVersion.java b/libraries/packets/packets-api/src/main/java/de/oliver/fancysitula/api/utils/ServerVersion.java index f120dabb..19226207 100644 --- a/libraries/packets/packets-api/src/main/java/de/oliver/fancysitula/api/utils/ServerVersion.java +++ b/libraries/packets/packets-api/src/main/java/de/oliver/fancysitula/api/utils/ServerVersion.java @@ -7,6 +7,7 @@ import java.util.List; public enum ServerVersion { + v1_21_9("1.21.9", 773), v1_21_8("1.21.8", 772), v1_21_7("1.21.7", 772), v1_21_6("1.21.6", 771), diff --git a/libraries/packets/src/main/java/de/oliver/fancysitula/factories/PacketFactory.java b/libraries/packets/src/main/java/de/oliver/fancysitula/factories/PacketFactory.java index b02a4411..40b1d5dc 100644 --- a/libraries/packets/src/main/java/de/oliver/fancysitula/factories/PacketFactory.java +++ b/libraries/packets/src/main/java/de/oliver/fancysitula/factories/PacketFactory.java @@ -28,6 +28,9 @@ public class PacketFactory { List entries ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundPlayerInfoUpdatePacketImpl(actions, entries); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundPlayerInfoUpdatePacketImpl(actions, entries); } @@ -70,6 +73,9 @@ public class PacketFactory { int velocityZ, int data) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundAddEntityPacketImpl(entityId, entityUUID, entityType, x, y, z, yaw, pitch, headYaw, velocityX, velocityY, velocityZ, data); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundAddEntityPacketImpl(entityId, entityUUID, entityType, x, y, z, yaw, pitch, headYaw, velocityX, velocityY, velocityZ, data); } @@ -99,6 +105,9 @@ public class PacketFactory { List uuids ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundPlayerInfoRemovePacketImpl(uuids); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundPlayerInfoRemovePacketImpl(uuids); } @@ -128,6 +137,9 @@ public class PacketFactory { List entityIds ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundRemoveEntitiesPacketImpl(entityIds); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundRemoveEntitiesPacketImpl(entityIds); } @@ -169,6 +181,9 @@ public class PacketFactory { boolean onGround ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundTeleportEntityPacketImpl(entityId, x, y, z, yaw, pitch, onGround); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundTeleportEntityPacketImpl(entityId, x, y, z, yaw, pitch, onGround); } @@ -200,6 +215,9 @@ public class PacketFactory { float headYaw ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundRotateHeadPacketImpl(entityId, headYaw); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundRotateHeadPacketImpl(entityId, headYaw); } @@ -231,6 +249,9 @@ public class PacketFactory { List entityData ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundSetEntityDataPacketImpl(entityId, entityData); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundSetEntityDataPacketImpl(entityId, entityData); } @@ -262,6 +283,9 @@ public class PacketFactory { Map equipment ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundSetEquipmentPacketImpl(entityId, equipment); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundSetEquipmentPacketImpl(entityId, equipment); } @@ -293,6 +317,9 @@ public class PacketFactory { List passengers ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundSetPassengersPacketImpl(entityId, passengers); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundSetPassengersPacketImpl(entityId, passengers); } @@ -327,6 +354,9 @@ public class PacketFactory { FS_ClientboundCreateOrUpdateTeamPacket.CreateTeam createTeam ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, createTeam); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, createTeam); } @@ -360,6 +390,9 @@ public class PacketFactory { FS_ClientboundCreateOrUpdateTeamPacket.RemoveTeam removeTeam ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, removeTeam); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, removeTeam); } @@ -393,6 +426,9 @@ public class PacketFactory { FS_ClientboundCreateOrUpdateTeamPacket.UpdateTeam updateTeam ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, updateTeam); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, updateTeam); } @@ -426,6 +462,9 @@ public class PacketFactory { FS_ClientboundCreateOrUpdateTeamPacket.AddEntity addEntity ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, addEntity); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, addEntity); } @@ -459,6 +498,9 @@ public class PacketFactory { FS_ClientboundCreateOrUpdateTeamPacket.RemoveEntity removeEntity ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, removeEntity); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundCreateOrUpdateTeamPacketImpl(teamName, removeEntity); } @@ -489,6 +531,9 @@ public class PacketFactory { FS_Dialog dialog ) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundShowDialogPacketImpl(dialog); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundShowDialogPacketImpl(dialog); } @@ -504,6 +549,9 @@ public class PacketFactory { */ public FS_ClientboundClearDialogPacket createClearDialogPacket() { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.packets.ClientboundClearDialogPacketImpl(); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.packets.ClientboundClearDialogPacketImpl(); } diff --git a/libraries/packets/src/main/java/de/oliver/fancysitula/factories/PacketListenerFactory.java b/libraries/packets/src/main/java/de/oliver/fancysitula/factories/PacketListenerFactory.java index 612d82f8..d6781e9d 100644 --- a/libraries/packets/src/main/java/de/oliver/fancysitula/factories/PacketListenerFactory.java +++ b/libraries/packets/src/main/java/de/oliver/fancysitula/factories/PacketListenerFactory.java @@ -8,6 +8,9 @@ public class PacketListenerFactory { public FS_PacketListener createPacketListener(FS_ServerboundPacket.Type packet) { switch (ServerVersion.getCurrentVersion()) { + case v1_21_9 -> { + return new de.oliver.fancysitula.versions.v1_21_9.utils.PacketListenerImpl(packet); + } case v1_21_6, v1_21_7, v1_21_8 -> { return new de.oliver.fancysitula.versions.v1_21_6.utils.PacketListenerImpl(packet); } diff --git a/plugins/fancydialogs/release_deployment_config.json b/plugins/fancydialogs/release_deployment_config.json index 1c718a8b..3b362b3b 100644 --- a/plugins/fancydialogs/release_deployment_config.json +++ b/plugins/fancydialogs/release_deployment_config.json @@ -7,7 +7,8 @@ "supported_versions": [ "1.21.6", "1.21.7", - "1.21.8" + "1.21.8", + "1.21.9" ], "channel": "RELEASE", "loaders": [ diff --git a/plugins/fancydialogs/snapshot_deployment_config.json b/plugins/fancydialogs/snapshot_deployment_config.json index c82ebe73..728e7df9 100644 --- a/plugins/fancydialogs/snapshot_deployment_config.json +++ b/plugins/fancydialogs/snapshot_deployment_config.json @@ -7,7 +7,8 @@ "supported_versions": [ "1.21.6", "1.21.7", - "1.21.8" + "1.21.8", + "1.21.9" ], "channel": "ALPHA", "loaders": [ diff --git a/plugins/fancyholograms-v2/release_deployment_config.json b/plugins/fancyholograms-v2/release_deployment_config.json index e6201b27..0dcba9b9 100644 --- a/plugins/fancyholograms-v2/release_deployment_config.json +++ b/plugins/fancyholograms-v2/release_deployment_config.json @@ -21,7 +21,8 @@ "1.21.5", "1.21.6", "1.21.7", - "1.21.8" + "1.21.8", + "1.21.9" ], "channel": "RELEASE", "loaders": [ diff --git a/plugins/fancyholograms-v2/snapshot_deployment_config.json b/plugins/fancyholograms-v2/snapshot_deployment_config.json index 9d3d3b59..4cc2b23e 100644 --- a/plugins/fancyholograms-v2/snapshot_deployment_config.json +++ b/plugins/fancyholograms-v2/snapshot_deployment_config.json @@ -21,7 +21,8 @@ "1.21.5", "1.21.6", "1.21.7", - "1.21.8" + "1.21.8", + "1.21.9" ], "channel": "ALPHA", "loaders": [ diff --git a/plugins/fancyholograms/release_deployment_config.json b/plugins/fancyholograms/release_deployment_config.json index d30ab8e6..9eb7de7a 100644 --- a/plugins/fancyholograms/release_deployment_config.json +++ b/plugins/fancyholograms/release_deployment_config.json @@ -13,7 +13,10 @@ "1.21.3", "1.21.4", "1.21.5", - "1.21.6" + "1.21.6", + "1.21.7", + "1.21.8", + "1.21.9" ], "channel": "RELEASE", "loaders": [ diff --git a/plugins/fancyholograms/snapshot_deployment_config.json b/plugins/fancyholograms/snapshot_deployment_config.json index 46875ac5..b192bc03 100644 --- a/plugins/fancyholograms/snapshot_deployment_config.json +++ b/plugins/fancyholograms/snapshot_deployment_config.json @@ -13,7 +13,10 @@ "1.21.3", "1.21.4", "1.21.5", - "1.21.6" + "1.21.6", + "1.21.7", + "1.21.8", + "1.21.9" ], "channel": "ALPHA", "loaders": [ diff --git a/plugins/fancynpcs/build.gradle.kts b/plugins/fancynpcs/build.gradle.kts index 0a27fd7e..1a642197 100644 --- a/plugins/fancynpcs/build.gradle.kts +++ b/plugins/fancynpcs/build.gradle.kts @@ -31,6 +31,7 @@ val supportedVersions = "1.21.6", "1.21.7", "1.21.8", + "1.21.9", ) allprojects { @@ -54,6 +55,7 @@ dependencies { compileOnly("io.papermc.paper:paper-api:1.21.8-R0.1-SNAPSHOT") implementation(project(":plugins:fancynpcs:fn-api")) + implementation(project(":plugins:fancynpcs:implementation_1_21_9")) implementation(project(":plugins:fancynpcs:implementation_1_21_6")) implementation(project(":plugins:fancynpcs:implementation_1_21_5")) implementation(project(":plugins:fancynpcs:implementation_1_21_4")) @@ -79,10 +81,10 @@ dependencies { implementation("de.oliver.FancyAnalytics:java-sdk:0.0.4") implementation("de.oliver.FancyAnalytics:mc-api:0.1.11") implementation("de.oliver.FancyAnalytics:logger:0.0.8") - implementation("org.incendo:cloud-core:2.1.0-SNAPSHOT") + implementation("org.incendo:cloud-core:2.0.0") implementation("org.incendo:cloud-paper:2.0.0-beta.11") - implementation("org.incendo:cloud-annotations:2.1.0-SNAPSHOT") - annotationProcessor("org.incendo:cloud-annotations:2.1.0-SNAPSHOT") + implementation("org.incendo:cloud-annotations:2.0.0") + annotationProcessor("org.incendo:cloud-annotations:2.0.0") implementation("org.mineskin:java-client-jsoup:3.0.3-SNAPSHOT") compileOnly("me.clip:placeholderapi:2.11.6") diff --git a/plugins/fancynpcs/implementation_1_21_9/build.gradle.kts b/plugins/fancynpcs/implementation_1_21_9/build.gradle.kts new file mode 100644 index 00000000..449fc540 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/build.gradle.kts @@ -0,0 +1,27 @@ +plugins { + id("java-library") + id("io.papermc.paperweight.userdev") +} + +paperweight.reobfArtifactConfiguration = io.papermc.paperweight.userdev.ReobfArtifactConfiguration.MOJANG_PRODUCTION + +dependencies { + paperweight.paperDevBundle("1.21.9-rc1-R0.1-SNAPSHOT") +// compileOnly("com.fancyinnovations:fancymc:1.21.6-pre2") + + compileOnly(project(":plugins:fancynpcs:fn-api")) + compileOnly(project(":libraries:common")) + compileOnly("org.lushplugins:ChatColorHandler:6.0.2") +} + + +tasks { + javadoc { + options.encoding = Charsets.UTF_8.name() + } + + compileJava { + options.encoding = Charsets.UTF_8.name() + options.release = 21 + } +} \ No newline at end of file diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/FakeSynchronizer.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/FakeSynchronizer.java new file mode 100644 index 00000000..87a246c1 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/FakeSynchronizer.java @@ -0,0 +1,31 @@ +package de.oliver.fancynpcs.v1_21_9; + +import net.minecraft.network.protocol.Packet; +import net.minecraft.network.protocol.game.ClientGamePacketListener; +import net.minecraft.server.level.ServerEntity; +import net.minecraft.server.level.ServerPlayer; + +import java.util.function.Predicate; + +public class FakeSynchronizer implements ServerEntity.Synchronizer { + + public static final FakeSynchronizer INSTANCE = new FakeSynchronizer(); + + private FakeSynchronizer() { + } + + @Override + public void sendToTrackingPlayers(Packet packet) { + + } + + @Override + public void sendToTrackingPlayersAndSelf(Packet packet) { + + } + + @Override + public void sendToTrackingPlayersFiltered(Packet packet, Predicate predicate) { + + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/Npc_1_21_9.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/Npc_1_21_9.java new file mode 100644 index 00000000..ff0f3c8a --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/Npc_1_21_9.java @@ -0,0 +1,446 @@ +package de.oliver.fancynpcs.v1_21_9; + +import com.google.common.collect.ImmutableList; +import com.mojang.authlib.GameProfile; +import com.mojang.authlib.properties.Property; +import com.mojang.datafixers.util.Pair; +import de.oliver.fancylib.ReflectionUtils; +import de.oliver.fancynpcs.api.FancyNpcsPlugin; +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.api.NpcData; +import de.oliver.fancynpcs.api.events.NpcSpawnEvent; +import de.oliver.fancynpcs.api.utils.NpcEquipmentSlot; +import io.papermc.paper.adventure.PaperAdventure; +import net.minecraft.Optionull; +import net.minecraft.core.Holder; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.RemoteChatSession; +import net.minecraft.network.protocol.game.*; +import net.minecraft.network.syncher.SynchedEntityData; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ClientInformation; +import net.minecraft.server.level.ServerEntity; +import net.minecraft.server.level.ServerLevel; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.entity.*; +import net.minecraft.world.entity.ai.attributes.Attribute; +import net.minecraft.world.entity.ai.attributes.AttributeInstance; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.phys.Vec3; +import net.minecraft.world.scores.PlayerTeam; +import net.minecraft.world.scores.Scoreboard; +import net.minecraft.world.scores.Team; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.craftbukkit.CraftServer; +import org.bukkit.craftbukkit.CraftWorld; +import org.bukkit.craftbukkit.entity.CraftPlayer; +import org.bukkit.craftbukkit.inventory.CraftItemStack; +import org.bukkit.craftbukkit.util.CraftNamespacedKey; +import org.bukkit.entity.Player; +import org.lushplugins.chatcolorhandler.ModernChatColorHandler; + +import java.util.*; +import java.util.concurrent.TimeUnit; + +public class Npc_1_21_9 extends Npc { + + private final String localName; + private final UUID uuid; + private Entity npc; + private Display.TextDisplay sittingVehicle; + + public Npc_1_21_9(NpcData data) { + super(data); + + this.localName = generateLocalName(); + this.uuid = UUID.randomUUID(); + } + + @Override + public void create() { + MinecraftServer minecraftServer = ((CraftServer) Bukkit.getServer()).getServer(); + ServerLevel serverLevel = ((CraftWorld) data.getLocation().getWorld()).getHandle(); + GameProfile gameProfile = new GameProfile(uuid, localName); + + if (data.getType() == org.bukkit.entity.EntityType.PLAYER) { + npc = new ServerPlayer(minecraftServer, serverLevel, new GameProfile(uuid, ""), ClientInformation.createDefault()); + ((ServerPlayer) npc).gameProfile = gameProfile; + } else { + Optional>> entityTypeReference = BuiltInRegistries.ENTITY_TYPE.get(CraftNamespacedKey.toMinecraft(data.getType().getKey())); + EntityType nmsType = entityTypeReference.get().value(); // TODO handle empty + EntityType.EntityFactory factory = (EntityType.EntityFactory) ReflectionUtils.getValue(nmsType, "factory"); // EntityType.factory + npc = factory.create(nmsType, serverLevel); + isTeamCreated.clear(); + } + } + + @Override + public void spawn(Player player) { + ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle(); + + if (npc == null) { + return; + } + + if (!data.getLocation().getWorld().getName().equalsIgnoreCase(serverPlayer.level().getWorld().getName())) { + return; + } + + if (data.getSkinData() != null && data.getSkinData().hasTexture()) { + String value = data.getSkinData().getTextureValue(); + String signature = data.getSkinData().getTextureSignature(); + + ((ServerPlayer) npc).getGameProfile().properties().replaceValues( + "textures", + ImmutableList.of(new Property("textures", value, signature)) + ); + } + + NpcSpawnEvent spawnEvent = new NpcSpawnEvent(this, player); + spawnEvent.callEvent(); + if (spawnEvent.isCancelled()) { + return; + } + + + if (npc instanceof ServerPlayer npcPlayer) { + EnumSet actions = EnumSet.noneOf(ClientboundPlayerInfoUpdatePacket.Action.class); + actions.add(ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER); + actions.add(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME); + if (data.isShowInTab()) { + actions.add(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED); + } + + ClientboundPlayerInfoUpdatePacket playerInfoPacket = new ClientboundPlayerInfoUpdatePacket(actions, getEntry(npcPlayer, serverPlayer)); + serverPlayer.connection.send(playerInfoPacket); + + if (data.isSpawnEntity()) { + npc.setPos(data.getLocation().x(), data.getLocation().y(), data.getLocation().z()); + } + } + + ClientboundAddEntityPacket addEntityPacket = new ClientboundAddEntityPacket( + npc.getId(), + npc.getUUID(), + data.getLocation().x(), + data.getLocation().y(), + data.getLocation().z(), + data.getLocation().getPitch(), + data.getLocation().getYaw(), + npc.getType(), + 0, + Vec3.ZERO, + data.getLocation().getYaw() + ); + serverPlayer.connection.send(addEntityPacket); + + isVisibleForPlayer.put(player.getUniqueId(), true); + + + int removeNpcsFromPlayerlistDelay = FancyNpcsPlugin.get().getFancyNpcConfig().getRemoveNpcsFromPlayerlistDelay(); + if (!data.isShowInTab() && removeNpcsFromPlayerlistDelay > 0) { + FancyNpcsPlugin.get().getNpcThread().schedule(() -> { + ClientboundPlayerInfoRemovePacket playerInfoRemovePacket = new ClientboundPlayerInfoRemovePacket(List.of(npc.getUUID())); + serverPlayer.connection.send(playerInfoRemovePacket); + }, removeNpcsFromPlayerlistDelay, TimeUnit.MILLISECONDS); + } + + update(player); + } + + @Override + public void remove(Player player) { + if (npc == null) { + return; + } + + ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle(); + + if (npc instanceof ServerPlayer npcPlayer) { + ClientboundPlayerInfoRemovePacket playerInfoRemovePacket = new ClientboundPlayerInfoRemovePacket(List.of((npcPlayer.getUUID()))); + serverPlayer.connection.send(playerInfoRemovePacket); + } + + // remove entity + ClientboundRemoveEntitiesPacket removeEntitiesPacket = new ClientboundRemoveEntitiesPacket(npc.getId()); + serverPlayer.connection.send(removeEntitiesPacket); + + // remove sitting vehicle + if (sittingVehicle != null) { + ClientboundRemoveEntitiesPacket removeSittingVehiclePacket = new ClientboundRemoveEntitiesPacket(sittingVehicle.getId()); + serverPlayer.connection.send(removeSittingVehiclePacket); + } + + isVisibleForPlayer.put(serverPlayer.getUUID(), false); + } + + @Override + public void lookAt(Player player, Location location) { + if (npc == null) { + return; + } + + ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle(); + + npc.setRot(location.getYaw(), location.getPitch()); + npc.setYHeadRot(location.getYaw()); + npc.setXRot(location.getPitch()); + npc.setYRot(location.getYaw()); + + ClientboundTeleportEntityPacket teleportEntityPacket = new ClientboundTeleportEntityPacket( + npc.getId(), + new PositionMoveRotation( + new Vec3(data.getLocation().getX(), data.getLocation().getY(), data.getLocation().getZ()), + Vec3.ZERO, + location.getYaw(), + location.getPitch() + ), + Set.of(), + false + ); + serverPlayer.connection.send(teleportEntityPacket); + + float angelMultiplier = 256f / 360f; + ClientboundRotateHeadPacket rotateHeadPacket = new ClientboundRotateHeadPacket(npc, (byte) (location.getYaw() * angelMultiplier)); + serverPlayer.connection.send(rotateHeadPacket); + } + + @Override + public void update(Player player, boolean swingArm) { + if (npc == null) { + return; + } + + if (!isVisibleForPlayer.getOrDefault(player.getUniqueId(), false)) { + return; + } + + ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle(); + + PlayerTeam team = new PlayerTeam(new Scoreboard(), "npc-" + localName); + team.getPlayers().clear(); + team.getPlayers().add(npc instanceof ServerPlayer npcPlayer ? npcPlayer.getGameProfile().name() : npc.getStringUUID()); + team.setColor(PaperAdventure.asVanilla(data.getGlowingColor())); + if (!data.isCollidable()) { + team.setCollisionRule(Team.CollisionRule.NEVER); + } + + net.kyori.adventure.text.Component displayName = ModernChatColorHandler.translate(data.getDisplayName(), serverPlayer.getBukkitEntity()); + Component vanillaComponent = PaperAdventure.asVanilla(displayName); + if (!(npc instanceof ServerPlayer)) { + npc.setCustomName(vanillaComponent); + npc.setCustomNameVisible(true); + } else { + npc.setCustomName(null); + npc.setCustomNameVisible(false); + } + + if (data.getDisplayName().equalsIgnoreCase("")) { + team.setNameTagVisibility(Team.Visibility.NEVER); + npc.setCustomName(null); + npc.setCustomNameVisible(false); + } else { + team.setNameTagVisibility(Team.Visibility.ALWAYS); + } + + if (npc instanceof ServerPlayer npcPlayer) { + team.setPlayerPrefix(vanillaComponent); + npcPlayer.listName = vanillaComponent; + + EnumSet actions = EnumSet.noneOf(ClientboundPlayerInfoUpdatePacket.Action.class); + actions.add(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME); + if (data.isShowInTab()) { + actions.add(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED); + } + + ClientboundPlayerInfoUpdatePacket playerInfoPacket = new ClientboundPlayerInfoUpdatePacket(actions, getEntry(npcPlayer, serverPlayer)); + serverPlayer.connection.send(playerInfoPacket); + } + + boolean isTeamCreatedForPlayer = this.isTeamCreated.getOrDefault(player.getUniqueId(), false); + serverPlayer.connection.send(ClientboundSetPlayerTeamPacket.createAddOrModifyPacket(team, !isTeamCreatedForPlayer)); + isTeamCreated.put(player.getUniqueId(), true); + + npc.setGlowingTag(data.isGlowing()); + + data.applyAllAttributes(this); + + // Set equipment + List> equipmentList = new ArrayList<>(); + if (data.getEquipment() != null) { + for (NpcEquipmentSlot slot : data.getEquipment().keySet()) { + equipmentList.add(new Pair<>(EquipmentSlot.byName(slot.toNmsName()), CraftItemStack.asNMSCopy(data.getEquipment().get(slot)))); + } + } + + // Set body slot (from happy ghast harness attribute) + if (npc instanceof LivingEntity livingEntity) { + ItemStack bodySlot = livingEntity.getItemBySlot(EquipmentSlot.BODY); + if (!bodySlot.isEmpty()) { + equipmentList.add(new Pair<>(EquipmentSlot.BODY, bodySlot)); + } + } + + if (!equipmentList.isEmpty()) { + ClientboundSetEquipmentPacket setEquipmentPacket = new ClientboundSetEquipmentPacket(npc.getId(), equipmentList); + serverPlayer.connection.send(setEquipmentPacket); + } + + if (npc instanceof ServerPlayer) { + // Enable second layer of skin (https://wiki.vg/Entity_metadata#Player) + npc.getEntityData().set(net.minecraft.world.entity.player.Player.DATA_PLAYER_MODE_CUSTOMISATION, (byte) (0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40)); + } + + refreshEntityData(player); + + if (data.isSpawnEntity() && data.getLocation() != null) { + move(player, swingArm); + } + + NpcAttribute playerPoseAttr = FancyNpcsPlugin.get().getAttributeManager().getAttributeByName(org.bukkit.entity.EntityType.PLAYER, "pose"); + if (data.getAttributes().containsKey(playerPoseAttr)) { + String pose = data.getAttributes().get(playerPoseAttr); + + if (pose.equals("sitting")) { + setSitting(serverPlayer); + } else { + if (sittingVehicle != null) { + ClientboundRemoveEntitiesPacket removeSittingVehiclePacket = new ClientboundRemoveEntitiesPacket(sittingVehicle.getId()); + serverPlayer.connection.send(removeSittingVehiclePacket); + } + } + + } + + if (npc instanceof LivingEntity) { + Holder.Reference scaleAttribute = BuiltInRegistries.ATTRIBUTE.get(ResourceLocation.parse("minecraft:scale")).get(); + AttributeInstance attributeInstance = new AttributeInstance(scaleAttribute, (a) -> { + }); + attributeInstance.setBaseValue(data.getScale()); + + ClientboundUpdateAttributesPacket updateAttributesPacket = new ClientboundUpdateAttributesPacket(npc.getId(), List.of(attributeInstance)); + serverPlayer.connection.send(updateAttributesPacket); + + } + } + + @Override + protected void refreshEntityData(Player player) { + if (!isVisibleForPlayer.getOrDefault(player.getUniqueId(), false)) { + return; + } + + ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle(); + + SynchedEntityData.DataItem[] itemsById = (SynchedEntityData.DataItem[]) ReflectionUtils.getValue(npc.getEntityData(), "itemsById"); // itemsById + List> entityData = new ArrayList<>(); + for (SynchedEntityData.DataItem dataItem : itemsById) { + entityData.add(dataItem.value()); + } + ClientboundSetEntityDataPacket setEntityDataPacket = new ClientboundSetEntityDataPacket(npc.getId(), entityData); + serverPlayer.connection.send(setEntityDataPacket); + } + + public void move(Player player, boolean swingArm) { + if (npc == null) { + return; + } + + ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle(); + + npc.setPosRaw(data.getLocation().x(), data.getLocation().y(), data.getLocation().z()); + npc.setRot(data.getLocation().getYaw(), data.getLocation().getPitch()); + npc.setYHeadRot(data.getLocation().getYaw()); + npc.setXRot(data.getLocation().getPitch()); + npc.setYRot(data.getLocation().getYaw()); + + ClientboundTeleportEntityPacket teleportEntityPacket = new ClientboundTeleportEntityPacket( + npc.getId(), + new PositionMoveRotation( + new Vec3(data.getLocation().getX(), data.getLocation().getY(), data.getLocation().getZ()), + Vec3.ZERO, + data.getLocation().getYaw(), + data.getLocation().getPitch() + ), + Set.of(), + false + ); + serverPlayer.connection.send(teleportEntityPacket); + + float angelMultiplier = 256f / 360f; + ClientboundRotateHeadPacket rotateHeadPacket = new ClientboundRotateHeadPacket(npc, (byte) (data.getLocation().getYaw() * angelMultiplier)); + serverPlayer.connection.send(rotateHeadPacket); + + if (swingArm && npc instanceof ServerPlayer) { + ClientboundAnimatePacket animatePacket = new ClientboundAnimatePacket(npc, 0); + serverPlayer.connection.send(animatePacket); + } + } + + private ClientboundPlayerInfoUpdatePacket.Entry getEntry(ServerPlayer npcPlayer, ServerPlayer viewer) { + GameProfile profile = npcPlayer.getGameProfile(); + if (data.isMirrorSkin()) { + GameProfile newProfile = new GameProfile(profile.id(), profile.name()); + newProfile.properties().putAll(viewer.getGameProfile().properties()); + profile = newProfile; + } + + return new ClientboundPlayerInfoUpdatePacket.Entry( + npcPlayer.getUUID(), + profile, + data.isShowInTab(), + 0, + npcPlayer.gameMode.getGameModeForPlayer(), + npcPlayer.getTabListDisplayName(), + true, + -1, + Optionull.map(npcPlayer.getChatSession(), RemoteChatSession::asData) + ); + } + + public void setSitting(ServerPlayer serverPlayer) { + if (npc == null) { + return; + } + + if (sittingVehicle == null) { + sittingVehicle = new Display.TextDisplay(EntityType.TEXT_DISPLAY, ((CraftWorld) data.getLocation().getWorld()).getHandle()); + } + + sittingVehicle.setPos(data.getLocation().x(), data.getLocation().y(), data.getLocation().z()); + + ServerEntity serverEntity = new ServerEntity( + serverPlayer.level(), + sittingVehicle, + 0, + false, + FakeSynchronizer.INSTANCE, + Set.of() + ); + ClientboundAddEntityPacket addEntityPacket = new ClientboundAddEntityPacket(sittingVehicle, serverEntity); + serverPlayer.connection.send(addEntityPacket); + + sittingVehicle.passengers = ImmutableList.of(npc); + + ClientboundSetPassengersPacket packet = new ClientboundSetPassengersPacket(sittingVehicle); + serverPlayer.connection.send(packet); + } + + @Override + public float getEyeHeight() { + return npc.getEyeHeight(); + } + + @Override + public int getEntityId() { + return npc.getId(); + } + + public Entity getNpc() { + return npc; + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/ReflectionHelper.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/ReflectionHelper.java new file mode 100644 index 00000000..8434c961 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/ReflectionHelper.java @@ -0,0 +1,13 @@ +package de.oliver.fancynpcs.v1_21_9; + +import de.oliver.fancylib.ReflectionUtils; +import de.oliver.fancynpcs.api.Npc; +import net.minecraft.world.entity.Entity; + +public class ReflectionHelper { + + public static T getEntity(Npc npc) { + return (T) ReflectionUtils.getValue(npc, "npc"); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/AgeableMobAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/AgeableMobAttributes.java new file mode 100644 index 00000000..350606fc --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/AgeableMobAttributes.java @@ -0,0 +1,38 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.AgeableMob; +import org.bukkit.entity.Ageable; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class AgeableMobAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "baby", + List.of("true", "false"), + Arrays.stream(EntityType.values()) + .filter(type -> type.getEntityClass() != null && Ageable.class.isAssignableFrom(type.getEntityClass())) + .toList(), + AgeableMobAttributes::setBaby + )); + + return attributes; + } + + private static void setBaby(Npc npc, String value) { + AgeableMob mob = ReflectionHelper.getEntity(npc); + + boolean isBaby = Boolean.parseBoolean(value); + + mob.setBaby(isBaby); + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/AllayAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/AllayAttributes.java new file mode 100644 index 00000000..0a85363e --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/AllayAttributes.java @@ -0,0 +1,34 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.allay.Allay; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class AllayAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "dancing", + List.of("true", "false"), + List.of(EntityType.ALLAY), + AllayAttributes::setDancing + )); + + return attributes; + } + + private static void setDancing(Npc npc, String value) { + Allay allay = ReflectionHelper.getEntity(npc); + + boolean dancing = Boolean.parseBoolean(value); + allay.setDancing(dancing); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ArmadilloAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ArmadilloAttributes.java new file mode 100644 index 00000000..a908115a --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ArmadilloAttributes.java @@ -0,0 +1,35 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.armadillo.Armadillo; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class ArmadilloAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "pose", + List.of("idle", "rolling", "unrolling", "scared"), + List.of(EntityType.ARMADILLO), + ArmadilloAttributes::setPose + )); + + return attributes; + } + + private static void setPose(Npc npc, String value) { + Armadillo armadillo = ReflectionHelper.getEntity(npc); + + Armadillo.ArmadilloState state = Armadillo.ArmadilloState.valueOf(value.toUpperCase()); + + armadillo.switchToState(state); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ArmorStandAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ArmorStandAttributes.java new file mode 100644 index 00000000..3974e514 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ArmorStandAttributes.java @@ -0,0 +1,35 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.decoration.ArmorStand; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class ArmorStandAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "show_arms", + List.of("true", "false"), + List.of(EntityType.ARMOR_STAND), + ArmorStandAttributes::setShowArms + )); + + return attributes; + } + + private static void setShowArms(Npc npc, String value) { + ArmorStand armorStand = ReflectionHelper.getEntity(npc); + + boolean showArms = Boolean.parseBoolean(value.toLowerCase()); + + armorStand.setShowArms(showArms); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/Attributes_1_21_9.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/Attributes_1_21_9.java new file mode 100644 index 00000000..a400882d --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/Attributes_1_21_9.java @@ -0,0 +1,56 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.NpcAttribute; + +import java.util.ArrayList; +import java.util.List; + +public class Attributes_1_21_9 { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.addAll(EntityAttributes.getAllAttributes()); + attributes.addAll(LivingEntityAttributes.getAllAttributes()); + attributes.addAll(AgeableMobAttributes.getAllAttributes()); + attributes.addAll(IllagerAttributes.getAllAttributes()); + attributes.addAll(SpellCasterAttributes.getAllAttributes()); + + attributes.addAll(PlayerAttributes.getAllAttributes()); + attributes.addAll(SheepAttributes.getAllAttributes()); + attributes.addAll(VillagerAttributes.getAllAttributes()); + attributes.addAll(FrogAttributes.getAllAttributes()); + attributes.addAll(HorseAttributes.getAllAttributes()); + attributes.addAll(ParrotAttributes.getAllAttributes()); + attributes.addAll(AxolotlAttributes.getAllAttributes()); + attributes.addAll(TropicalFishAttributes.getAllAttributes()); + attributes.addAll(FoxAttributes.getAllAttributes()); + attributes.addAll(PandaAttributes.getAllAttributes()); + attributes.addAll(GoatAttributes.getAllAttributes()); + attributes.addAll(AllayAttributes.getAllAttributes()); + attributes.addAll(CamelAttributes.getAllAttributes()); + attributes.addAll(RabbitAttributes.getAllAttributes()); + attributes.addAll(PiglinAttributes.getAllAttributes()); + attributes.addAll(CatAttributes.getAllAttributes()); + attributes.addAll(ShulkerAttributes.getAllAttributes()); + attributes.addAll(WolfAttributes.getAllAttributes()); + attributes.addAll(SlimeAttributes.getAllAttributes()); + attributes.addAll(PigAttributes.getAllAttributes()); + attributes.addAll(CowAttributes.getAllAttributes()); + attributes.addAll(ChickenAttributes.getAllAttributes()); + attributes.addAll(ArmorStandAttributes.getAllAttributes()); + attributes.addAll(BeeAttributes.getAllAttributes()); + attributes.addAll(VexAttributes.getAllAttributes()); + attributes.addAll(ArmadilloAttributes.getAllAttributes()); + attributes.addAll(HappyGhastAttributes.getAllAttributes()); + attributes.addAll(SnifferAttributes.getAllAttributes()); + + attributes.addAll(DisplayAttributes.getAllAttributes()); + attributes.addAll(TextDisplayAttributes.getAllAttributes()); + attributes.addAll(BlockDisplayAttributes.getAllAttributes()); + attributes.addAll(InteractionAttributes.getAllAttributes()); + + return attributes; + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/AxolotlAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/AxolotlAttributes.java new file mode 100644 index 00000000..d8368f2b --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/AxolotlAttributes.java @@ -0,0 +1,51 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.axolotl.Axolotl; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class AxolotlAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "variant", + Arrays.stream(Axolotl.Variant.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.AXOLOTL), + AxolotlAttributes::setVariant + )); + + attributes.add(new NpcAttribute( + "playing_dead", + List.of("true", "false"), + List.of(EntityType.AXOLOTL), + AxolotlAttributes::setPlayingDead + )); + + return attributes; + } + + private static void setVariant(Npc npc, String value) { + Axolotl axolotl = ReflectionHelper.getEntity(npc); + + Axolotl.Variant variant = Axolotl.Variant.valueOf(value.toUpperCase()); + axolotl.setVariant(variant); + } + + private static void setPlayingDead(Npc npc, String value) { + Axolotl axolotl = ReflectionHelper.getEntity(npc); + + boolean playingDead = Boolean.parseBoolean(value); + axolotl.setPlayingDead(playingDead); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/BeeAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/BeeAttributes.java new file mode 100644 index 00000000..2f0aa456 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/BeeAttributes.java @@ -0,0 +1,84 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.Bee; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class BeeAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "angry", + List.of("true", "false"), + List.of(EntityType.BEE), + BeeAttributes::setAngry + )); + + attributes.add(new NpcAttribute( + "sting", + List.of("true", "false"), + List.of(EntityType.BEE), + BeeAttributes::setSting + )); + + attributes.add(new NpcAttribute( + "nectar", + List.of("true", "false"), + List.of(EntityType.BEE), + BeeAttributes::setNectar + )); + + attributes.add(new NpcAttribute( + "rolling", + List.of("true", "false"), + List.of(EntityType.BEE), + BeeAttributes::setRolling + )); + + return attributes; + } + + private static void setAngry(Npc npc, String value) { + Bee bee = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "true" -> bee.setRemainingPersistentAngerTime(1); + case "false" -> bee.setRemainingPersistentAngerTime(0); + } + } + + private static void setSting(Npc npc, String value) { + Bee bee = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "true" -> bee.setHasStung(false); + case "false" -> bee.setHasStung(true); + } + } + + private static void setNectar(Npc npc, String value) { + Bee bee = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "true" -> bee.setHasNectar(true); + case "false" -> bee.setHasNectar(false); + } + } + + private static void setRolling(Npc npc, String value) { + Bee bee = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "true" -> bee.setRolling(true); + case "false" -> bee.setRolling(false); + } + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/BlockDisplayAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/BlockDisplayAttributes.java new file mode 100644 index 00000000..f20e7d95 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/BlockDisplayAttributes.java @@ -0,0 +1,41 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.entity.Display; +import net.minecraft.world.level.block.Block; +import org.bukkit.Material; +import org.bukkit.Registry; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class BlockDisplayAttributes { + + private static final List BLOCKS = Registry.MATERIAL.stream().filter(Material::isBlock).map(it -> it.key().value()).toList(); + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "block", + BLOCKS, + List.of(EntityType.BLOCK_DISPLAY), + BlockDisplayAttributes::setBlock + )); + + return attributes; + } + + private static void setBlock(Npc npc, String value) { + Display.BlockDisplay display = ReflectionHelper.getEntity(npc); + + Block block = BuiltInRegistries.BLOCK.getValue(ResourceLocation.parse(value.toLowerCase())); + + display.setBlockState(block.defaultBlockState()); + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/CamelAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/CamelAttributes.java new file mode 100644 index 00000000..4b17b6e9 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/CamelAttributes.java @@ -0,0 +1,54 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.FancyNpcsPlugin; +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.Pose; +import net.minecraft.world.entity.animal.camel.Camel; +import org.bukkit.Bukkit; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class CamelAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "pose", + List.of("standing", "sitting", "dashing"), + List.of(EntityType.CAMEL), + CamelAttributes::setPose + )); + + return attributes; + } + + private static void setPose(Npc npc, String value) { + Camel camel = ReflectionHelper.getEntity(npc); + + Bukkit.getScheduler().runTask(FancyNpcsPlugin.get().getPlugin(), () -> { + switch (value.toLowerCase()) { + case "standing" -> { + camel.setPose(Pose.STANDING); + camel.setDashing(false); + camel.resetLastPoseChangeTick(camel.level().getGameTime()); + } + case "sitting" -> { + camel.setPose(Pose.SITTING); + camel.setDashing(false); + camel.resetLastPoseChangeTick(-camel.level().getGameTime()); + } + case "dashing" -> { + camel.setPose(Pose.STANDING); + camel.setDashing(true); + camel.resetLastPoseChangeTick(camel.level().getGameTime()); + } + } + }); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/CatAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/CatAttributes.java new file mode 100644 index 00000000..6d399c67 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/CatAttributes.java @@ -0,0 +1,107 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.core.Holder; +import net.minecraft.core.HolderLookup; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.world.entity.animal.Cat; +import net.minecraft.world.entity.animal.CatVariant; +import net.minecraft.world.item.DyeColor; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class CatAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "variant", + getCatVariantRegistry() + .listElementIds() + .map(id -> id.location().getPath()) + .toList(), + List.of(EntityType.CAT), + CatAttributes::setVariant + )); + + attributes.add(new NpcAttribute( + "pose", + List.of("standing", "sleeping", "sitting"), + List.of(EntityType.CAT), + CatAttributes::setPose + )); + + attributes.add(new NpcAttribute( + "collar_color", + List.of("RED", "BLUE", "YELLOW", "GREEN", "PURPLE", "ORANGE", "LIME", "MAGENTA", "BROWN", "WHITE", "GRAY", "LIGHT_GRAY", "LIGHT_BLUE", "BLACK", "CYAN", "PINK", "NONE"), + List.of(EntityType.CAT), + CatAttributes::setCollarColor + )); + + return attributes; + } + + private static void setVariant(Npc npc, String value) { + final Cat cat = ReflectionHelper.getEntity(npc); + + Holder variant = getCatVariantRegistry() + .get(ResourceKey.create( + Registries.CAT_VARIANT, + ResourceLocation.withDefaultNamespace(value.toLowerCase()) + )) + .orElseThrow(); + + cat.setVariant(variant); + } + + private static void setPose(Npc npc, String value) { + final Cat cat = ReflectionHelper.getEntity(npc); + switch (value.toLowerCase()) { + case "standing" -> { + cat.setInSittingPose(false, false); + cat.setLying(false); + } + case "sleeping" -> { + cat.setInSittingPose(false, false); + cat.setLying(true); + } + case "sitting" -> { + cat.setLying(false); + cat.setOrderedToSit(true); + cat.setInSittingPose(true, false); + } + } + } + + private static HolderLookup.RegistryLookup getCatVariantRegistry() { + return MinecraftServer.getServer().registryAccess().lookupOrThrow(Registries.CAT_VARIANT); + } + + private static void setCollarColor(Npc npc, String value) { + Cat cat = ReflectionHelper.getEntity(npc); + + if (value.equalsIgnoreCase("none") || value.isEmpty()) { + // Reset to no collar + cat.setTame(false, false); + return; + } + + try { + DyeColor color = DyeColor.valueOf(value.toUpperCase()); + if (!cat.isTame()) { + cat.setTame(true, false); + } + cat.setCollarColor(color); + } catch (IllegalArgumentException e) { + System.out.println("Invalid cat collar color: " + value); + } + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ChickenAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ChickenAttributes.java new file mode 100644 index 00000000..7b421759 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ChickenAttributes.java @@ -0,0 +1,54 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.core.Holder; +import net.minecraft.core.HolderLookup; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.world.entity.animal.Chicken; +import net.minecraft.world.entity.animal.ChickenVariant; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class ChickenAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "variant", + getChickenVariantRegistry() + .listElementIds() + .map(id -> id.location().getPath()) + .toList(), + List.of(EntityType.CHICKEN), + ChickenAttributes::setVariant + )); + + return attributes; + } + + private static void setVariant(Npc npc, String value) { + final Chicken cow = ReflectionHelper.getEntity(npc); + + Holder variant = getChickenVariantRegistry() + .get(ResourceKey.create( + Registries.CHICKEN_VARIANT, + ResourceLocation.withDefaultNamespace(value.toLowerCase()) + )) + .orElseThrow(); + + cow.setVariant(variant); + } + + private static HolderLookup.RegistryLookup getChickenVariantRegistry() { + return MinecraftServer.getServer().registryAccess().lookupOrThrow(Registries.CHICKEN_VARIANT); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/CowAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/CowAttributes.java new file mode 100644 index 00000000..e40a84eb --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/CowAttributes.java @@ -0,0 +1,54 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.core.Holder; +import net.minecraft.core.HolderLookup; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.world.entity.animal.Cow; +import net.minecraft.world.entity.animal.CowVariant; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class CowAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "variant", + getCowVariantRegistry() + .listElementIds() + .map(id -> id.location().getPath()) + .toList(), + List.of(EntityType.COW), + CowAttributes::setVariant + )); + + return attributes; + } + + private static void setVariant(Npc npc, String value) { + final Cow cow = ReflectionHelper.getEntity(npc); + + Holder variant = getCowVariantRegistry() + .get(ResourceKey.create( + Registries.COW_VARIANT, + ResourceLocation.withDefaultNamespace(value.toLowerCase()) + )) + .orElseThrow(); + + cow.setVariant(variant); + } + + private static HolderLookup.RegistryLookup getCowVariantRegistry() { + return MinecraftServer.getServer().registryAccess().lookupOrThrow(Registries.COW_VARIANT); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/DisplayAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/DisplayAttributes.java new file mode 100644 index 00000000..7f6fca04 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/DisplayAttributes.java @@ -0,0 +1,37 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.Display; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class DisplayAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "billboard", + Arrays.stream(org.bukkit.entity.Display.Billboard.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.TEXT_DISPLAY, EntityType.BLOCK_DISPLAY, EntityType.ITEM_DISPLAY), + DisplayAttributes::setBillboard + )); + + return attributes; + } + + private static void setBillboard(Npc npc, String value) { + Display display = ReflectionHelper.getEntity(npc); + + Display.BillboardConstraints billboard = Display.BillboardConstraints.valueOf(value.toUpperCase()); + display.setBillboardConstraints(billboard); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/EntityAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/EntityAttributes.java new file mode 100644 index 00000000..0833ab3c --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/EntityAttributes.java @@ -0,0 +1,103 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.Entity; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class EntityAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "on_fire", + List.of("true", "false"), + Arrays.stream(EntityType.values()).toList(), + EntityAttributes::setOnFire + )); + + attributes.add(new NpcAttribute( + "invisible", + List.of("true", "false"), + Arrays.stream(EntityType.values()).toList(), + EntityAttributes::setInvisible + )); + + attributes.add(new NpcAttribute( + "silent", + List.of("true", "false"), + Arrays.stream(EntityType.values()).toList(), + EntityAttributes::setSilent + )); + + attributes.add(new NpcAttribute( + "shaking", + List.of("true", "false"), + Arrays.stream(EntityType.values()).toList(), + EntityAttributes::setShaking + )); + + attributes.add(new NpcAttribute( + "on_ground", + List.of("true", "false"), + Arrays.stream(EntityType.values()).toList(), + EntityAttributes::setOnGround + )); + + /*attributes.add(new NpcAttribute( + "entity_pose", + Arrays.stream(Pose.values()).map(Enum::toString).toList(), + Arrays.stream(EntityType.values()).toList(), + EntityAttributes::setEntityPose + ));*/ + + return attributes; + } + + private static void setOnFire(Npc npc, String value) { + Entity entity = ReflectionHelper.getEntity(npc); + + boolean onFire = Boolean.parseBoolean(value); + + entity.setSharedFlagOnFire(onFire); + + } + + private static void setInvisible(Npc npc, String value) { + Entity entity = ReflectionHelper.getEntity(npc); + + boolean invisible = Boolean.parseBoolean(value); + + entity.setInvisible(invisible); + } + + private static void setSilent(Npc npc, String value) { + Entity entity = ReflectionHelper.getEntity(npc); + + boolean silent = Boolean.parseBoolean(value); + + entity.setSilent(silent); + } + + private static void setShaking(Npc npc, String value) { + Entity entity = ReflectionHelper.getEntity(npc); + + boolean shaking = Boolean.parseBoolean(value); + + entity.setTicksFrozen(shaking ? entity.getTicksRequiredToFreeze() : 0); + } + + private static void setOnGround(Npc npc, String value) { + Entity entity = ReflectionHelper.getEntity(npc); + + boolean onGround = Boolean.parseBoolean(value); + + entity.setOnGround(onGround); + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/FoxAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/FoxAttributes.java new file mode 100644 index 00000000..bd24eeee --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/FoxAttributes.java @@ -0,0 +1,66 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.Fox; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class FoxAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "type", + Arrays.stream(Fox.Variant.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.FOX), + FoxAttributes::setType + )); + + attributes.add(new NpcAttribute( + "pose", + List.of("standing", "sleeping", "sitting"), + List.of(EntityType.FOX), + FoxAttributes::setPose + )); + + return attributes; + } + + private static void setType(Npc npc, String value) { + Fox fox = ReflectionHelper.getEntity(npc); + + Fox.Variant type = Fox.Variant.valueOf(value.toUpperCase()); + fox.setVariant(type); + } + + private static void setPose(Npc npc, String value) { + Fox fox = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "standing" -> { + fox.setIsCrouching(false); + fox.setSleeping(false); + fox.setSitting(false, false); + } + case "sleeping" -> { + fox.setSleeping(true); + fox.setSitting(false, false); + fox.setIsCrouching(false); + } + case "sitting" -> { + fox.setSitting(true, false); + fox.setSleeping(false); + fox.setIsCrouching(false); + } + } + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/FrogAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/FrogAttributes.java new file mode 100644 index 00000000..7e08a16f --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/FrogAttributes.java @@ -0,0 +1,53 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.core.Holder; +import net.minecraft.core.HolderLookup; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.world.entity.animal.frog.Frog; +import net.minecraft.world.entity.animal.frog.FrogVariant; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class FrogAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "variant", + getFrogVariantRegistry() + .listElementIds() + .map(id -> id.location().getPath()) + .toList(), + List.of(EntityType.FROG), + FrogAttributes::setVariant + )); + + return attributes; + } + + private static void setVariant(Npc npc, String value) { + final Frog frog = ReflectionHelper.getEntity(npc); + + Holder variant = getFrogVariantRegistry() + .get(ResourceKey.create( + Registries.FROG_VARIANT, + ResourceLocation.withDefaultNamespace(value.toLowerCase()) + )) + .orElseThrow(); + + frog.setVariant(variant); + } + + private static HolderLookup.RegistryLookup getFrogVariantRegistry() { + return MinecraftServer.getServer().registryAccess().lookupOrThrow(Registries.FROG_VARIANT); + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/GoatAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/GoatAttributes.java new file mode 100644 index 00000000..ace51767 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/GoatAttributes.java @@ -0,0 +1,44 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.goat.Goat; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class GoatAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "horns", + List.of("none", "left", "right", "both"), + List.of(EntityType.GOAT), + GoatAttributes::setHorns + )); + + return attributes; + } + + private static void setHorns(Npc npc, String value) { + Goat goat = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "none" -> goat.removeHorns(); + case "both" -> goat.addHorns(); + case "left" -> { + goat.getEntityData().set(Goat.DATA_HAS_LEFT_HORN, true); + goat.getEntityData().set(Goat.DATA_HAS_RIGHT_HORN, false); + } + case "right" -> { + goat.getEntityData().set(Goat.DATA_HAS_RIGHT_HORN, true); + goat.getEntityData().set(Goat.DATA_HAS_LEFT_HORN, false); + } + } + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/HappyGhastAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/HappyGhastAttributes.java new file mode 100644 index 00000000..d4340b34 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/HappyGhastAttributes.java @@ -0,0 +1,57 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.EquipmentSlot; +import net.minecraft.world.entity.animal.HappyGhast; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.Items; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class HappyGhastAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "harness", + List.of("white", "orange", "magenta", "light_blue", "yellow", "lime", "pink", "gray", "light_gray", "cyan", "purple", "blue", "brown", "green", "red", "black"), + List.of(EntityType.HAPPY_GHAST), + HappyGhastAttributes::setHarness + )); + + return attributes; + } + + private static void setHarness(Npc npc, String value) { + HappyGhast ghast = ReflectionHelper.getEntity(npc); + + ItemStack harnessItem = switch (value.toLowerCase()) { + case "white" -> Items.WHITE_HARNESS.getDefaultInstance(); + case "orange" -> Items.ORANGE_HARNESS.getDefaultInstance(); + case "magenta" -> Items.MAGENTA_HARNESS.getDefaultInstance(); + case "light_blue" -> Items.LIGHT_BLUE_HARNESS.getDefaultInstance(); + case "yellow" -> Items.YELLOW_HARNESS.getDefaultInstance(); + case "lime" -> Items.LIME_HARNESS.getDefaultInstance(); + case "pink" -> Items.PINK_HARNESS.getDefaultInstance(); + case "gray" -> Items.GRAY_HARNESS.getDefaultInstance(); + case "light_gray" -> Items.LIGHT_GRAY_HARNESS.getDefaultInstance(); + case "cyan" -> Items.CYAN_HARNESS.getDefaultInstance(); + case "purple" -> Items.PURPLE_HARNESS.getDefaultInstance(); + case "blue" -> Items.BLUE_HARNESS.getDefaultInstance(); + case "brown" -> Items.BROWN_HARNESS.getDefaultInstance(); + case "green" -> Items.GREEN_HARNESS.getDefaultInstance(); + case "red" -> Items.RED_HARNESS.getDefaultInstance(); + case "black" -> Items.BLACK_HARNESS.getDefaultInstance(); + default -> Items.AIR.getDefaultInstance(); + }; + + if (!harnessItem.isEmpty()) { + ghast.setItemSlot(EquipmentSlot.BODY, harnessItem); + } + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/HorseAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/HorseAttributes.java new file mode 100644 index 00000000..f2399d0f --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/HorseAttributes.java @@ -0,0 +1,84 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.horse.Horse; +import net.minecraft.world.entity.animal.horse.Markings; +import net.minecraft.world.entity.animal.horse.Variant; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class HorseAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "variant", + Arrays.stream(Variant.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.HORSE), + HorseAttributes::setVariant + )); + + attributes.add(new NpcAttribute( + "markings", + Arrays.stream(Markings.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.HORSE), + HorseAttributes::setMarkings + )); + + attributes.add(new NpcAttribute( + "pose", + List.of("eating", "rearing", "standing"), + Arrays.stream(EntityType.values()) + .filter(type -> type.getEntityClass() != null && (type == EntityType.HORSE || type == EntityType.DONKEY || + type == EntityType.MULE || type == EntityType.SKELETON_HORSE || type == EntityType.ZOMBIE_HORSE)) + .toList(), + HorseAttributes::setPose + )); + + return attributes; + } + + private static void setVariant(Npc npc, String value) { + Horse horse = ReflectionHelper.getEntity(npc); + + Variant variant = Variant.valueOf(value.toUpperCase()); + horse.setVariantAndMarkings(variant, horse.getMarkings()); + } + + private static void setMarkings(Npc npc, String value) { + Horse horse = ReflectionHelper.getEntity(npc); + + Markings markings = Markings.valueOf(value.toUpperCase()); + horse.setVariantAndMarkings(horse.getVariant(), markings); + } + + private static void setPose(Npc npc, String value) { + net.minecraft.world.entity.animal.horse.AbstractHorse horse = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "standing" -> { + horse.setEating(false); + horse.setStanding(0); + } + case "rearing" -> { + horse.setStanding(20); + horse.setEating(false); + } + case "eating" -> { + horse.setStanding(0); + horse.setEating(true); + } + } + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/IllagerAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/IllagerAttributes.java new file mode 100644 index 00000000..81a08b0e --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/IllagerAttributes.java @@ -0,0 +1,39 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.raid.Raider; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.Illager; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class IllagerAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "celebrating", + List.of("true", "false"), + Arrays.stream(EntityType.values()) + .filter(type -> type.getEntityClass() != null && Illager.class.isAssignableFrom(type.getEntityClass())) + .toList(), + IllagerAttributes::setCelebrating + )); + + return attributes; + } + + private static void setCelebrating(Npc npc, String value) { + Raider raider = ReflectionHelper.getEntity(npc); + + boolean isCelebrating = Boolean.parseBoolean(value); + + raider.setCelebrating(isCelebrating); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/InteractionAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/InteractionAttributes.java new file mode 100644 index 00000000..c9f37066 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/InteractionAttributes.java @@ -0,0 +1,60 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.Interaction; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class InteractionAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "height", + new ArrayList<>(), + List.of(EntityType.INTERACTION), + InteractionAttributes::setHeight + )); + + attributes.add(new NpcAttribute( + "width", + new ArrayList<>(), + List.of(EntityType.INTERACTION), + InteractionAttributes::setWidth + )); + + return attributes; + } + + private static void setHeight(Npc npc, String value) { + Interaction interaction = ReflectionHelper.getEntity(npc); + + float height; + try { + height = Float.parseFloat(value); + } catch (NumberFormatException e) { + return; + } + + interaction.setHeight(height); + } + + private static void setWidth(Npc npc, String value) { + Interaction interaction = ReflectionHelper.getEntity(npc); + + float width; + try { + width = Float.parseFloat(value); + } catch (NumberFormatException e) { + return; + } + + interaction.setWidth(width); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/LivingEntityAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/LivingEntityAttributes.java new file mode 100644 index 00000000..ac958aca --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/LivingEntityAttributes.java @@ -0,0 +1,67 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.InteractionHand; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.LivingEntity; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class LivingEntityAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + /*attributes.add(new NpcAttribute( + "hurt", + List.of("true", "false"), + Arrays.stream(EntityType.values()) + .filter(type -> type.getEntityClass() != null && LivingEntity.class.isAssignableFrom(type.getEntityClass())) + .toList(), + LivingEntityAttributes::setHurt + ));*/ + + attributes.add(new NpcAttribute( + "use_item", + List.of("main_hand", "off_hand", "none"), + Arrays.stream(EntityType.values()) + .filter(type -> type.getEntityClass() != null && LivingEntity.class.isAssignableFrom(type.getEntityClass())) + .toList(), + LivingEntityAttributes::setUseItem + )); + + return attributes; + } + + private static void setHurt(Npc npc, String value) { + net.minecraft.world.entity.LivingEntity livingEntity = ReflectionHelper.getEntity(npc); + + boolean isHurt = Boolean.parseBoolean(value); + + if (isHurt) { + livingEntity.hurtDuration = 1; + livingEntity.hurtTime = 1; + livingEntity.hurtMarked = true; + livingEntity.animateHurt(0); + } else { + livingEntity.hurtDuration = 0; + livingEntity.hurtTime = 0; + livingEntity.hurtMarked = false; + } + } + + private static void setUseItem(Npc npc, String value) { + net.minecraft.world.entity.LivingEntity livingEntity = ReflectionHelper.getEntity(npc); + + switch (value.toUpperCase()) { + case "NONE" -> livingEntity.stopUsingItem(); + case "MAIN_HAND" -> livingEntity.startUsingItem(InteractionHand.MAIN_HAND, true); + case "OFF_HAND" -> livingEntity.startUsingItem(InteractionHand.OFF_HAND, true); + } + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PandaAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PandaAttributes.java new file mode 100644 index 00000000..504dc929 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PandaAttributes.java @@ -0,0 +1,101 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancylib.ReflectionUtils; +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.network.syncher.EntityDataAccessor; +import net.minecraft.world.entity.animal.Panda; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class PandaAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "gene", + Arrays.stream(Panda.Gene.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.PANDA), + PandaAttributes::setGene + )); + + attributes.add(new NpcAttribute( + "eating", + List.of("true", "false"), + List.of(EntityType.PANDA), + PandaAttributes::setEating + )); + + attributes.add(new NpcAttribute( + "pose", + List.of("standing", "sitting", "onBack", "rolling"), + List.of(EntityType.PANDA), + PandaAttributes::setPose + )); + + return attributes; + } + + private static void setGene(Npc npc, String value) { + Panda panda = ReflectionHelper.getEntity(npc); + + Panda.Gene gene = Panda.Gene.valueOf(value.toUpperCase()); + panda.setMainGene(gene); + } + + private static void setPose(Npc npc, String value) { + Panda panda = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "standing" -> { + setFlag(panda, 8, false); //sitting + panda.roll(false); + panda.setOnBack(false); + } + case "sitting" -> { + panda.roll(false); + panda.setOnBack(false); + setFlag(panda, 8, true); //sitting + } + case "onback" -> { + setFlag(panda, 8, false); //sitting + panda.roll(false); + panda.setOnBack(true); + } + case "rolling" -> { + setFlag(panda, 8, false); //sitting + panda.setOnBack(false); + panda.roll(true); + } + } + } + + private static void setEating(Npc npc, String value) { + Panda panda = ReflectionHelper.getEntity(npc); + + boolean eating = Boolean.parseBoolean(value); + + panda.eat(eating); + } + + private static void setFlag(Panda panda, int mask, boolean value) { + EntityDataAccessor DATA_ID_FLAGS = (EntityDataAccessor) ReflectionUtils.getValue(panda, "DATA_ID_FLAGS"); + + byte b0 = panda.getEntityData().get(DATA_ID_FLAGS); + + if (value) { + panda.getEntityData().set(DATA_ID_FLAGS, (byte) (b0 | mask)); + } else { + panda.getEntityData().set(DATA_ID_FLAGS, (byte) (b0 & ~mask)); + } + + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ParrotAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ParrotAttributes.java new file mode 100644 index 00000000..de3e582f --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ParrotAttributes.java @@ -0,0 +1,59 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.Parrot; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class ParrotAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "variant", + Arrays.stream(Parrot.Variant.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.PARROT), + ParrotAttributes::setVariant + )); + + attributes.add(new NpcAttribute( + "pose", + List.of("standing", "sitting"), + List.of(EntityType.PARROT), + ParrotAttributes::setPose + )); + + return attributes; + } + + private static void setVariant(Npc npc, String value) { + Parrot parrot = ReflectionHelper.getEntity(npc); + + Parrot.Variant variant = Parrot.Variant.valueOf(value.toUpperCase()); + parrot.setVariant(variant); + } + + private static void setPose(Npc npc, String value) { + Parrot parrot = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "standing" -> { + parrot.setOrderedToSit(false); + parrot.setInSittingPose(false, false); + } + case "sitting" -> { + parrot.setOrderedToSit(true); + parrot.setInSittingPose(true, false); + } + } + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PigAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PigAttributes.java new file mode 100644 index 00000000..09e19c60 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PigAttributes.java @@ -0,0 +1,73 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.core.Holder; +import net.minecraft.core.HolderLookup; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.world.entity.EquipmentSlot; +import net.minecraft.world.entity.animal.Pig; +import net.minecraft.world.entity.animal.PigVariant; +import net.minecraft.world.item.Items; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class PigAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "variant", + getPigVariantRegistry() + .listElementIds() + .map(id -> id.location().getPath()) + .toList(), + List.of(EntityType.PIG), + PigAttributes::setVariant + )); + + attributes.add(new NpcAttribute( + "has_saddle", + List.of("true", "false"), + List.of(EntityType.PIG), + PigAttributes::setHasSaddle + )); + + return attributes; + } + + private static void setVariant(Npc npc, String value) { + final Pig pig = ReflectionHelper.getEntity(npc); + + Holder variant = getPigVariantRegistry() + .get(ResourceKey.create( + Registries.PIG_VARIANT, + ResourceLocation.withDefaultNamespace(value.toLowerCase()) + )) + .orElseThrow(); + + pig.setVariant(variant); + } + + private static void setHasSaddle(Npc npc, String value) { + Pig pig = ReflectionHelper.getEntity(npc); + + boolean hasSaddle = Boolean.parseBoolean(value.toLowerCase()); + + if (hasSaddle) { + pig.setItemSlot(EquipmentSlot.SADDLE, Items.SADDLE.getDefaultInstance()); + } + } + + private static HolderLookup.RegistryLookup getPigVariantRegistry() { + return MinecraftServer.getServer().registryAccess().lookupOrThrow(Registries.PIG_VARIANT); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PiglinAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PiglinAttributes.java new file mode 100644 index 00000000..edc8e6e9 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PiglinAttributes.java @@ -0,0 +1,34 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.monster.piglin.Piglin; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class PiglinAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "dancing", + List.of("true", "false"), + List.of(EntityType.PIGLIN), + PiglinAttributes::setDancing + )); + + return attributes; + } + + private static void setDancing(Npc npc, String value) { + Piglin piglin = ReflectionHelper.getEntity(npc); + + boolean dancing = Boolean.parseBoolean(value); + piglin.setDancing(dancing); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PlayerAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PlayerAttributes.java new file mode 100644 index 00000000..db5ac472 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/PlayerAttributes.java @@ -0,0 +1,40 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancylib.ReflectionUtils; +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.network.syncher.EntityDataAccessor; +import net.minecraft.world.entity.Entity; +import net.minecraft.world.entity.Pose; +import net.minecraft.world.entity.player.Player; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class PlayerAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "pose", + List.of("standing", "crouching", "sleeping", "swimming", "sitting"), + List.of(EntityType.PLAYER), + PlayerAttributes::setPose + )); + + return attributes; + } + + private static void setPose(Npc npc, String value) { + Player player = ReflectionHelper.getEntity(npc); + + Pose pose = Pose.valueOf(value.toUpperCase()); + + EntityDataAccessor DATA_POSE = (EntityDataAccessor) ReflectionUtils.getStaticValue(Entity.class, "DATA_POSE"); // DATA_POSE + player.getEntityData().set(DATA_POSE, pose); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/RabbitAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/RabbitAttributes.java new file mode 100644 index 00000000..7e2eed23 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/RabbitAttributes.java @@ -0,0 +1,37 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.Rabbit; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class RabbitAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "variant", + Arrays.stream(Rabbit.Variant.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.RABBIT), + RabbitAttributes::setVariant + )); + + return attributes; + } + + private static void setVariant(Npc npc, String value) { + Rabbit rabbit = ReflectionHelper.getEntity(npc); + + Rabbit.Variant variant = Rabbit.Variant.valueOf(value.toUpperCase()); + rabbit.setVariant(variant); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SheepAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SheepAttributes.java new file mode 100644 index 00000000..070bc72a --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SheepAttributes.java @@ -0,0 +1,50 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.sheep.Sheep; +import net.minecraft.world.item.DyeColor; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class SheepAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "wool_color", + Arrays.stream(DyeColor.values()).map(dyeColor -> dyeColor.name().toLowerCase()).toList(), + List.of(EntityType.SHEEP), + SheepAttributes::setColor + )); + + attributes.add(new NpcAttribute( + "sheared", + Arrays.asList("true", "false"), + List.of(EntityType.SHEEP), + SheepAttributes::setSheared + )); + + return attributes; + } + + private static void setColor(Npc npc, String value) { + Sheep sheep = ReflectionHelper.getEntity(npc); + + sheep.setColor(DyeColor.byName(value.toLowerCase(), DyeColor.WHITE)); + } + + private static void setSheared(Npc npc, String value) { + Sheep sheep = ReflectionHelper.getEntity(npc); + + boolean sheared = Boolean.parseBoolean(value); + + sheep.setSheared(sheared); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ShulkerAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ShulkerAttributes.java new file mode 100644 index 00000000..52f99c19 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/ShulkerAttributes.java @@ -0,0 +1,54 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.monster.Shulker; +import net.minecraft.world.item.DyeColor; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class ShulkerAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "color", + Arrays.stream(DyeColor.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.SHULKER), + ShulkerAttributes::setColor + )); + + attributes.add(new NpcAttribute( + "shield", + List.of("open", "closed"), + List.of(EntityType.SHULKER), + ShulkerAttributes::setShield + )); + + return attributes; + } + + private static void setColor(Npc npc, String value) { + Shulker shulker = ReflectionHelper.getEntity(npc); + + DyeColor color = DyeColor.byName(value.toLowerCase(), DyeColor.PURPLE); + shulker.getEntityData().set(Shulker.DATA_COLOR_ID, (byte) color.getId()); + } + + private static void setShield(Npc npc, String value) { + Shulker shulker = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "closed" -> shulker.setRawPeekAmount(0); + case "open" -> shulker.setRawPeekAmount(Byte.MAX_VALUE); + } + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SlimeAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SlimeAttributes.java new file mode 100644 index 00000000..ae278150 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SlimeAttributes.java @@ -0,0 +1,40 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.monster.Slime; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class SlimeAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "size", + new ArrayList<>(), + List.of(EntityType.SLIME), + SlimeAttributes::setSize + )); + + return attributes; + } + + private static void setSize(Npc npc, String value) { + Slime slime = ReflectionHelper.getEntity(npc); + + int size; + try { + size = Integer.parseInt(value); + } catch (NumberFormatException e) { + return; + } + + slime.setSize(size, false); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SnifferAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SnifferAttributes.java new file mode 100644 index 00000000..a6906109 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SnifferAttributes.java @@ -0,0 +1,36 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.sniffer.Sniffer; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class SnifferAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "state", + Arrays.stream(Sniffer.State.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.SNIFFER), + SnifferAttributes::setState + )); + + return attributes; + } + + private static void setState(Npc npc, String value) { + final Sniffer sniffer = ReflectionHelper.getEntity(npc); + + Sniffer.State state = Sniffer.State.valueOf(value.toUpperCase()); + sniffer.transitionTo(state); + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SpellCasterAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SpellCasterAttributes.java new file mode 100644 index 00000000..129b1d33 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/SpellCasterAttributes.java @@ -0,0 +1,39 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.monster.SpellcasterIllager; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.Spellcaster; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class SpellCasterAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "casting", + Arrays.stream(SpellcasterIllager.IllagerSpell.values()).map(Enum::toString).toList(), + Arrays.stream(EntityType.values()) + .filter(type -> type.getEntityClass() != null && Spellcaster.class.isAssignableFrom(type.getEntityClass())) + .toList(), + SpellCasterAttributes::setPose + )); + + return attributes; + } + + private static void setPose(Npc npc, String value) { + SpellcasterIllager spellcasterIllager = ReflectionHelper.getEntity(npc); + + SpellcasterIllager.IllagerSpell spell = SpellcasterIllager.IllagerSpell.valueOf(value); + + spellcasterIllager.setIsCastingSpell(spell); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/TextDisplayAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/TextDisplayAttributes.java new file mode 100644 index 00000000..59d2f51d --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/TextDisplayAttributes.java @@ -0,0 +1,36 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import io.papermc.paper.adventure.PaperAdventure; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.minimessage.MiniMessage; +import net.minecraft.world.entity.Display; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class TextDisplayAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "text", + new ArrayList<>(), + List.of(EntityType.TEXT_DISPLAY), + TextDisplayAttributes::setText + )); + + return attributes; + } + + private static void setText(Npc npc, String value) { + Display.TextDisplay display = ReflectionHelper.getEntity(npc); + + Component text = MiniMessage.miniMessage().deserialize(value); + display.setText(PaperAdventure.asVanilla(text)); + } +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/TropicalFishAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/TropicalFishAttributes.java new file mode 100644 index 00000000..8313f2ff --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/TropicalFishAttributes.java @@ -0,0 +1,72 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.animal.TropicalFish; +import net.minecraft.world.item.DyeColor; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class TropicalFishAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "pattern", + Arrays.stream(TropicalFish.Pattern.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.TROPICAL_FISH), + TropicalFishAttributes::setPattern + )); + + attributes.add(new NpcAttribute( + "base_color", + Arrays.stream(DyeColor.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.TROPICAL_FISH), + TropicalFishAttributes::setBaseColor + )); + + attributes.add(new NpcAttribute( + "pattern_color", + Arrays.stream(DyeColor.values()) + .map(Enum::name) + .toList(), + List.of(EntityType.TROPICAL_FISH), + TropicalFishAttributes::setPatternColor + )); + + return attributes; + } + + private static void setPattern(Npc npc, String value) { + TropicalFish tropicalFish = ReflectionHelper.getEntity(npc); + + TropicalFish.Pattern pattern = TropicalFish.Pattern.valueOf(value.toUpperCase()); + tropicalFish.setPackedVariant(pattern.getPackedId()); + } + + private static void setBaseColor(Npc npc, String value) { + TropicalFish tropicalFish = ReflectionHelper.getEntity(npc); + + DyeColor color = DyeColor.byName(value.toLowerCase(), DyeColor.WHITE); + TropicalFish.Variant variant = new TropicalFish.Variant(tropicalFish.getPattern(), color, tropicalFish.getPatternColor()); + tropicalFish.setPackedVariant(variant.getPackedId()); + } + + private static void setPatternColor(Npc npc, String value) { + TropicalFish tropicalFish = ReflectionHelper.getEntity(npc); + + DyeColor color = DyeColor.byName(value.toLowerCase(), DyeColor.WHITE); + TropicalFish.Variant variant = new TropicalFish.Variant(tropicalFish.getPattern(), tropicalFish.getBaseColor(), color); + tropicalFish.setPackedVariant(variant.getPackedId()); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/VexAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/VexAttributes.java new file mode 100644 index 00000000..eec9ac98 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/VexAttributes.java @@ -0,0 +1,36 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.world.entity.monster.Vex; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class VexAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "charging", + List.of("true", "false"), + List.of(EntityType.VEX), + VexAttributes::setCharging + )); + + return attributes; + } + + private static void setCharging(Npc npc, String value) { + Vex vex = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "true" -> vex.setIsCharging(true); + case "false" -> vex.setIsCharging(false); + } + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/VillagerAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/VillagerAttributes.java new file mode 100644 index 00000000..d587ca34 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/VillagerAttributes.java @@ -0,0 +1,55 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.core.Holder; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.entity.npc.Villager; +import net.minecraft.world.entity.npc.VillagerProfession; +import net.minecraft.world.entity.npc.VillagerType; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class VillagerAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "profession", + BuiltInRegistries.VILLAGER_PROFESSION.keySet().stream().map(ResourceLocation::getPath).toList(), + List.of(EntityType.VILLAGER), + VillagerAttributes::setProfession + )); + + attributes.add(new NpcAttribute( + "type", + BuiltInRegistries.VILLAGER_TYPE.keySet().stream().map(ResourceLocation::getPath).toList(), + List.of(EntityType.VILLAGER), + VillagerAttributes::setType + )); + + return attributes; + } + + private static void setProfession(Npc npc, String value) { + Villager villager = ReflectionHelper.getEntity(npc); + + Holder profession = BuiltInRegistries.VILLAGER_PROFESSION.get(ResourceLocation.tryParse(value)).orElseThrow(); + + villager.setVillagerData(villager.getVillagerData().withProfession(profession)); + } + + private static void setType(Npc npc, String value) { + Villager villager = ReflectionHelper.getEntity(npc); + + Holder type = BuiltInRegistries.VILLAGER_TYPE.get(ResourceLocation.tryParse(value)).orElseThrow(); + + villager.setVillagerData(villager.getVillagerData().withType(type)); + } + +} diff --git a/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/WolfAttributes.java b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/WolfAttributes.java new file mode 100644 index 00000000..374a6852 --- /dev/null +++ b/plugins/fancynpcs/implementation_1_21_9/src/main/java/de/oliver/fancynpcs/v1_21_9/attributes/WolfAttributes.java @@ -0,0 +1,127 @@ +package de.oliver.fancynpcs.v1_21_9.attributes; + +import de.oliver.fancynpcs.api.Npc; +import de.oliver.fancynpcs.api.NpcAttribute; +import de.oliver.fancynpcs.v1_21_9.ReflectionHelper; +import net.minecraft.core.Holder; +import net.minecraft.core.HolderLookup; +import net.minecraft.core.Registry; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.MinecraftServer; +import net.minecraft.world.entity.animal.wolf.Wolf; +import net.minecraft.world.entity.animal.wolf.WolfVariant; +import net.minecraft.world.item.DyeColor; +import org.bukkit.entity.EntityType; + +import java.util.ArrayList; +import java.util.List; + +public class WolfAttributes { + + public static List getAllAttributes() { + List attributes = new ArrayList<>(); + + attributes.add(new NpcAttribute( + "pose", + List.of("standing", "sitting"), + List.of(EntityType.WOLF), + WolfAttributes::setPose + )); + + attributes.add(new NpcAttribute( + "angry", + List.of("true", "false"), + List.of(EntityType.WOLF), + WolfAttributes::setAngry + )); + + attributes.add(new NpcAttribute( + "variant", + getWolfVariantRegistry() + .listElementIds() + .map(id -> id.location().getPath()) + .toList(), + List.of(EntityType.WOLF), + WolfAttributes::setVariant + )); + + attributes.add(new NpcAttribute( + "collar_color", + List.of("RED", "BLUE", "YELLOW", "GREEN", "PURPLE", "ORANGE", "LIME", "MAGENTA", "BROWN", "WHITE", "GRAY", "LIGHT_GRAY", "LIGHT_BLUE", "BLACK", "CYAN", "PINK", "NONE"), + List.of(EntityType.WOLF), + WolfAttributes::setCollarColor + )); + + return attributes; + } + + private static void setPose(Npc npc, String value) { + Wolf wolf = ReflectionHelper.getEntity(npc); + + switch (value.toLowerCase()) { + case "standing" -> wolf.setInSittingPose(false, false); + case "sitting" -> wolf.setInSittingPose(true, false); + } + } + + private static void setAngry(Npc npc, String value) { + Wolf wolf = ReflectionHelper.getEntity(npc); + + boolean angry = Boolean.parseBoolean(value.toLowerCase()); + + wolf.setRemainingPersistentAngerTime(angry ? 100 : 0); + } + + private static void setVariant(Npc npc, String value) { + Wolf wolf = ReflectionHelper.getEntity(npc); + + Registry registry = wolf.level().registryAccess().lookupOrThrow(Registries.WOLF_VARIANT); + + ResourceLocation variantLocation = ResourceLocation.tryParse("minecraft:" + value.toLowerCase()); + if (variantLocation == null) { + System.out.println("Invalid variant name: " + value); + return; + } + + WolfVariant variant = registry.getOptional(variantLocation).orElse(null); + if (variant == null) { + System.out.println("Wolf variant not found: " + variantLocation); + return; + } + + // Get the ResourceKey from the registry + registry.getResourceKey(variant).ifPresentOrElse( + key -> { + // Get the holder from the registry — this is properly bound + Holder holder = registry.wrapAsHolder(variant); + wolf.setVariant(holder); + }, + () -> System.out.println("Wolf variant not registered: " + variantLocation) + ); + } + + private static void setCollarColor(Npc npc, String value) { + Wolf wolf = ReflectionHelper.getEntity(npc); + + if (value.equalsIgnoreCase("none") || value.isEmpty()) { + // Reset to no collar + wolf.setTame(false, false); + return; + } + + try { + DyeColor color = DyeColor.valueOf(value.toUpperCase()); + if (!wolf.isTame()) { + wolf.setTame(true, false); + } + wolf.setCollarColor(color); + } catch (IllegalArgumentException e) { + System.out.println("Invalid wolf collar color: " + value); + } + } + + private static HolderLookup.RegistryLookup getWolfVariantRegistry() { + return MinecraftServer.getServer().registryAccess().lookupOrThrow(Registries.WOLF_VARIANT); + } +} diff --git a/plugins/fancynpcs/release_deployment_config.json b/plugins/fancynpcs/release_deployment_config.json index 6bf5f4a7..faf1a733 100644 --- a/plugins/fancynpcs/release_deployment_config.json +++ b/plugins/fancynpcs/release_deployment_config.json @@ -21,7 +21,8 @@ "1.21.5", "1.21.6", "1.21.7", - "1.21.8" + "1.21.8", + "1.21.9" ], "channel": "RELEASE", "loaders": [ diff --git a/plugins/fancynpcs/snapshot_deployment_config.json b/plugins/fancynpcs/snapshot_deployment_config.json index 593be6bc..c388384b 100644 --- a/plugins/fancynpcs/snapshot_deployment_config.json +++ b/plugins/fancynpcs/snapshot_deployment_config.json @@ -21,7 +21,8 @@ "1.21.5", "1.21.6", "1.21.7", - "1.21.8" + "1.21.8", + "1.21.9" ], "channel": "ALPHA", "loaders": [ diff --git a/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/AttributeManagerImpl.java b/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/AttributeManagerImpl.java index 056e9e54..0e25724b 100644 --- a/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/AttributeManagerImpl.java +++ b/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/AttributeManagerImpl.java @@ -12,6 +12,7 @@ import de.oliver.fancynpcs.v1_21_3.attributes.Attributes_1_21_3; import de.oliver.fancynpcs.v1_21_4.attributes.Attributes_1_21_4; import de.oliver.fancynpcs.v1_21_5.attributes.Attributes_1_21_5; import de.oliver.fancynpcs.v1_21_6.attributes.Attributes_1_21_6; +import de.oliver.fancynpcs.v1_21_9.attributes.Attributes_1_21_9; import org.bukkit.Bukkit; import org.bukkit.entity.EntityType; @@ -30,6 +31,7 @@ public class AttributeManagerImpl implements AttributeManager { private void init() { String mcVersion = Bukkit.getMinecraftVersion(); switch (mcVersion) { + case "1.21.9" -> attributes = Attributes_1_21_9.getAllAttributes(); case "1.21.6", "1.21.7", "1.21.8" -> attributes = Attributes_1_21_6.getAllAttributes(); case "1.21.5" -> attributes = Attributes_1_21_5.getAllAttributes(); case "1.21.4" -> attributes = Attributes_1_21_4.getAllAttributes(); diff --git a/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/FancyNpcs.java b/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/FancyNpcs.java index 37285d39..af0bfcbc 100644 --- a/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/FancyNpcs.java +++ b/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/FancyNpcs.java @@ -57,6 +57,7 @@ import de.oliver.fancynpcs.v1_21_3.Npc_1_21_3; import de.oliver.fancynpcs.v1_21_4.Npc_1_21_4; import de.oliver.fancynpcs.v1_21_5.Npc_1_21_5; import de.oliver.fancynpcs.v1_21_6.Npc_1_21_6; +import de.oliver.fancynpcs.v1_21_9.Npc_1_21_9; import org.apache.maven.artifact.versioning.ComparableVersion; import org.bukkit.Bukkit; import org.bukkit.entity.EntityType; @@ -160,6 +161,7 @@ public class FancyNpcs extends JavaPlugin implements FancyNpcsPlugin { String mcVersion = Bukkit.getMinecraftVersion(); switch (mcVersion) { + case "1.21.9" -> npcAdapter = Npc_1_21_9::new; case "1.21.6", "1.21.7", "1.21.8" -> npcAdapter = Npc_1_21_6::new; case "1.21.5" -> npcAdapter = Npc_1_21_5::new; case "1.21.4" -> npcAdapter = Npc_1_21_4::new; @@ -272,7 +274,7 @@ public class FancyNpcs extends JavaPlugin implements FancyNpcsPlugin { pluginManager.registerEvents(new PlayerTeleportListener(), instance); pluginManager.registerEvents(new PlayerChangedWorldListener(), instance); pluginManager.registerEvents(skinManager, instance); - if (Bukkit.getMinecraftVersion().equals("1.21.4") || Bukkit.getMinecraftVersion().equals("1.21.5") || Bukkit.getMinecraftVersion().equals("1.21.6") || Bukkit.getMinecraftVersion().equals("1.21.7") || Bukkit.getMinecraftVersion().equals("1.21.8")) { + if (Bukkit.getMinecraftVersion().equals("1.21.4") || Bukkit.getMinecraftVersion().equals("1.21.5") || Bukkit.getMinecraftVersion().equals("1.21.6") || Bukkit.getMinecraftVersion().equals("1.21.7") || Bukkit.getMinecraftVersion().equals("1.21.8") || Bukkit.getMinecraftVersion().equals("1.21.9")) { getServer().getPluginManager().registerEvents(new PlayerLoadedListener(), this); } diff --git a/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/commands/CloudCommandManager.java b/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/commands/CloudCommandManager.java index aa47126c..bcad52af 100644 --- a/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/commands/CloudCommandManager.java +++ b/plugins/fancynpcs/src/main/java/de/oliver/fancynpcs/commands/CloudCommandManager.java @@ -198,7 +198,7 @@ public final class CloudCommandManager { } String mcVersion = Bukkit.getMinecraftVersion(); - if (mcVersion.equals("1.20.5") || mcVersion.equals("1.20.6") || mcVersion.equals("1.21") || mcVersion.equals("1.21.1") || mcVersion.equals("1.21.2") || mcVersion.equals("1.21.3") || mcVersion.equals("1.21.4") || mcVersion.equals("1.21.5") || mcVersion.equals("1.21.6") || mcVersion.equals("1.21.7") || Bukkit.getMinecraftVersion().equals("1.21.8")) { + if (mcVersion.equals("1.20.5") || mcVersion.equals("1.20.6") || mcVersion.equals("1.21") || mcVersion.equals("1.21.1") || mcVersion.equals("1.21.2") || mcVersion.equals("1.21.3") || mcVersion.equals("1.21.4") || mcVersion.equals("1.21.5") || mcVersion.equals("1.21.6") || mcVersion.equals("1.21.7") || Bukkit.getMinecraftVersion().equals("1.21.8") || Bukkit.getMinecraftVersion().equals("1.21.9")) { annotationParser.parse(ScaleCMD.INSTANCE); } diff --git a/settings.gradle.kts b/settings.gradle.kts index 0e51e680..e8eb2fad 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -2,6 +2,7 @@ rootProject.name = "minecraft-plugins" include(":plugins:fancynpcs:") include(":plugins:fancynpcs:fn-api") +include(":plugins:fancynpcs:implementation_1_21_9") include(":plugins:fancynpcs:implementation_1_21_6") include(":plugins:fancynpcs:implementation_1_21_5") include(":plugins:fancynpcs:implementation_1_21_4") @@ -44,6 +45,7 @@ include(":libraries:packets:implementations:1_21_3") include(":libraries:packets:implementations:1_21_4") include(":libraries:packets:implementations:1_21_5") include(":libraries:packets:implementations:1_21_6") +include(":libraries:packets:implementations:1_21_9") include(":tools:deployment")