Java 类cpw.mods.fml.common.network.simpleimpl.IMessage 实例源码

@Override
public IMessage onMessage(LobbyBeginGamePacket packet, MessageContext ctx) {
    int x = packet.x;
    int y = packet.y;
    int z = packet.z;

    World w = ctx.getServerHandler().playerEntity.worldObj;

    TileEntity te = w.getTileEntity(x, y, z);

    if (te != null && te instanceof LobbyTileEntity) {
        LobbyTileEntity tile = (LobbyTileEntity) te;

        tile.setGameLive(true);

        for (EntityPlayer p : UUIDUtil.getPlayersFromProfileUUIDs(w, tile.players))
            p.travelToDimension(PAYDAY.dimensionID);
    }

    return null;
}

@Override
public IMessage onMessage(LobbyPlayerOpenedGuiPacket packet, MessageContext ctx) {
    // SERVER
    int x = packet.x;
    int y = packet.y;
    int z = packet.z;

    EntityPlayerMP p = ctx.getServerHandler().playerEntity;

    World w = p.worldObj;
    if (w == null)
        return null;

    LobbyTileEntity tile = (LobbyTileEntity) w.getTileEntity(x, y, z);

    if (tile == null)
        return null;

    PAYDAY.INSTANCE.sendTo(new PacketSyncTileEntityClient(tile), p);

    return null;
}

@Override
public IMessage onMessage(final PacketSyncPlayerPropertiesServer packet, final MessageContext ctx) {
    // SERVER
    new Thread() {
        @Override
        public void run() {
            EntityPlayerMP player = ctx.getServerHandler().playerEntity;

            PlayerData data = PlayerData.get(player);
            data.setInLobby(packet.inLobby);
            data.setReady(packet.ready);

            PAYDAY.INSTANCE.sendToAll(new PacketSyncPlayerPropertiesClient(player.getGameProfile().getId(), packet.ready, packet.inLobby));
        }
    }.start();

    return null;
}

@Override
@SideOnly(Side.CLIENT)
public IMessage onMessage(SupportedFeaturesPacket message, MessageContext ctx) {

    MineDonate.cfg.sellItems = message.items;
    MineDonate.cfg.itemsMoneyType = message.itemsMoneyType;
    MineDonate.cfg.sellPrivelegies = message.privelegies;
    MineDonate.cfg.privelegiesMoneyType = message.privelegiesMoneyType;
    MineDonate.cfg.sellRegions = message.regions;
    MineDonate.cfg.regionMoneyType = message.regionsMoneyType;
    MineDonate.cfg.sellEntities = message.entities;
    MineDonate.cfg.entitiesMoneyType = message.entitiesMoneyType;
    MineDonate.cfg.userShops = message.userShops;

    MineDonate . loadClientMerch ( ) ;

    ShopGUI . instance . defaultCategory = message . firstCatId ;

    return null;

}

@Override
@SideOnly(Side.CLIENT)
public IMessage onMessage(MsgSyncRadiation message, MessageContext ctx)
{
    PlayerTracker tracker = TrackerManager.lookupTrackerFromUsername(Minecraft.getMinecraft().thePlayer.getCommandSenderName());

    if (tracker == null) {
        tracker = new PlayerTracker(Minecraft.getMinecraft().thePlayer);
        TrackerManager.addToManager(tracker);
        System.out.println("Tracker == null? Add new!");
    }


    if (tracker != null) {
        tracker.prevRadiation = tracker.radiation;
        tracker.radiation = message.radiation;
    }

    //System.out.println("RECV! " + message.radiation);

    return null;
}

@Override
public IMessage onMessage(MessageSyncRoleplayMode message, MessageContext ctx)
{
    EntityPlayer player = YeOldeChat.proxy.getPlayerFromMessageContext(ctx);
    if (player == null)
        return null;

    PlayerRoleplayMode props = PlayerRoleplayMode.get(player);
    if (props == null) {
        return null;
    }

    if (player.worldObj.isRemote)
    props.setRoleplayMode(message.roleplayMode, true);

    return null;
}

