diff options
Diffstat (limited to 'YWD/src/main/java/fyresmodjam/handlers')
6 files changed, 1636 insertions, 0 deletions
diff --git a/YWD/src/main/java/fyresmodjam/handlers/ClientTickHandler.java b/YWD/src/main/java/fyresmodjam/handlers/ClientTickHandler.java new file mode 100755 index 0000000..a8bd717 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/handlers/ClientTickHandler.java @@ -0,0 +1,82 @@ +package fyresmodjam.handlers;
+
+import java.io.File;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent.ClientTickEvent;
+import fyresmodjam.ModjamMod;
+import fyresmodjam.misc.ConfigData;
+import fyresmodjam.misc.ItemStatHelper;
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.config.Configuration;
+
+public class ClientTickHandler {
+
+ public static long time = System.currentTimeMillis();
+
+ @SubscribeEvent
+ public void clientTick(ClientTickEvent event) {
+ EntityPlayer player = Minecraft.getMinecraft().thePlayer;
+
+ if (System.currentTimeMillis() - time > 200
+ && player != null) {
+ if (player.openContainer != null) {
+ boolean sendPacket = false;
+
+ for (Object object : player.inventory.mainInventory) {
+ if (object == null
+ || !(object instanceof ItemStack)) {
+ continue;
+ }
+
+ ItemStack stack = (ItemStack) object;
+
+ if (stack.getItem() != null
+ && !ItemStatHelper.skip
+ .contains(stack.getItem()
+ .getClass())
+ && (stack.getTagCompound() == null
+ || !stack.getTagCompound()
+ .hasKey("processed")
+ || stack.getTagCompound()
+ .getString("processed")
+ .equals("false"))) {
+ sendPacket = true;
+ }
+ }
+
+ if (sendPacket) {
+ NewPacketHandler.UPDATE_PLAYER_ITEMS
+ .sendToServer((Object) null);
+ time = System.currentTimeMillis();
+ }
+ }
+
+ player.triggerAchievement(ModjamMod.startTheGame);
+ }
+
+ if (FyresKeyHandler.examine
+ .getKeyCode() != ConfigData.examineKey
+ || FyresKeyHandler.activateBlessing
+ .getKeyCode() != ConfigData.blessingKey) {
+ ConfigData.examineKey = FyresKeyHandler.examine
+ .getKeyCode();
+ ConfigData.blessingKey = FyresKeyHandler.activateBlessing
+ .getKeyCode();
+
+ Configuration config = new Configuration(
+ new File(ModjamMod.configPath));
+ config.load();
+ config.get("Keybindings", "examine_key",
+ ConfigData.examineKey)
+ .set(ConfigData.examineKey);
+ config.get("Keybindings", "blessing_key",
+ ConfigData.blessingKey)
+ .set(ConfigData.blessingKey);
+ config.save();
+ }
+ }
+
+}
diff --git a/YWD/src/main/java/fyresmodjam/handlers/CommonTickHandler.java b/YWD/src/main/java/fyresmodjam/handlers/CommonTickHandler.java new file mode 100755 index 0000000..1a50f3f --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/handlers/CommonTickHandler.java @@ -0,0 +1,369 @@ +package fyresmodjam.handlers;
+
+import java.util.ArrayList;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.TickEvent;
+import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent;
+import cpw.mods.fml.common.gameevent.TickEvent.WorldTickEvent;
+import fyresmodjam.blessings.BlessingUtils;
+import fyresmodjam.misc.ConfigData;
+import fyresmodjam.misc.EntityStatHelper;
+import fyresmodjam.worldgen.FyresWorldData;
+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.server.MinecraftServer;
+import net.minecraft.world.WorldServer;
+
+public class CommonTickHandler {
+ public static FyresWorldData worldData = null;
+
+ public static ArrayList<Entity> addLater = new ArrayList<Entity>();
+
+ @SubscribeEvent
+ public void worldTick(WorldTickEvent event) {
+ if (event.phase == TickEvent.Phase.START) {
+ if (event.world != null
+ && event.world.provider.dimensionId == 0) {
+ worldData = FyresWorldData
+ .forWorld(event.world);
+ worldData.markDirty();
+ }
+ }
+ }
+
+ @SubscribeEvent
+ public void serverTick(ServerTickEvent event) {
+ MinecraftServer server = FMLCommonHandler.instance()
+ .getMinecraftServerInstance();
+
+ for (int i = 0; i < server.worldServers.length; i++) {
+ WorldServer s = FMLCommonHandler.instance()
+ .getMinecraftServerInstance().worldServers[i];
+
+ if (s == null) {
+ continue;
+ }
+
+ for (Object o : s.playerEntities) {
+ if (o == null || !(o instanceof EntityPlayer)) {
+ continue;
+ }
+
+ EntityPlayer player = (EntityPlayer) o;
+
+ String blessing;
+
+ if (player.getEntityData()
+ .hasKey("Blessing")) {
+ blessing = player.getEntityData()
+ .getString("Blessing");
+ } else {
+ blessing = null;
+ }
+
+ int coolDown = 0, counter = 0, timer = 0;
+
+ boolean blessingActive;
+
+ if (EntityStatHelper.hasStat(player,
+ "BlessingActive")) {
+ blessingActive = Boolean
+ .parseBoolean(EntityStatHelper
+ .getStat(player, "BlessingActive"));
+ } else {
+ blessingActive = false;
+ }
+
+ if (EntityStatHelper.hasStat(player,
+ "BlessingCooldown")) {
+ coolDown = Integer.parseInt(
+ EntityStatHelper.getStat(
+ player,
+ "BlessingCooldown"));
+ if (coolDown > 0) {
+ coolDown--;
+ }
+ }
+
+ if (EntityStatHelper.hasStat(player,
+ "BlessingTimer")) {
+ timer = Integer.parseInt(
+ EntityStatHelper.getStat(
+ player,
+ "BlessingTimer"));
+ if (blessingActive) {
+ timer++;
+ } else {
+ timer = 0;
+ }
+ }
+
+ if (EntityStatHelper.hasStat(player,
+ "BlessingCounter")) {
+ counter = Integer.parseInt(
+ EntityStatHelper.getStat(
+ player,
+ "BlessingCounter"));
+
+ if (BlessingUtils.hasBlessing(player)) {
+ if (blessingActive
+ && BlessingUtils.hasBlessing(player, "BlessingBerserker")
+ && timer % 40 == 0) {
+ counter = Math.max(
+ 0,
+ counter - 1);
+
+ if (counter == 0) {
+ NewPacketHandler.SEND_MESSAGE
+ .sendToPlayer(player,
+ "\u00A7cYou calm down.");
+ coolDown = 1200;
+ timer = 0;
+ blessingActive = false;
+ }
+ }
+ }
+ }
+
+ if (blessing != null) {
+ BlessingUtils.getBlessingInstance(blessing).commonTick(event, player);
+ }
+
+ if (EntityStatHelper.hasStat(player,
+ "BlessingCounter")
+ && Integer.parseInt(
+ EntityStatHelper.getStat(
+ player,
+ "BlessingCounter")) != counter) {
+ NewPacketHandler.UPDATE_STAT
+ .sendToPlayer(player,
+ "BlessingCounter",
+ "" + counter);
+ }
+
+ EntityStatHelper.giveStat(player,
+ "BlessingActive",
+ blessingActive);
+ EntityStatHelper.giveStat(player,
+ "BlessingCooldown",
+ coolDown);
+ EntityStatHelper.giveStat(player,
+ "BlessingCounter",
+ counter);
+ EntityStatHelper.giveStat(player,
+ "BlessingTimer", timer);
+
+ }
+
+ for (Object o : s.loadedEntityList) {
+ if (o == null || !(o instanceof Entity)) {
+ continue;
+ }
+
+ if (o instanceof EntityItem) {
+ EntityItem item = (EntityItem) o;
+
+ if (((EntityItem) o).isBurning()) {
+ ItemStack stack = item
+ .getDataWatcher()
+ .getWatchableObjectItemStack(
+ 10);
+
+ if (canAdvanceBurnTaskProgress(
+ stack)) {
+ worldData.progress += stack.stackSize;
+ ((EntityItem) o).isDead = true;
+
+ String name1;
+
+ if (CommonTickHandler.worldData.currentTask
+ .equals("Kill")) {
+ name1 = FyresWorldData.validMobNames[CommonTickHandler.worldData.currentTaskID];
+ } else {
+ name1 = FyresWorldData.validItems[CommonTickHandler.worldData.currentTaskID]
+ .getDisplayName();
+ }
+
+ if (name1.contains(
+ "Block")) {
+ if (name1.contains(
+ "Block")) {
+ name1 = name1.replace(
+ "Block",
+ "Blocks")
+ .replace("block",
+ "blocks");
+ }
+ } else {
+ name1 += "s";
+ }
+
+ NewPacketHandler.SEND_MESSAGE
+ .sendToAllPlayers(
+ "\u00A7fCurrent Goal Progress: "
+ + worldData.progress
+ + "/"
+ + worldData.currentTaskAmount
+ + " "
+ + name1
+ + " "
+ + worldData.currentTask
+ + "ed.");
+
+ if (worldData.progress >= worldData.currentTaskAmount) {
+ worldData.progress = 0;
+ worldData.tasksCompleted++;
+
+ NewPacketHandler.LEVEL_UP
+ .sendToAllPlayers(
+ worldData.rewardLevels);
+
+ worldData.giveNewTask();
+
+ String name;
+ if (worldData.currentTask
+ .equals("Kill")) {
+ name = FyresWorldData.validMobNames[worldData.currentTaskID];
+ } else {
+ name = FyresWorldData.validItems[worldData.currentTaskID]
+ .getDisplayName();
+ }
+
+ if (worldData.currentTaskAmount > 1) {
+ if (name.contains(
+ "Block")) {
+ if (name.contains(
+ "Block")) {
+ name = name.replace(
+ "Block",
+ "Blocks")
+ .replace("block",
+ "blocks");
+ }
+ } else {
+ name += "s";
+ }
+ }
+
+ NewPacketHandler.SEND_MESSAGE
+ .sendToAllPlayers(
+ "\u00A7eA world goal has been completed!"
+ + (!worldData.getDisadvantage()
+ .equals("None") ? " World disadvantage has been lifted!"
+ : ""));
+
+ NewPacketHandler.SEND_MESSAGE
+ .sendToAllPlayers(
+ "\u00A7eA new world goal has been set: "
+ + (worldData.currentTask
+ + " "
+ + worldData.currentTaskAmount
+ + " "
+ + name
+ + ". ("
+ + worldData.progress
+ + " "
+ + worldData.currentTask
+ + "ed)"));
+
+ worldData.currentDisadvantage = "None";
+ }
+
+ NewPacketHandler.UPDATE_WORLD_DATA
+ .sendToAllPlayers(
+ worldData.potionValues,
+ worldData.potionDurations,
+ worldData.getDisadvantage(),
+ worldData.currentTask,
+ worldData.currentTaskID,
+ worldData.currentTaskAmount,
+ worldData.progress,
+ worldData.tasksCompleted,
+ worldData.enderDragonKilled,
+ ConfigData.spawnTraps,
+ worldData.rewardLevels,
+ worldData.mushroomColors);
+
+ worldData.setDirty(
+ true);
+ }
+ }
+ }
+ }
+ }
+
+ for (Entity e : addLater) {
+ WorldServer world = null;
+
+ for (WorldServer s : MinecraftServer
+ .getServer().worldServers) {
+ if (s.provider.dimensionId == e.dimension) {
+ world = s;
+ break;
+ }
+ }
+
+ if (world != null) {
+ world.spawnEntityInWorld(e);
+ }
+ }
+
+ addLater.clear();
+
+ if (worldData != null) {
+ if (worldData.getDisadvantage()
+ .equals("Neverending Rain")) {
+ if (!MinecraftServer
+ .getServer().worldServers[0]
+ .getWorldInfo()
+ .isRaining()) {
+ MinecraftServer.getServer().worldServers[0]
+ .getWorldInfo()
+ .setRaining(true);
+ }
+
+ if (!MinecraftServer
+ .getServer().worldServers[0]
+ .getWorldInfo()
+ .isThundering()) {
+ MinecraftServer.getServer().worldServers[0]
+ .getWorldInfo()
+ .setThundering(true);
+ }
+ } else if (worldData.getDisadvantage()
+ .equals("Neverending Night")) {
+ MinecraftServer.getServer().worldServers[0]
+ .getWorldInfo()
+ .setWorldTime(18000);
+ }
+ }
+ }
+
+ private boolean canAdvanceBurnTaskProgress(ItemStack stack) {
+ String task = worldData.currentTask;
+
+ if(task == null || !(task.equals("Burn"))) return false;
+
+ if(stack != null && stack.getItem() != null) {
+ ItemStack target = FyresWorldData.validItems[worldData.currentTaskID];
+
+ if(target != null && target.getItem() != null) {
+ if(stack.getItem() != target.getItem()) {
+ return false;
+ }
+
+ if(stack.getItemDamage() != target.getItemDamage()) {
+ return false;
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/YWD/src/main/java/fyresmodjam/handlers/EventHandler.java b/YWD/src/main/java/fyresmodjam/handlers/EventHandler.java new file mode 100644 index 0000000..d8ca215 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/handlers/EventHandler.java @@ -0,0 +1,5 @@ +package fyresmodjam.handlers; + +public class EventHandler { + +} diff --git a/YWD/src/main/java/fyresmodjam/handlers/FyresKeyHandler.java b/YWD/src/main/java/fyresmodjam/handlers/FyresKeyHandler.java new file mode 100755 index 0000000..4b3dd35 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/handlers/FyresKeyHandler.java @@ -0,0 +1,189 @@ +package fyresmodjam.handlers;
+
+import org.lwjgl.input.Keyboard;
+
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.InputEvent.KeyInputEvent;
+import fyresmodjam.ModjamMod;
+import fyresmodjam.blessings.Blessing;
+import fyresmodjam.blessings.BlessingUtils;
+import fyresmodjam.blocks.BlockTrap;
+import fyresmodjam.items.ItemTrap;
+import fyresmodjam.tileentities.TileEntityPillar;
+import fyresmodjam.tileentities.TileEntityTrap;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.MovingObjectPosition.MovingObjectType;
+
+public class FyresKeyHandler {
+
+ public static KeyBinding examine = new KeyBinding(
+ "Examine", Keyboard.KEY_X, "YWD");
+ public static KeyBinding activateBlessing = new KeyBinding(
+ "Activate Blessing", Keyboard.KEY_K, "YWD");
+
+ public static KeyBinding[] keyBindings = new KeyBinding[] {
+ examine, activateBlessing
+ };
+
+ public FyresKeyHandler() {
+ for (KeyBinding k : keyBindings) {
+ ClientRegistry.registerKeyBinding(k);
+ }
+ }
+
+ @SubscribeEvent
+ public void keyInput(KeyInputEvent event) {
+ if (Minecraft.getMinecraft().inGameHasFocus) {
+ Minecraft minecraft = Minecraft.getMinecraft();
+ EntityPlayer player = minecraft.thePlayer;
+
+ if (player != null) {
+ if (examine.isPressed()) {
+ if (minecraft.objectMouseOver != null) {
+
+ MovingObjectPosition o = minecraft.objectMouseOver;
+
+ if (o.typeOfHit == MovingObjectType.BLOCK) {
+ int x = minecraft.objectMouseOver.blockX;
+ int y = minecraft.objectMouseOver.blockY;
+ int z = minecraft.objectMouseOver.blockZ;
+
+ if (minecraft.theWorld
+ .getBlock(x, y, z) == ModjamMod.blockPillar
+ && (minecraft.theWorld
+ .getBlockMetadata(
+ x,
+ y,
+ z)
+ % 2) == 1) {
+ y--;
+ }
+
+ TileEntity te = minecraft.theWorld
+ .getTileEntity(x,
+ y,
+ z);
+
+ if (te != null && te instanceof TileEntityPillar) {
+ Blessing bless = BlessingUtils
+ .getBlessingInstance(
+ ((TileEntityPillar) te).blessing);
+
+ String s = "@\u00A7e "
+ + bless.customName()
+ + "\n"
+ + bless.description()
+ + ".";
+
+ for (String s2 : s
+ .split("@")) {
+
+ NewPacketHandler.SEND_MESSAGE.data = new Object[] {
+ s2
+ };
+ NewPacketHandler.SEND_MESSAGE
+ .executeClient(Minecraft
+ .getMinecraft().thePlayer);
+ }
+
+ } else if (te != null
+ && te instanceof TileEntityTrap) {
+ String placedBy = ((TileEntityTrap) te).placedBy;
+
+ String s = (placedBy != null
+ ? "\u00A7eThis " + ItemTrap.names[te
+ .getBlockMetadata()
+ % BlockTrap.trapTypes]
+ .toLowerCase()
+ + " was placed by "
+ + (placedBy.equals(
+ player.getCommandSenderName())
+ ? "you"
+ : placedBy)
+ + "."
+ : "\u00A7eThis " + ItemTrap.names[te
+ .getBlockMetadata()
+ % BlockTrap.trapTypes]
+ .toLowerCase()
+ + " doesn't seem to have been placed by anyone.");
+ s += " \u00A7eTrap is set to "
+ + TileEntityTrap.settings[((TileEntityTrap) te).setting]
+ + ".";
+
+ NewPacketHandler.SEND_MESSAGE.data = new Object[] {
+ s
+ };
+ NewPacketHandler.SEND_MESSAGE
+ .executeClient(Minecraft
+ .getMinecraft().thePlayer);
+ } else {
+ ItemStack stack = new ItemStack(
+ minecraft.theWorld
+ .getBlock(x, y, z),
+ 1,
+ minecraft.theWorld
+ .getBlockMetadata(
+ x,
+ y,
+ z));
+
+ if (stack.getItem() != null) {
+ String name = stack
+ .getDisplayName()
+ .toLowerCase();
+
+ NewPacketHandler.SEND_MESSAGE.data = new Object[] {
+ "\u00A7eIt's a " + name
+ + (!name.contains(
+ "block") ? " block."
+ : ".")
+ };
+ NewPacketHandler.SEND_MESSAGE
+ .executeClient(Minecraft
+ .getMinecraft().thePlayer);
+ }
+ }
+ } else if (o.typeOfHit == MovingObjectType.ENTITY
+ && o.entityHit != null) {
+ NewPacketHandler.EXAMINE_MOB
+ .sendToServer(o.entityHit.dimension,
+ o.entityHit.getEntityId());
+ }
+ }
+ }
+
+ if (activateBlessing.isPressed()) {
+ String blessing = player
+ .getEntityData()
+ .getString("Blessing");
+
+ if (blessing != null) {
+ FMLLog.info("Triggering blessing");
+
+ if (minecraft.objectMouseOver != null) {
+ MovingObjectPosition o = minecraft.objectMouseOver;
+ if (o.typeOfHit == MovingObjectType.BLOCK) {
+ NewPacketHandler.ACTIVATE_BLESSING
+ .sendToServer(minecraft.objectMouseOver.blockX,
+ minecraft.objectMouseOver.blockY,
+ minecraft.objectMouseOver.blockZ);
+ }
+ } else {
+ NewPacketHandler.ACTIVATE_BLESSING
+ .sendToServer(player.chunkCoordX,
+ player.chunkCoordY,
+ player.chunkCoordZ);
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/YWD/src/main/java/fyresmodjam/handlers/GUIHandler.java b/YWD/src/main/java/fyresmodjam/handlers/GUIHandler.java new file mode 100755 index 0000000..207a569 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/handlers/GUIHandler.java @@ -0,0 +1,21 @@ +package fyresmodjam.handlers;
+
+import cpw.mods.fml.common.network.IGuiHandler;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+
+public class GUIHandler implements IGuiHandler {
+
+ @Override
+ public Object getServerGuiElement(int ID, EntityPlayer player,
+ World world, int x, int y, int z) {
+ return null;
+ }
+
+ @Override
+ public Object getClientGuiElement(int ID, EntityPlayer player,
+ World world, int x, int y, int z) {
+ return null;
+ }
+
+}
diff --git a/YWD/src/main/java/fyresmodjam/handlers/NewPacketHandler.java b/YWD/src/main/java/fyresmodjam/handlers/NewPacketHandler.java new file mode 100755 index 0000000..787a8c9 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/handlers/NewPacketHandler.java @@ -0,0 +1,970 @@ +package fyresmodjam.handlers;
+
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.network.FMLIndexedMessageToMessageCodec;
+import cpw.mods.fml.common.network.FMLOutboundHandler;
+import cpw.mods.fml.common.network.NetworkRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import fyresmodjam.ModjamMod;
+import fyresmodjam.blessings.BlessingUtils;
+import fyresmodjam.blocks.BlockTrap;
+import fyresmodjam.misc.EntityStatHelper;
+import fyresmodjam.misc.ItemStatHelper;
+import fyresmodjam.tileentities.TileEntityTrap;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+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.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.WorldServer;
+
+@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<IPacket> {
+
+ 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).playerEntity;
+
+ if (player != null) {
+ packet.executeServer(
+ player);
+ packet.executeBoth(player);
+ }
+
+ break;
+
+ default:
+ break;
+
+ }
+ }
+
+ @SideOnly(Side.CLIENT)
+ public EntityPlayer getClientPlayer() {
+ return Minecraft.getMinecraft().thePlayer;
+ }
+ }
+
+ 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<Class> validClasses = new ArrayList<Class>();
+ 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];
+ player.worldObj.playSound(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.addChatComponentMessage(
+ new ChatComponentText(
+ 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");
+
+ TileEntity te = player.worldObj
+ .getTileEntity(blockX,
+ blockY,
+ blockZ);
+
+ boolean yours = (te == null
+ || !(te instanceof TileEntityTrap))
+ ? false
+ : player.getCommandSenderName()
+ .equals(((TileEntityTrap) te).placedBy);
+
+ 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) {
+ ItemStack spawned = new ItemStack(
+ ModjamMod.itemTrap,
+ 1,
+ player.worldObj.getBlockMetadata(
+ blockX,
+ blockY,
+ blockZ)
+ % BlockTrap.trapTypes);
+
+ player.worldObj.spawnEntityInWorld(
+ new EntityItem(player.worldObj,
+ blockX + 0.5F,
+ blockY,
+ blockZ + 0.5F,
+ spawned));
+ }
+
+ player.worldObj.setBlockToAir(
+ blockX,
+ blockY,
+ blockZ);
+ } else {
+ int trapType = player.worldObj
+ .getBlockMetadata(
+ blockX,
+ blockY,
+ blockZ);
+
+ // TODO use a custom damage
+ // type for the traps
+ if (trapType % BlockTrap.trapTypes == 0) {
+ player.attackEntityFrom(
+ DamageSource.cactus,
+ 4.0F + (scout ? 1
+ : 0));
+ if (ModjamMod.r.nextInt(
+ 16 - (scout ? 4
+ : 0)) == 0) {
+ ((EntityLivingBase) player)
+ .addPotionEffect(
+ new PotionEffect(
+ Potion.poison.id,
+ 100 + (scout ? 25
+ : 0),
+ 1));
+ }
+ } else if (trapType
+ % BlockTrap.trapTypes == 1) {
+ if (!player.isBurning()) {
+ player.setFire(5 + (scout
+ ? 1
+ : 0));
+ }
+ } else if (trapType
+ % BlockTrap.trapTypes == 2) {
+ 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.worldObj.setBlockToAir(
+ blockX,
+ blockY,
+ blockZ);
+
+ SEND_MESSAGE.sendToPlayer(
+ player,
+ "\u00A7c\u00A7oYou failed to disarm the trap.");
+
+ if (CommonTickHandler.worldData
+ .getDisadvantage()
+ .equals("Explosive Traps")) {
+ player.worldObj.setBlockToAir(
+ blockX,
+ blockY,
+ blockZ);
+ player.worldObj.createExplosion(
+ null,
+ blockX + 0.5F,
+ blockY + 0.5F,
+ blockZ + 0.5F,
+ 1.33F,
+ true);
+ }
+ 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 : MinecraftServer
+ .getServer().worldServers) {
+ if (s.provider.dimensionId == 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.getCommandSenderName()
+ + "\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.getCommandSenderName()
+ + "\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.worldObj
+ .getTotalWorldTime()
+ : player.worldObj
+ .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")) {
+ TileEntity te = player.worldObj
+ .getTileEntity(x,
+ y,
+ z);
+
+ if (te != null && te instanceof TileEntityTrap) {
+ SEND_MESSAGE.sendToPlayer(
+ player,
+ "\u00A7e\u00A7oYou disarm and salvage the trap.");
+
+ player.worldObj.spawnEntityInWorld(
+ new EntityItem(player.worldObj,
+ x + 0.5F,
+ y,
+ z + 0.5F,
+ new ItemStack(ModjamMod.itemTrap,
+ 1,
+ player.worldObj.getBlockMetadata(
+ x,
+ y,
+ z)
+ % BlockTrap.trapTypes)));
+ player.worldObj.setBlockToAir(
+ x,
+ y,
+ z);
+
+ 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
+ };
+ }
+ };
+}
|