diff options
Diffstat (limited to 'src/main/java/fyresmodjam/handlers/NewPacketHandler.java')
| -rw-r--r-- | src/main/java/fyresmodjam/handlers/NewPacketHandler.java | 1067 |
1 files changed, 1067 insertions, 0 deletions
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<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).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<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];
+
+ // 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
+ };
+ }
+ };
+}
|