@Override
public IMessage onMessage(PacketClientCommand message, MessageContext ctx) {
    switch (message.commandType) {
    case 0: // Command /cnp reload
        ConfigLoader.reloadPlugins();
        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentTranslation("customneiplugins.command.reload.info", ConfigLoader.loadedPlugins.size()));
        break;
    case 1: // Command /cnp status
        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentTranslation("customneiplugins.command.status.info", ConfigLoader.loadedPlugins.size(), ConfigLoader.disabledPlugins.size(), ConfigLoader.erroredPlugins.size()));
        for (String loadedPluginName: ConfigLoader.loadedPlugins)
            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentTranslation("customneiplugins.command.status_loaded.info", loadedPluginName));
        for (String disabledPluginName: ConfigLoader.disabledPlugins)
            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentTranslation("customneiplugins.command.status_disabled.info", disabledPluginName));
        for (String erroredPluginName: ConfigLoader.erroredPlugins)
            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentTranslation("customneiplugins.command.status_errored.info", erroredPluginName));
    }
    return null;
}

private void pull(World world, Entity entity, double posX, double posY, double posZ, double dy, double yy) {
   if(!(entity instanceof EntityDragon) && !(entity instanceof EntityHornedHuntsman)) {
      double d = posX - entity.posX;
      double d1 = posY - entity.posY;
      double d2 = posZ - entity.posZ;
      float distance = MathHelper.sqrt_double(d * d + d1 * d1 + d2 * d2);
      float f2 = 0.1F + (float)dy;
      double mx = d / (double)distance * (double)f2 * (double)distance;
      double my = yy == 0.0D?0.4D:d1 / (double)distance * (double)distance * 0.2D + 0.2D + yy;
      double mz = d2 / (double)distance * (double)f2 * (double)distance;
      if(entity instanceof EntityLivingBase) {
         ((EntityLivingBase)entity).addPotionEffect(new PotionEffect(Potion.jump.id, 20, 1));
      }

      if(entity instanceof EntityPlayer) {
         Witchery.packetPipeline.sendTo((IMessage)(new PacketPushTarget(mx, my, mz)), (EntityPlayer)entity);
      } else {
         entity.motionX = mx;
         entity.motionY = my;
         entity.motionZ = mz;
      }

   }
}

public void onUsingTick(ItemStack stack, EntityPlayer player, int countdown) {
   World world = player.worldObj;
   int elapsedTicks = this.getMaxItemUseDuration(stack) - countdown;
   if(!world.isRemote && elapsedTicks % 20 == 0) {
      EntityLivingBase entity = this.getBoundEntity(world, player, stack, Integer.valueOf(1));
      if(entity != null && entity.dimension == player.dimension) {
         if(entity == player) {
            if(elapsedTicks == 0) {
               EntityEye eye = new EntityEye(world);
               eye.setLocationAndAngles(player.posX, player.posY, player.posZ, player.rotationYaw, 90.0F);
               world.spawnEntityInWorld(eye);
               Witchery.packetPipeline.sendTo((IMessage)(new PacketCamPos(true, elapsedTicks == 0, eye)), player);
            } else {
               Witchery.packetPipeline.sendTo((IMessage)(new PacketCamPos(true, false, (Entity)null)), player);
            }
         } else {
            Witchery.packetPipeline.sendTo((IMessage)(new PacketCamPos(true, elapsedTicks == 0, entity)), player);
         }
      } else {
         Witchery.packetPipeline.sendTo((IMessage)(new PacketCamPos(false, false, (Entity)null)), player);
      }
   }

}

@Override
public IMessage onMessage(BlockMessage message, MessageContext ctx) {
    /*int d = message.dimension == 0 ? 0 : (message.dimension == -1 ? 1 : 2);
    switch(message.id){
    case 0:
    MinecraftServer.getServer().worldServers[d].setBlock(message.x, message.y - 1, message.z, Blocks.planks);break;
    case 1:
    MinecraftServer.getServer().worldServers[d].setBlock(message.x, message.y - 1, message.z, Blocks.dirt);break;
    case 2:
    MinecraftServer.getServer().worldServers[d].setBlock(message.x, message.y - 1, message.z, Blocks.stone);break;
    }*/
    int d = message.dimension == 0 ? 0 : (message.dimension == -1 ? 1 : 2);
    switch(message.id){
    case 0:
        ctx.getServerHandler().playerEntity.worldObj.setBlock(message.x, message.y - 1, message.z, Blocks.planks);break;
    case 1:
        ctx.getServerHandler().playerEntity.worldObj.setBlock(message.x, message.y - 1, message.z, Blocks.dirt);break;
    case 2:
        ctx.getServerHandler().playerEntity.worldObj.setBlock(message.x, message.y - 1, message.z, Blocks.stone);break;
    }
    TileEntityNote entity = (TileEntityNote) ctx.getServerHandler().playerEntity.worldObj.getTileEntity(message.x, message.y, message.z);
    entity.note = (byte) message.note;
    entity.triggerNote(ctx.getServerHandler().playerEntity.worldObj, message.x, message.y, message.z);
    return null;
}

