From b8b41aa5846dae5a9bbf4fee82020f1d9e2b2a48 Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Mon, 12 Aug 2024 17:08:54 -0400 Subject: Initial commit --- .../fyresmodjam/handlers/NewPacketHandler.java | 1067 ++++++++++++++++++++ 1 file changed, 1067 insertions(+) create mode 100644 src/main/java/fyresmodjam/handlers/NewPacketHandler.java (limited to 'src/main/java/fyresmodjam/handlers/NewPacketHandler.java') diff --git a/src/main/java/fyresmodjam/handlers/NewPacketHandler.java b/src/main/java/fyresmodjam/handlers/NewPacketHandler.java new file mode 100644 index 0000000..4fac1d5 --- /dev/null +++ b/src/main/java/fyresmodjam/handlers/NewPacketHandler.java @@ -0,0 +1,1067 @@ +package fyresmodjam.handlers; + +import java.nio.charset.Charset; +import java.util.ArrayList; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.misc.EntityStatHelper; +import fyresmodjam.misc.ItemStatHelper; +import io.netty.buffer.ByteBuf; +import io.netty.channel.ChannelHandlerContext; +import net.minecraft.client.Minecraft; +import net.minecraft.entity.Entity; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.network.INetHandler; +import net.minecraft.network.NetHandlerPlayServer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.DamageSource; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.text.TextComponentString; +import net.minecraft.world.WorldServer; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.common.network.FMLIndexedMessageToMessageCodec; +import net.minecraftforge.fml.common.network.FMLOutboundHandler; +import net.minecraftforge.fml.common.network.NetworkRegistry; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +@SuppressWarnings("rawtypes") +public class NewPacketHandler { + + public static BasicPacket[] packetTypes = new BasicPacket[256]; + + public static int[] potionValues = new int[12]; + public static int[] potionDurations = new int[12]; + + public static int[][] mushroomColors = new int[13][2]; + + public static String currentDisadvantage = null; + + public static String currentTask = null; + public static int currentTaskID = -1; + public static int currentTaskAmount = 0; + public static int progress = 0; + public static int tasksCompleted = 0; + public static int rewardLevels = 0; + + public static boolean enderDragonKilled = false; + public static boolean trapsDisabled = false; + + public static interface IPacket { + public void readBytes(ByteBuf bytes); + + public void writeBytes(ByteBuf bytes); + + public void executeClient(EntityPlayer player); + + public void executeServer(EntityPlayer player); + + public void executeBoth(EntityPlayer player); + } + + public static class ChannelHandler + extends FMLIndexedMessageToMessageCodec { + + public ChannelHandler() { + addDiscriminator(0, BasicPacket.class); + + } + + @Override + public void encodeInto(ChannelHandlerContext ctx, + IPacket packet, ByteBuf data) + throws Exception { + packet.writeBytes(data); + } + + @Override + public void decodeInto(ChannelHandlerContext ctx, + ByteBuf data, IPacket packet) { + packet.readBytes(data); + + if (packet instanceof BasicPacket) { + packetTypes[((BasicPacket) packet).type].data = ((BasicPacket) packet).data; + } + + EntityPlayer player = null; + + switch (FMLCommonHandler.instance() + .getEffectiveSide()) { + + case CLIENT: + + player = getClientPlayer(); + + if (player != null) { + packet.executeClient( + player); + packet.executeBoth(player); + } + + break; + + case SERVER: + + INetHandler netHandler = ctx + .channel() + .attr(NetworkRegistry.NET_HANDLER) + .get(); + player = ((NetHandlerPlayServer) netHandler).player; + + if (player != null) { + packet.executeServer( + player); + packet.executeBoth(player); + } + + break; + + default: + break; + + } + } + + @SideOnly(Side.CLIENT) + public EntityPlayer getClientPlayer() { + return Minecraft.getMinecraft().player; + } + } + + public static class BasicPacket implements IPacket { + public static Class[] validClassArray = { + Integer.class, Boolean.class, String.class, + Character.class, Byte.class, Float.class, + Double.class, int[].class, int[][].class + }; + public static ArrayList validClasses = new ArrayList(); + static { + for (Class c : validClassArray) { + validClasses.add(c); + } + } + + public Object[] data = null; + public byte type; + + public BasicPacket() { + } + + public BasicPacket(int type) { + if (type == 0 || packetTypes[type] != null) { + throw new RuntimeException("Packet slot " + + type + + " already in use."); + } + packetTypes[type] = this; + this.type = (byte) type; + } + + public BasicPacket(BasicPacket packet, Object... data) { + if (packet.type > 0 + && packet.type < packetTypes.length + && packet == packetTypes[packet.type]) { + type = packet.type; + } else { + throw new RuntimeException( + "Must supply valid packet type."); + } + + Class[] classes = getExpectedClasses(); + + if (classes != null) { + for (Class c : classes) { + if (!validClasses.contains(c)) { + throw new RuntimeException( + "Argument class not valid. (" + + c + + ")"); + } + } + + if (data == null || data.length != classes.length) { + throw new RuntimeException( + "Wrong number of arguments provided."); + } else { + for (int i = 0; i < data.length; i++) { + if (data[i].getClass() != classes[i]) { + throw new RuntimeException( + "Wrong argument class provided. (" + + data[i].getClass() + + ", expected " + + classes[i] + + ")"); + } + } + } + } + + this.data = data; + } + + @Override + public void readBytes(ByteBuf bytes) { + type = bytes.readByte(); + + Class[] classes = getExpectedClasses(); + + if (classes != null) { + data = new Object[classes.length]; + + for (int i = 0; i < classes.length; i++) { + if (classes[i] == Integer.class) { + data[i] = bytes.readInt(); + } + if (classes[i] == int[].class) { + int[] array = new int[bytes + .readInt()]; + for (int i2 = 0; i2 < array.length; i2++) { + array[i2] = bytes + .readInt(); + } + data[i] = array; + } + if (classes[i] == int[][].class) { + int[][] array = new int[bytes + .readInt()][]; + + for (int i2 = 0; i2 < array.length; i2++) { + array[i2] = new int[bytes + .readInt()]; + for (int i3 = 0; i3 < array[i2].length; i3++) { + array[i2][i3] = bytes + .readInt(); + } + } + + data[i] = array; + } else if (classes[i] == Boolean.class) { + data[i] = bytes.readBoolean(); + } else if (classes[i] == String.class) { + int length = bytes + .readInt(); + try { + byte[] stringBytes = new byte[length]; + bytes.readBytes(stringBytes); + data[i] = new String( + stringBytes, + "UTF-8"); + } catch (Exception e) { + e.printStackTrace(); + } + } else if (classes[i] == Byte.class) { + data[i] = bytes.readByte(); + } else if (classes[i] == Float.class) { + data[i] = bytes.readDouble(); + } else if (classes[i] == Double.class) { + data[i] = bytes.readFloat(); + } else if (classes[i] == Character.class) { + data[i] = bytes.readChar(); + } + } + } + } + + @Override + public void writeBytes(ByteBuf bytes) { + bytes.writeByte(type); + + if (data != null) { + for (int i = 0; i < data.length; i++) { + if (data[i] instanceof Integer) { + bytes.writeInt((Integer) data[i]); + } else if (data[i] instanceof int[]) { + bytes.writeInt(((int[]) data[i]).length); + for (int i2 = 0; i2 < ((int[]) data[i]).length; i2++) { + bytes.writeInt(((int[]) data[i])[i2]); + } + } else if (data[i] instanceof int[][]) { + int[][] values = (int[][]) data[i]; + + bytes.writeInt(values.length); + + for (int i2 = 0; i2 < values.length; i2++) { + bytes.writeInt(values[i2].length); + for (int i3 = 0; i3 < values[i2].length; i3++) { + bytes.writeInt(values[i2][i3]); + } + } + } else if (data[i] instanceof Boolean) { + bytes.writeBoolean( + (Boolean) data[i]); + } else if (data[i] instanceof String) { + byte[] stringBytes = ((String) data[i]) + .getBytes(Charset + .forName("UTF-8")); + bytes.writeInt(stringBytes.length); + bytes.writeBytes( + stringBytes); + } else if (data[i] instanceof Byte) { + bytes.writeByte((Byte) data[i]); + } else if (data[i] instanceof Float) { + bytes.writeDouble( + (Double) data[i]); + } else if (data[i] instanceof Double) { + bytes.writeFloat( + (Float) data[i]); + } else if (data[i] instanceof Character) { + bytes.writeChar((Character) data[i]); + } + } + } + } + + @Override + public void executeClient(EntityPlayer player) { + if (packetTypes[type] != this) { + packetTypes[type].executeClient(player); + } + } + + @Override + public void executeServer(EntityPlayer player) { + if (packetTypes[type] != this) { + packetTypes[type].executeServer(player); + } + } + + @Override + public void executeBoth(EntityPlayer player) { + if (packetTypes[type] != this) { + packetTypes[type].executeBoth(player); + } + } + + public Class[] getExpectedClasses() { + if (packetTypes[type] != this) { + return packetTypes[type] + .getExpectedClasses(); + } else { + return null; + } + } + + public void sendToPlayer(EntityPlayer player, + Object... data) { + sendPacketToPlayer(new BasicPacket(this, data), + player); + } + + public void sendToAllPlayers(Object... data) { + sendPacketToAllPlayers( + new BasicPacket(this, data)); + } + + public void sendToServer(Object... data) { + sendPacketToServer(new BasicPacket(this, data)); + } + } + + public static void sendPacketToPlayer(IPacket packet, + EntityPlayer player) { + ModjamMod.channels.get(Side.SERVER) + .attr(FMLOutboundHandler.FML_MESSAGETARGET) + .set(FMLOutboundHandler.OutboundTarget.PLAYER); + ModjamMod.channels.get(Side.SERVER).attr( + FMLOutboundHandler.FML_MESSAGETARGETARGS) + .set(player); + ModjamMod.channels.get(Side.SERVER).writeOutbound(packet); + } + + public static void sendPacketToAllPlayers(IPacket packet) { + ModjamMod.channels.get(Side.SERVER) + .attr(FMLOutboundHandler.FML_MESSAGETARGET) + .set(FMLOutboundHandler.OutboundTarget.ALL); + ModjamMod.channels.get(Side.SERVER).writeOutbound(packet); + } + + public static void sendPacketToServer(IPacket packet) { + ModjamMod.channels.get(Side.CLIENT) + .attr(FMLOutboundHandler.FML_MESSAGETARGET) + .set(FMLOutboundHandler.OutboundTarget.TOSERVER); + ModjamMod.channels.get(Side.CLIENT).writeOutbound(packet); + } + + public static final BasicPacket + + UPDATE_BLESSING = new BasicPacket(1) { + @Override + public void executeBoth(EntityPlayer player) { + player.getEntityData().setString("Blessing", + (String) data[0]); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + String.class + }; + } + }, + + PLAY_SOUND = new BasicPacket(2) { + @Override + public void executeServer( + EntityPlayer player) { + String sound = (String) data[0]; + int x = (Integer) data[1], + y = (Integer) data[2], + z = (Integer) data[3]; + + // TODO fix this + // player.world.playSound(player, + // new BlockPos(x, y, z), + // "fyresmodjam:" + sound, + // 1.0F, 1.0F, false); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + String.class, + Integer.class, + Integer.class, + Integer.class + }; + } + }, + + UPDATE_POTION_KNOWLEDGE = new BasicPacket(3) { + @Override + public void executeBoth( + EntityPlayer player) { + player.getEntityData().setIntArray( + "PotionKnowledge", + (int[]) data[0]); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + int[].class + }; + } + }, + + SEND_MESSAGE = new BasicPacket(4) { + @Override + public void executeClient( + EntityPlayer player) { + String style = ""; + + for (String s : ((String) data[0]) + .split("@")) { + String[] words = s.split( + " "); + s = ""; + + for (String word : words) { + s += style + word + + " "; + + while (word.contains( + "\u00A7")) { + int firstOccurance = word + .indexOf("\u00A7"); + String string = word + .substring(firstOccurance, + firstOccurance + 2); + + if (style.contains( + string)) { + style = style.replace( + string, + ""); + } + style += string; + if (string.equals( + "\u00A7r")) { + style = ""; + } + + word = word.replaceFirst( + string, + ""); + } + } + + player.sendMessage( + new TextComponentString( + s)); + } + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + String.class + }; + } + }, + + UPDATE_WORLD_DATA = new BasicPacket(5) { + @Override + public void executeClient( + EntityPlayer player) { + potionValues = (int[]) data[0]; + potionDurations = (int[]) data[1]; + currentDisadvantage = (String) data[2]; + currentTask = (String) data[3]; + currentTaskID = (Integer) data[4]; + currentTaskAmount = (Integer) data[5]; + progress = (Integer) data[6]; + tasksCompleted = (Integer) data[7]; + enderDragonKilled = (Boolean) data[8]; + trapsDisabled = !((Boolean) data[9]); + rewardLevels = (Integer) data[10]; + mushroomColors = (int[][]) data[11]; + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + int[].class, + int[].class, + String.class, + String.class, + Integer.class, + Integer.class, + Integer.class, + Integer.class, + Boolean.class, + Boolean.class, + Integer.class, + int[][].class + }; + } + }, + + UPDATE_PLAYER_ITEMS = new BasicPacket(6) { + @Override + public void executeServer( + EntityPlayer player) { + for (Object stack : player.inventory.mainInventory) { + if (stack == null + || !(stack instanceof ItemStack)) { + continue; + } + ItemStatHelper.processItemStack( + (ItemStack) stack, + ModjamMod.r); + } + } + + @Override + public Class[] getExpectedClasses() { + return null; + } + }, + + DISARM_TRAP = new BasicPacket(7) { + @Override + public void executeServer( + EntityPlayer player) { + int blockX = (Integer) data[0], + blockY = (Integer) data[1], + blockZ = (Integer) data[2]; + boolean mechanic = (Boolean) data[3]; + + boolean scout = BlessingUtils + .hasBlessing(player, + "MarkScouting"); + + BlockPos blockPos = new BlockPos( + blockX, blockY, + blockZ); + TileEntity te = player.world + .getTileEntity(blockPos); + + boolean yours = false; + + if (yours || (mechanic + ? ModjamMod.r.nextInt( + 4) != 0 + : ModjamMod.r.nextInt( + 4) == 0)) { + boolean salvage = yours + || (mechanic ? ModjamMod.r + .nextBoolean() + : (ModjamMod.r.nextInt( + 4) == 0)); + + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7e\u00A7o" + (!salvage + ? "You disarmed the trap." + : "You disarm and salvage the trap.")); + + if (salvage) { + int meta = player.world + .getBlockState(blockPos) + .getBlock() + .getMetaFromState( + player.world.getBlockState( + player.getPosition())); + + ItemStack spawned = new ItemStack( + ModjamMod.itemTrap, + 1, + 0); + + player.world.spawnEntity( + new EntityItem(player.world, + blockX + 0.5F, + blockY, + blockZ + 0.5F, + spawned)); + } + + player.world.setBlockToAir( + blockPos); + } else { + int trapType = player.world + .getBlockState(blockPos) + .getBlock() + .getMetaFromState( + player.world.getBlockState( + player.getPosition())); + + // TODO use a custom damage + // type for the traps + if (trapType == 0) { + player.attackEntityFrom( + DamageSource.CACTUS, + 4.0F + (scout ? 1 + : 0)); + if (ModjamMod.r.nextInt( + 16 - (scout ? 4 + : 0)) == 0) { + // TODO + // figure + // out how + // potion + // effects + // work + + // ((EntityLivingBase) + // player) + // .addPotionEffect( + // new + // PotionEffect( + // Potion.POISON.id, + // 100 + + // (scout ? + // 25 + // : 0), + // 1)); + } + } else if (trapType == 1) { + if (!player.isBurning()) { + player.setFire(5 + (scout + ? 1 + : 0)); + } + } else if (trapType == 2) { + // TODO figure out + // how potion + // effects work + + // player.addPotionEffect( + // new + // PotionEffect( + // Potion.blindness.id, + // 100 + (scout ? + // 25 + // : 0), + // 1)); + // player.addPotionEffect( + // new + // PotionEffect( + // Potion.moveSlowdown.id, + // 100 + (scout ? + // 25 + // : 0), + // 1)); + } + + player.world.setBlockToAir( + blockPos); + + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7c\u00A7oYou failed to disarm the trap."); + + if (CommonTickHandler.worldData + .getDisadvantage() + .equals("Explosive Traps")) { + player.world.setBlockToAir( + blockPos); + player.world.createExplosion( + null, + blockX + 0.5F, + blockY + 0.5F, + blockZ + 0.5F, + 1.33F, + true); + } + + // TODO swap to advancement + // player.triggerAchievement( + // ModjamMod.whoops); + } + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + Integer.class, + Integer.class, + Integer.class, + Boolean.class + }; + } + }, + + EXAMINE_MOB = new BasicPacket(8) { + @Override + public void executeServer( + EntityPlayer player) { + int dimension = (Integer) data[0]; + int entityID = (Integer) data[1]; + + WorldServer server = null; + + for (WorldServer s : player.world + .getMinecraftServer().worlds) { + if (s.provider.getDimension() == dimension) { + server = s; + break; + } + } + + if (server != null) { + Entity entity = server + .getEntityByID(entityID); + + if (entity != null) { + String blessing2 = entity + .getEntityData() + .hasKey("Blessing") + ? entity.getEntityData() + .getString("Blessing") + : null; + + if (blessing2 != null) { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7eYou notice " + + entity.getName() + + "\u00A7e is using " + + BlessingUtils.getBlessingInstance( + blessing2) + .customName() + + "."); + } else { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7eThere doesn't seem to be anything special about " + + (entity instanceof EntityPlayer + ? "" + : "this ") + + entity.getName() + + "\u00A7e."); + } + } + } + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + Integer.class, + Integer.class + }; + } + }, + + LEVEL_UP = new BasicPacket(9) { + @Override + public void executeBoth( + EntityPlayer player) { + player.addExperienceLevel( + (Integer) data[0]); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + Integer.class + }; + } + }, + + ACTIVATE_BLESSING = new BasicPacket(10) { + @Override + public void executeServer( + EntityPlayer player) { + + int x = (Integer) data[0], + y = (Integer) data[1], + z = (Integer) data[2]; + + boolean blessingActive = EntityStatHelper + .hasStat(player, "BlessingActive") + ? Boolean.parseBoolean( + EntityStatHelper.getStat( + player, + "BlessingActive")) + : false; + + if (!EntityStatHelper.hasStat( + player, + "BlessingCooldown")) { + EntityStatHelper.giveStat( + player, + "BlessingCooldown", + 0); + } + + long time = (CommonTickHandler.worldData != null + && CommonTickHandler.worldData + .getDisadvantage() + .equals("Neverending Rain")) + ? player.world.getTotalWorldTime() + : player.world.getWorldTime(); + + if (EntityStatHelper.getStat( + player, + "BlessingCooldown") + .equals("0")) { + if (!blessingActive) { + if (BlessingUtils + .hasBlessing(player)) { + if (BlessingUtils + .hasBlessing(player, + "BlessingBerserker")) { + if (hasBlessingCounters( + player)) { + blessingActive = true; + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7cYou enter berserk mode."); + } else { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7cYou have no berserk counters."); + } + } else if (BlessingUtils + .hasBlessing(player, + "BlessingMechanic")) { + BlockPos blockPos = new BlockPos( + x, + y, + z); + + TileEntity te = player.world + .getTileEntity(blockPos); + + /* + * if + * (te + * != + * null + * && + * te + * instanceof + * TileEntityTrap) + * { + * SEND_MESSAGE + * . + * sendToPlayer( + * player, + * "\u00A7e\u00A7oYou disarm and salvage the trap." + * ); + * + * int + * meta + * = + * player + * . + * world + * .getBlockState + * ( + * blockPos) + * .getBlock + * ( + * ) + * .getMetaFromState( + * player + * . + * world + * . + * getBlockState( + * player + * . + * getPosition + * ( + * ) + * ) + * ) + * ; + * + * player + * . + * world + * . + * spawnEntity( + * new + * EntityItem + * ( + * player + * . + * world, + * x + * + + * 0 + * . + * 5F, + * y, + * z + * + + * 0 + * . + * 5F, + * new + * ItemStack + * ( + * ModjamMod + * . + * itemTrap, + * 1, + * meta + * % + * BlockTrap + * . + * trapTypes + * ) + * ) + * ) + * ; + * player + * . + * world + * . + * setBlockToAir( + * blockPos + * ) + * ; + * + * EntityStatHelper + * . + * giveStat( + * player, + * "BlessingCooldown", + * 24000 + * - + * (time + * % + * 24000 + * ) + * ) + * ; + * } + * else + * { + * SEND_MESSAGE + * . + * sendToPlayer( + * player, + * "\u00A7e\u00A7oNo selected trap." + * ); + * } + */ + } + } + } else { + blessingActive = false; + + if (BlessingUtils + .hasBlessing(player)) { + if (BlessingUtils + .hasBlessing(player, + "BlessingBerserker")) { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7cYou calm down."); + + EntityStatHelper.giveStat( + player, + "BlessingCooldown", + 1200); + } + } + + EntityStatHelper.giveStat( + player, + "BlessingTimer", + 0); + } + } else { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7cBlessing is on cooldown. (" + + (Integer.parseInt( + EntityStatHelper.getStat( + player, + "BlessingCooldown"))) + / 20 + + "s)"); + } + + EntityStatHelper.giveStat(player, + "BlessingActive", + blessingActive); + } + + private boolean hasBlessingCounters( + EntityPlayer player) { + return EntityStatHelper.hasStat( + player, + "BlessingCounter") + && Integer.parseInt( + EntityStatHelper.getStat( + player, + "BlessingCounter")) > 0; + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + Integer.class, + Integer.class, + Integer.class + }; + } + }, + + UPDATE_STAT = new BasicPacket(11) { + @Override + public void executeBoth( + EntityPlayer player) { + EntityStatHelper.giveStat(player, + (String) data[0], + data[1]); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + String.class, + String.class + }; + } + }; +} -- cgit v1.2.3