@Override
public IMessage onMessage(ADSUpdatePacket m, MessageContext ctx)
{
    TileEntity te = Minecraft.getMinecraft().theWorld.getTileEntity(m.x, m.y, m.z);

    if (te instanceof TileEntityReciever)
    {
        TileEntityReciever ter = (TileEntityReciever) te;
        ter.yawLimit = m.range;
        ter.kMobs = m.mob;
        ter.kTeam = m.chip;
        ter.kPlayers = m.player;
        ter.hasWeapon = m.haswep;
        ter.username = m.user;
    }
    return null;
}

@Override
public IMessage onMessage(EntityDebrisPacket m, MessageContext ctx)
{
    Iterator iter = Minecraft.getMinecraft().theWorld.loadedEntityList.iterator();
    while (iter.hasNext())
    {
        Entity e = (Entity) iter.next();
        if (e.getEntityId() == m.id && e instanceof EntityDebris)
        {
            EntityDebris ed = (EntityDebris) e;
            ed.block = m.block;
            ed.metadata = m.metadata;
            break;
        }
    }
    return null;
}

@Override
public IMessage onMessage(ItemUpdate message, MessageContext ctx)
{
    ItemStack itemstack = ctx.getServerHandler().playerEntity.inventory.getStackInSlot(message.item);
    if (itemstack.getItem() instanceof ItemTesla)
    {
        if (itemstack.stackTagCompound == null) itemstack.stackTagCompound = new NBTTagCompound();
        itemstack.stackTagCompound.setInteger("dial", message.value);
    }
    if (itemstack.getItem() instanceof ItemFlameThrower)
    {
        if (itemstack.stackTagCompound == null) itemstack.stackTagCompound = new NBTTagCompound();
        itemstack.stackTagCompound.setInteger("mode", message.value);
    }
    return null;
}

@Override
public IMessage onMessage(TextPacket m, MessageContext ctx)
{
    if (m.text.startsWith("-t"))
    {
        String[] str = m.text.substring(2, m.text.length()).split("\n");
        for (int i = 0; i < str.length; i++) Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str[i]));
    }
    else
    {
        String[] s = m.text.split(" ");
        StringBuilder strb = new StringBuilder();
        for (int i = 0; i < s.length; i++)
        {
            strb.append(StatCollector.translateToLocal(s[i]));
            strb.append(" ");
        }
        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(strb.toString()));
    }
    return null;
}

@Override
public IMessage onMessage(EntityGorePacket m, MessageContext ctx)
{
    Iterator iter = Minecraft.getMinecraft().theWorld.loadedEntityList.iterator();
    while (iter.hasNext())
    {
        Entity e = (Entity) iter.next();
        if (e.getEntityId() == m.id && e instanceof EntityGore)
        {
            EntityGore eg = (EntityGore) e;
            eg.mob = m.mob;
            eg.type = m.type;
            eg.greenblood = m.green;

            if (m.mob == 0) eg.username = m.username;
            if (m.mob == 11) eg.size = m.size;
            break;
        }
    }
    return null;
}

@Override
public IMessage onMessage(PacketDialerChangeMode message, MessageContext ctx)
{
    ItemStack dialer = null;
    InventoryPlayer inv = ctx.getServerHandler().playerEntity.inventory;
    for (int i = 0; i < inv.getSizeInventory(); i++)
    {
        if (inv.getStackInSlot(i) != null && inv.getStackInSlot(i).getItem() instanceof ItemDialer)
        {
            dialer = inv.getStackInSlot(i);
            dialer.stackTagCompound.setBoolean("modeDial", !dialer.stackTagCompound.getBoolean("modeDial"));
            break;
        }
    }
    return null;
}

@Override
public IMessage onMessage(ClientWaypointPacket message, MessageContext ctx) {
    if (LoadedModHelper.supportMod == null) 
        return null;
    else if (!LoadedModHelper.failedCompat) {
        int targetY = message.posY==-1? ModConfig.waypointYLevelEliteLocator: message.posY;
        switch(LoadedModHelper.supportMod) {
        case JOURNEYMAP:
            if (!JourneyMapHelper.isWaypointExist(message.posX, message.posZ, message.dimId, true))
                JourneyMapHelper.addWaypoint(I18n.format(message.wpName), message.posX, targetY, message.posZ, message.dimId);        
            break;
        case XAEROMINIMAP:
            if (!XaeroMinimapHelper.isWaypointExist(message.posX, message.posZ, true))
                XaeroMinimapHelper.addWaypoint(I18n.format(message.wpName), message.posX, targetY, message.posZ);
            break;
        }
    }
    return null;
}

@Override
public IMessage onMessage(ClientInfoMessageTranslationPacket message, MessageContext ctx) {
    SupportModsEnum supportMod = LoadedModHelper.supportMod;
    if (supportMod == null) {
        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentTranslation("modcompat.gtveinlocator.no_minimap.info"));
        return null;
    }
    else if (LoadedModHelper.failedCompat) {
        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentTranslation("modcompat.gtveinlocator.oldversion_minimap.info", supportMod.getName()));
        return null;
    }
    int[] intParaArray = message.intParaArray;
    int infoIndex = message.infoIndex;
    switch (infoIndex) {
    case 2:
        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentTranslation("chat.gtveinlocator.info"+infoIndex, intParaArray[0], intParaArray[1], intParaArray[2], supportMod.getName()));
        break;
    default:
        break;
    }
    return null;
}

@Override
public IMessage onMessage(ConfigPacket message, MessageContext ctx) {
    ConfigLoadEvent.Pre event = new ConfigLoadEvent.Pre();
    event.configName = message.configName;
    event.config = message.config;
    event.isRevert = message.isRevert;
    if (!MinecraftForge.EVENT_BUS.post(event)) {
        ConfigRegistry.onConfigReload(event);
        ConfigLoadEvent.Post newEvent = new ConfigLoadEvent.Post();
        newEvent.configName = event.configName;
        newEvent.config = event.config;
        newEvent.isRevert = event.isRevert;
        MinecraftForge.EVENT_BUS.post(event);
    }
    return null;
}

@Override
public IMessage onMessage(PacketTileEntity message, MessageContext messageContext) {
    TileEntity tileEntity = message.getLocation().getTileEntity(NetworkHandler.getWorld(messageContext));

    if (tileEntity != null && tileEntity instanceof ITileNetworkable) {
        ITileNetworkable tileNetworkable = (ITileNetworkable) tileEntity;

        try {
            tileNetworkable.handlePacketData(message.storedBuffer);
        } catch (Exception e) {
            e.printStackTrace();
        }

        message.storedBuffer.release();
    }

    return null;
}

public void disconnectFromPowerGrid(World world, TileEntityPowerGridNode te_node)
{
    UUID grid_uuid = te_node.getPowerGridUUID();
    PowerGrid grid = PowerGridWorldSavedData.get(te_node.getWorldObj()).getGridByUUID(grid_uuid);
    PowerGridNode node = grid.getGridNode(te_node.getNodeUUID());

    grid.disconnectGridNode(node);

    IMessage message = new PowerGridNodeDisconnectedMessage(grid_uuid, te_node.getNodeUUID(), te_node.xCoord, te_node.yCoord, te_node.zCoord);
    NetworkUtils.broadcastToWorld(world, message);

    if (grid.getNodes().size() == 0)
    {
        message = new PowerGridDestroyedMessage(grid_uuid);
        NetworkUtils.broadcastToWorld(world, message);
    }

    grid.connectGrid();
}

@Override
public IMessage onMessage(PacketWaterworksProgress message, MessageContext ctx) {
  TileWaterworks te = message.getTileEntity(EnderIO.proxy.getClientWorld());
  if (te != null) {
    te.setProgress(message.progress);
    setTank(te.inputTank, message.inputTankAmount, message.inputTankId);
    setTank(te.outputTank, message.outputTankAmount, message.outputTankId);
    if (message.progress_inId >= 0) {
      te.progress_in = FluidRegistry.getFluid(message.progress_inId);
    }
    if (message.progress_outId >= 0) {
      te.progress_out = FluidRegistry.getFluid(message.progress_outId);
    } else {
      te.progress_out = null;
    }
    te.stashProgress = message.stashProgress;
  }
  return null;
}

@Override
public IMessage onMessage(jsonConfigMessage message, MessageContext ctx) {
    if (ctx.side.isClient()) {
        if (message.configName.equals(CONSTS.packetMaterialId)){
            ITA.jsonMaterial = message.json;
        } else if (message.configName.equals(CONSTS.packetProtectionTraitsId)){
            ITA.jsonProtectionTraits = message.json;
        } else if (message.configName.equals(CONSTS.packetPotionTraitsId)){
            ITA.jsonPotionTraits = message.json;
        }
        System.out.println(message.configName);
        System.out.println(message.json);
        Config.loadFromCachedJSON(message.configName);
        return null;
    }
    return null;
}

@Override
@SideOnly(Side.CLIENT)
public IMessage onMessage(PacketPMon msg, MessageContext ctx) {
  EntityPlayer player = EnderIO.proxy.getClientPlayer();
  if (player != null) {
    TilePMon te = msg.getTileEntity(player.worldObj);
    if (te != null && msg.no >= 0 && msg.no < te.stats.length) {
      te.stats[msg.no].setCollectCount(msg.collectCount);
      te.stats[msg.no].setPos(msg.pos);
      te.stats[msg.no].setData(msg.data);
      if (msg.no == te.stats.length - 1 && te.dynaTextureProvider != null) {
        ((DynaTextureProvider) te.dynaTextureProvider).updateTexture();
      }
    }
  }
  return null;
}

@Override
        public IMessage onMessage(DragonPlayerUpdateIsDragon message, MessageContext ctx) {
            EntityClientPlayerMP player = Minecraft.getMinecraft().thePlayer;
            if (player != null) {
                if (player != null) {
                    DragonPlayer dragonPlayer = DragonPlayer.get(player);
                    dragonPlayer.setDragon(message.value, false);
                    if (!message.value) {
                        // Some other human defaults
//                      player.noClip = false;
                        player.stepHeight = 0.5F; // Normally 0.5F for player
                    }
                }

            }
            return null;
        }

@Override
public IMessage onMessage(StaffUpdateDestroyBlock message, MessageContext ctx) {
    EntityPlayer player = ctx.getServerHandler().playerEntity;
    if (player != null) {
        Block block = player.worldObj.getBlock(message.x, message.y, message.z);
        if (block != null) {
            float amplifier = DragonPlayer.get(player).getLevel() / 2.0F;
            float minHardness = Math.max(1.0F, 1.0F + amplifier);
            float hardness = block.getBlockHardness(player.worldObj, message.x, message.y, message.z);
            LogHelper.info("Block hardness is " + hardness);
            if (hardness >= 0 && hardness < minHardness) {
                player.worldObj.setBlock(message.x, message.y, message.z, Blocks.air, 0, 3);
                player.worldObj.playSoundEffect(message.x + 0.5D, message.y + 0.5D, message.z + 0.5D, 
                        REFERENCE.MODID + ":" + "soundWaveImpact", 1.8F, 1.0F);
                LogHelper.info("Destroyed a block!");
            }
            else {
                player.addChatMessage(new ChatComponentText(
                        StatCollector.translateToLocal("chat.wildbill22_draco.blockIsTooHard")));                       
            }
        }
    }
    return null;
}

/**
 * Send this message to all players within a defined AABB cuboid.
 * @param message - the message to send
 * @param cuboid - the AABB cuboid to send the packet in
 * @param dimId - the dimension the cuboid is in
 */
public void sendToCuboid(IMessage message, AxisAlignedBB cuboid, int dimId)
{
    MinecraftServer server = MinecraftServer.getServer();

    if(server != null && cuboid != null)
    {
        for(EntityPlayerMP player : (List<EntityPlayerMP>)server.getConfigurationManager().playerEntityList)
        {
            if(player.dimension == dimId && cuboid.isVecInside(Vec3.createVectorHelper(player.posX, player.posY, player.posZ)))
            {
                sendTo(message, player);
            }
        }
    }
}

@Override
public IMessage onMessage(MessageSetOverride message, MessageContext context)
{
    if (context.getServerHandler().playerEntity != null)
    {
        if (!context.getServerHandler().playerEntity.worldObj.isRemote)
        {
            World world = context.getServerHandler().playerEntity.worldObj;
            int x = message.changeX, y = message.changeY, z = message.changeZ;
            if (world.getTileEntity(x, y, z) instanceof TileEntityChangeBlock)
            {
                TileEntityChangeBlock tileEntity = (TileEntityChangeBlock) world.getTileEntity(x, y, z);
                System.out.println("Overrides " + message.state + " with: " + message.override);
                tileEntity.getBlockInfo().setOverridesState(message.state, message.override);
                world.markBlockForUpdate(x, y, z);
            }
        }
    }
    return null;
}

@Override
    public IMessage onMessage(PacketFilling message, MessageContext ctx)
    {
//        LogHelper.info("Received message from the server! " + message.getDirection() + ":" + message.getIsFilling());
//        LogHelper.info("I should be spawning a particle at: " + StringHelper.makeCoords(message.getX() + 1.0, message.getY() + 1.0, message.getZ() + 1.0));
//        Minecraft.getMinecraft().theWorld.spawnParticle("happyVillager", message.getX() + 1.0, message.getY() + 2.0, message.getZ() + 1.0, 0.0, 0.0, 0.0);
//        TileEntity tileEntity = (Minecraft.getMinecraft().theWorld.getTileEntity( message.getX(), message.getY() , message.getZ()));
//
//        if (Minecraft.getMinecraft().theWorld.isRemote && tileEntity!=null && tileEntity instanceof TileQuantumTank)
//        {
//            //((TileQuantumTank)tileEntity).tankFillParticles(message.getDirection(),message.getIsFilling(), FluidRegistry.getFluid(message.getFluidName()),message.getAmount(),message.getSize());
//            ParticleManager.tankFillParticles(Minecraft.getMinecraft().theWorld, message.getX(), message.getY(), message.getZ(), message.getDirection(), message.getIsFilling(), FluidRegistry.getFluid(message.getFluidName()), message.getAmount(), message.getSize());
//        }

        M4thThings.proxy.startParticleRendering(message);

        return null;
    }

@Override
public IMessage onMessage(PacketVoidTank message, MessageContext ctx) {
  EntityPlayer player = EnderIO.proxy.getClientPlayer();
  if (player != null) {
    TileVoidTank tile = message.getTileEntity(player.worldObj);
    if (tile == null) {
      return null;
    }
    if (message.nbtRoot.hasKey("tank")) {
      NBTTagCompound tankRoot = message.nbtRoot.getCompoundTag("tank");
      tile.tank.readFromNBT(tankRoot);
    } else {
      tile.tank.setFluid(null);
    }
  }
  return null;
}

@Override
public IMessage onMessage(AetherCraftTEPacket message, MessageContext ctx) {
    super.onMessage(message, ctx);

    if (te!=null) {
        te.selection = ((ForgeSelectionPacket)message).sel;
        if (te.selection==-1) {
            te.gridSize = 0;
        } else {
            te.gridSize = AetoForgeRegistry.recipes.get(te.selection).inputs.size();
        }
        if (te.container!=null) {
            te.container.regenerateSlots();
        }
    }

    return null;
}

@Override
public IMessage onMessage(MessageChamber message, MessageContext ctx)
{
    TileEntity tileEntity =
            FMLClientHandler.instance().getClient().theWorld.getTileEntity(message.x, message.y, message.z);

    if (tileEntity instanceof TileEntityFluxCrystallizationChamber)
    {
        ((TileEntityFluxCrystallizationChamber) tileEntity).setProgress(message.progress);
        ((TileEntityFluxCrystallizationChamber) tileEntity).setMultiplier(message.multiplier);
        ((TileEntityFluxCrystallizationChamber) tileEntity).setMultiplierDuration(message.multiplierDuration);
        ((TileEntityFluxCrystallizationChamber) tileEntity).setPowerStored(message.powerStored);
        ((TileEntityFluxCrystallizationChamber) tileEntity).setMaxPowerStored(message.powerMax);
    }

    return null;
}

@Override
public IMessage onMessage(SculptureOperationMessage message,
        MessageContext ctx) {

  World w = ctx.getServerHandler().playerEntity.worldObj;
  if (Operations.validOperation(w, message.x, message.y, message.z, message.pos, message.flags)) {
    Operations.applyOperation(w, message.x, message.y, message.z, message.pos, message.flags, message.block, message.meta);
  }

  EntityPlayer ep = ctx.getServerHandler().playerEntity;
  ItemStack is = ep.getCurrentEquippedItem();

  if ((message.flags & Operations.DAMAGE) != 0) {
    is.damageItem(1, ep);
  } else if ((Operations.CONSUME & message.flags) != 0) {
    if (!ep.capabilities.isCreativeMode) {
      is.stackSize--;
      if (is.stackSize <= 0) {
        ForgeEventFactory.onPlayerDestroyItem(ep, is);
        ep.inventory.mainInventory[ep.inventory.currentItem] = null;
      }
    }
  }

  return null;
}

@Override
public IMessage onMessage(final PacketSyncPlayerPropertiesClient packet, final MessageContext ctx) {
    // CLIENT

    new Thread() {
        @Override
        public void run() {
            PlayerData data = PlayerData.get(UUIDUtil.getPlayerFromProfileUUID(Minecraft.getMinecraft().theWorld, packet.playerProfileUUID));
            data.setInLobby(packet.inLobby);
            data.setReady(packet.ready);
        }
    }.start();

    return null;
}

@Override
public IMessage onMessage(final PacketSyncTileEntityServer packet, final MessageContext ctx) {
    // THIS IS ON SERVER
    new Thread() {
        @Override
        public void run() {
            EntityPlayerMP p = ctx.getServerHandler().playerEntity;
            World w = FMLCommonHandler.instance().getMinecraftServerInstance().worldServers[packet.dimensionID];
            LobbyTileEntity te = (LobbyTileEntity) w.getTileEntity(packet.x, packet.y, packet.z);

            if (te != null) {
                te.players = packet.players;
                te.lobbyHost = packet.lobbyHost;
                te.isGameLive = packet.isGameLive;
                te.check();
            }

            w = p.worldObj;
            te = (LobbyTileEntity) w.getTileEntity(packet.x, packet.y, packet.z);
            te.check();
            PAYDAY.INSTANCE.sendToAll(new PacketSyncTileEntityClient(te));

            // PAYDAY.INSTANCE.sendToServer(new
            // LobbyPlayerOpenedGuiPacket(packet.x, packet.y,
            // packet.z));//new PacketSyncTileEntityClient(te));
        }
    }.start();

    return null;
}

@Override
public IMessage onMessage(ArmourStandInteractMessage message, MessageContext ctx) {
    World world = DimensionManager.getWorld(message.dimID);
    EntityArmourStand stand = (EntityArmourStand) world.getEntityByID(message.standID);
    EntityPlayer player = (EntityPlayer) world.getEntityByID(message.playerID);

    stand.interact(player, message.hitPos);
    return null;
}

@Override
public IMessage onMessage(SetPlayerModelMessage message, MessageContext ctx) {
    String playerName = message.playerName;
    boolean isAlex = message.isAlex;

    for (Object obj : Minecraft.getMinecraft().theWorld.playerEntities)
        if (obj instanceof EntityPlayer && playerName.equals(((EntityPlayer) obj).getCommandSenderName())) {
            EntityPlayer player = (EntityPlayer) obj;
            player.getEntityData().setBoolean(SetPlayerModelCommand.MODEL_KEY, isAlex);
        }

    return null;
}

@Override
public IMessage onMessage(KickbackMessage message, MessageContext ctx)
{       
    if (ctx.side.isClient())    // just to make sure that the side is correct 
    {
        Helper_Client.knockUserBackClient(message.strength);
    }

    return null;    // Don't care about returning anything
}

@Override
public IMessage onMessage(PositionMessage message, MessageContext ctx)
{       
    if (ctx.side.isClient())    // just to make sure that the side is correct 
    {
        // Setting the position of the passed in entity, for precision purposes
        Helper_Client.updateEntityPositionClient(message.entityID, message.posX, message.posY, message.posZ);
    }

    return null;    // Don't care about returning anything
}

@Override
public IMessage onMessage(TurretInventoryMessage message, MessageContext ctx)
{       
    if (ctx.side.isClient())    // just to make sure that the side is correct 
    {
        Helper_Client.setTurretInventory(message.entityID, message.itemID, message.itemSlot, message.metadata);
    }

    return null;    // Don't care about returning anything
}