@Override
public IMessage onMessage(PacketAltarAnimation message, MessageContext ctx) {
	if (ctx.side == Side.CLIENT) {
		Minecraft.getMinecraft().addScheduledTask(new Runnable() {
			
			@Override
			public void run() {
				TileEntity tileEntity = Minecraft.getMinecraft().world.getTileEntity(message.pos);
				if (tileEntity instanceof TileEntityAltar) {
					((TileEntityAltar) tileEntity).altarAnimation = message.altarAnimation;
				}
			}
		});
	} else {
		System.out.println("Bad packet (wrong side: SERVER)!");
	}
	return null;
}
 

/** IMPORTANT: Call this from the onMessage method in the subclass. */
public IMessage processMessage(ObservationRequestMessage message, MessageContext ctx)
{
    IThreadListener mainThread = (WorldServer) ctx.getServerHandler().playerEntity.world;
    final EntityPlayerMP player = ctx.getServerHandler().playerEntity;
    final ObservationRequestMessage mess = message;
    mainThread.addScheduledTask(new Runnable()
    {
        @Override
        public void run()
        {
            JsonObject json = new JsonObject();
            buildJson(json, player, mess);
            // Send this message back again now we've filled in the json stats.
            Map<String, String> returnData = new HashMap<String, String>();
            returnData.put("json", json.toString());
            mess.addReturnData(returnData);
            MalmoMod.network.sendTo(new MalmoMod.MalmoMessage(MalmoMessageType.SERVER_OBSERVATIONSREADY, mess.id, returnData), player);
        }
    });
    return null; // no response in this case
}
 

@Override
public IMessage onMessage(VSGuiButtonMessage message, MessageContext ctx) {
    IThreadListener mainThread = ctx.getServerHandler().server;
    mainThread.addScheduledTask(() -> {
        World playerWorld = ctx.getServerHandler().player.world;
        TileEntity tileEntity = playerWorld.getTileEntity(message.getTileEntityPos());
        if (tileEntity == null) {
            // Nothing there, ignore this message
            return;
        }
        int buttonId = message.getButtonId();
        // Tell the tile entity that this player tried pressing the given button.
        if (tileEntity instanceof IVSTileGui) {
            ((IVSTileGui) tileEntity).onButtonPress(buttonId, ctx.getServerHandler().player);
        }
    });
    return null;
}
 

@Override
public IMessage onMessage(final WrapperPositionMessage message, MessageContext ctx) {
    if (Minecraft.getMinecraft().player == null) {
        return null;
    }

    IThreadListener mainThread = Minecraft.getMinecraft();
    mainThread.addScheduledTask(new Runnable() {
        @Override
        public void run() {
            if (Minecraft.getMinecraft().world != null) {
                Entity ent = Minecraft.getMinecraft().world
                    .getEntityByID(message.getEntityID());
                if (ent instanceof PhysicsWrapperEntity) {
                    PhysicsWrapperEntity wrapper = (PhysicsWrapperEntity) ent;
                    wrapper.getPhysicsObject().getShipTransformationManager().serverBuffer
                        .pushMessage(message);
                }
            }
        }
    });
    return null;
}
 

@Override
public IMessage onMessage(CraftMessage message, MessageContext ctx)
{
    EntityPlayerMP player = ctx.getServerHandler().playerEntity;
    // Try crafting recipes first:
    List<IRecipe> matching_recipes;
    String[] split = message.parameters.split(" ");
    matching_recipes = CraftingHelper.getRecipesForRequestedOutput(message.parameters, split.length > 1);

    for (IRecipe recipe : matching_recipes)
    {
        if (CraftingHelper.attemptCrafting(player, recipe))
            return null;
    }
    // Now try furnace recipes:
    ItemStack input = CraftingHelper.getSmeltingRecipeForRequestedOutput(message.parameters);
    if (input != null)
    {
        if (CraftingHelper.attemptSmelting(player, input))
            return null;
    }
    return null;
}
 

private void handle(InvokeWandMessage message, MessageContext ctx) {
    // note: we only get send types BLOCK and ENTITY and we only handle this message on the server
    EntityPlayer player = ctx.getServerHandler().playerEntity;
    switch (message.typeOfHit) {
        case BLOCK:
            FMLLog.info("Got a InvokeWandMessage block=%s", message.blockPos);
            PythonWandItem.invokeOnBlock(player, message.blockPos);
        case ENTITY:
            // in theory this should never be invoked on the client...
            Entity entity = player.worldObj.getEntityByID(message.entityId);
            FMLLog.info("Got a InvokeWandMessage entity=%s", entity);
            if (entity == null) return;
            PythonWandItem.invokeOnEntity(player, entity);
            break;
        case MISS:
            PythonWandItem.invokeInDirection(player, message.hitVec);
    }
}
 

@Override
public void handle(@NotNull MessageContext ctx) {
	EntityPlayerMP player = ctx.getServerHandler().player;

	ItemStack swappable = player.getHeldItemMainhand();

	ItemStack storageStack = BaublesSupport.getItem(player, IPearlStorageHolder.class);
	IPearlStorageHolder holder = (IPearlStorageHolder) storageStack.getItem();
	int originalPearlCount = holder.getPearlCount(storageStack);

	if (!storageStack.isEmpty() && swappable.getItem() instanceof IPearlSwappable) {
		ItemStack pearl = ((IPearlSwappable) swappable.getItem()).swapPearl(swappable, holder.removePearl(storageStack, index, false));
		holder.addPearl(storageStack, pearl, false);
	}

	PacketHandler.NETWORK.sendTo(new PacketUpdatePearlGUI(originalPearlCount, holder.getPearlCount(storageStack), index, swappable.getTagCompound(), storageStack.getTagCompound()), player);
}
 

@Override
public void handle(@NotNull MessageContext ctx) {
	EntityPlayerMP player = ctx.getServerHandler().player;

	ItemStack stack = player.getHeldItemMainhand();

	if (stack.getItem() instanceof IPearlStorageHolder) {
		IPearlStorageHolder holder = (IPearlStorageHolder) stack.getItem();
		int originalPearlCount = holder.getPearlCount(stack);

		ItemStack pearl = holder.removePearl(stack, index, true);
		player.addItemStackToInventory(pearl);

		int newPearlCount = holder.getPearlCount(stack);

		PacketHandler.NETWORK.sendTo(new PacketUpdatePearlGUI(originalPearlCount, newPearlCount, index, null, stack.getTagCompound()), player);
	}
}
 

@Override
public InventoryChangeMessage onMessage(final InventoryMessage message, MessageContext ctx)
{
    final EntityPlayerMP player = ctx.getServerHandler().playerEntity;
    IThreadListener mainThread = (WorldServer)ctx.getServerHandler().playerEntity.world;
    mainThread.addScheduledTask(new Runnable()
    {
        @Override
        public void run()
        {
            ItemStack[] changes = null;
            if (message.combine)
                changes = combineSlots(player, message.invA, message.slotA, message.invB, message.slotB, message.containerPos);
            else
                changes = swapSlots(player, message.invA, message.slotA, message.invB, message.slotB, message.containerPos);
            if (changes != null)
                MalmoMod.network.sendTo(new InventoryChangeMessage(changes[0], changes[1]), player);
        }
    });
    return null;
}
 

@Override
	public void handle(@NotNull MessageContext ctx) {
		if (ctx.side.isServer()) return;

		World world = LibrarianLib.PROXY.getClientPlayer().world;
		if (world == null) return;
		if (!world.isBlockLoaded(pos)) return;

		TileEntity entity = world.getTileEntity(pos);
		if (entity instanceof TileCraftingPlate) {
			TileCraftingPlate plate = (TileCraftingPlate) entity;

			// DEBUG
//			if (plate.renderHandler != null) {
//				System.out.println("Map has size " + ((TileCraftingPlateRenderer) plate.renderHandler).hoveringStacks.size());
//			}

			for (int i = 0; i < plate.realInventory.getHandler().getSlots(); i++) {
				plate.realInventory.getHandler().setStackInSlot(i, ItemStack.EMPTY);

				if (plate.renderHandler != null) {
					((TileCraftingPlateRenderer) plate.renderHandler).update(i, ItemStack.EMPTY);
				}
			}
		}
	}
 

@Override
public void handle(@NotNull MessageContext messageContext) {
	if (messageContext.side.isServer()) return;

	World world = LibrarianLib.PROXY.getClientPlayer().world;
	if (world == null) return;

	ClientRunnable.run(new ClientRunnable() {
		@Override
		@SideOnly(Side.CLIENT)
		public void runIfClient() {
			//	LibParticles.ParticleExplosion.INSTANCE.spawn(lifeTime, lifeTimeRange, amount, pos, color1, color2, strengthUpwards, strengthSideways);
			LibParticles.EXPLODE(world, pos, color1, color2, strengthSideways, strengthUpwards, amount, lifeTime, lifeTimeRange, bounce);
		}
	});
}
 

@Override
public IMessage onMessage(final MessageQuestUpdate message, MessageContext ctx) {
	if (ctx.side != Side.SERVER) {
		return null;
	}

	final EntityPlayerMP player = ctx.getServerHandler().player;

	if (player == null) {
		return null;
	}

	final WorldServer worldServer = player.getServerWorld();

	worldServer.addScheduledTask(new Runnable() {
		@Override
		public void run() {
			new Worker(message.action).work(message, player);
		}
	});

	return null;
}
 

@Override
public IMessage onMessage(MessagePlayerStoppedPiloting message, MessageContext ctx) {
    IThreadListener mainThread = ctx.getServerHandler().server;
    mainThread.addScheduledTask(() -> {
            BlockPos pos = message.posToStopPiloting;
            EntityPlayerMP player = ctx.getServerHandler().player;

            TileEntity tileEntity = player.world.getTileEntity(pos);

            if (tileEntity instanceof ITileEntityPilotable) {
                ((ITileEntityPilotable) tileEntity).playerWantsToStopPiloting(player);
            }
        }
    );
    return null;
}
 

@Override
public IMessage onMessage(final MessageBarrelModeUpdate msg, MessageContext ctx)
{
	Minecraft.getMinecraft().addScheduledTask(new Runnable() {
		@Override
		public void run()
		{
			TileEntity entity =  Minecraft.getMinecraft().player.world.getTileEntity(new BlockPos(msg.x, msg.y, msg.z));
			if (entity instanceof TileBarrel)
			{
				TileBarrel te = (TileBarrel) entity;
				te.setMode(msg.modeName);
				
				//Minecraft.getMinecraft().thePlayer.worldObj.notifyBlockUpdate(new BlockPos(msg.x, msg.y, msg.z));
			}
		}
	});
	return null;
}
 

@Override
public IMessage onMessage(PacketKeyMessage message, MessageContext ctx) {
	EntityPlayer player = ctx.getServerHandler().player;
	if(isPlayerHoldingSheath(player)){
		ItemStack sheath = getHeldItemSheath(player);
		((ItemSheath)sheath.getItem()).sheath_In(player);
	}
	return null;
}
 

@Override
public IMessage onMessage(GuiPacket message, MessageContext ctx)
{
	EntityPlayerMP serverPlayer = ctx.getServerHandler().playerEntity;
	DimensionManager.getWorld(serverPlayer.worldObj.provider.getDimension()).addScheduledTask(new DoSync(ctx, message.guid, message.x, message.y, message.z));


	return null;
}
 

@Override
public IMessage onMessage(SurgeryRemovePacket message, MessageContext ctx)
{
	DimensionManager.getWorld(message.dimensionId).addScheduledTask(new DoSync(message.pos, message.dimensionId, message.slotNumber, message.isNull));

	return null;
}
 

@Override
public IMessage onMessage(PacketRequestUpdateAltar message, MessageContext ctx) {
	if (ctx.side == Side.SERVER) {
		World world = FMLCommonHandler.instance().getMinecraftServerInstance().getWorld(message.dimension);
		TileEntity tileEntity = world.getTileEntity(message.pos);
		if (tileEntity instanceof TileEntityAltar) {
			return new PacketUpdateAltar((TileEntityAltar) tileEntity);
		}
	} else {
		System.out.println("Bad packet (wrong side: CLIENT)!");
	}
	return null;
}
 

@Override
public IMessage onMessage(EngineeringDestroyPacket message, MessageContext ctx)
{
	DimensionManager.getWorld(message.dimensionId).addScheduledTask(new DoSync(message.pos, message.dimensionId));

	return null;
}
 

@Override
public IMessage onMessage(SquashEntityMessage message, MessageContext ctx) {
    Minecraft.getMinecraft().addScheduledTask(() -> {
        WorldClient world = Minecraft.getMinecraft().world;
        Entity entity = world.getEntityByID(message.entityId);
        if (entity == null) return;

        Squashable squashable = entity.getCapability(SquashableMod.squashableCap(), null);
        if (squashable != null) {
            squashable.squash(message.axis);
        }
    });

    return null;
}
 

@Override
public IMessage onMessage(MessageStopPiloting message, MessageContext ctx) {
    IThreadListener mainThread = Minecraft.getMinecraft();
    mainThread.addScheduledTask(() -> {
        IShipPilotClient pilot = (IShipPilotClient) Minecraft.getMinecraft().player;

        BlockPos posToStopPiloting = message.posToStopPiloting;

        if (pilot.getPosBeingControlled() != null && pilot.getPosBeingControlled()
            .equals(posToStopPiloting)) {
            pilot.stopPilotingEverything();
        }
    });
    return null;
}
 

@Override
public IMessage onMessage(SyncHotkeyPacket message, MessageContext ctx)
{
	EntityPlayerMP player = ctx.getServerHandler().playerEntity;
	DimensionManager.getWorld(player.worldObj.provider.getDimension()).addScheduledTask(new DoSync(message.selectedPart, message.key, player));

	return null;
}
 

@Override
public IMessage onMessage(final SubspacedEntityRecordMessage message,
    final MessageContext ctx) {
    IThreadListener threadScheduler = null;
    World world = null;
    if (ctx.side.isClient()) {
        // We are receiving this on the client
        threadScheduler = getClientThreadListener();
        world = getClientWorld();
    } else {
        // Otherwise we are receiving this on the server
        threadScheduler = ctx.getServerHandler().server;
        world = ctx.getServerHandler().player.world;
    }
    final World worldFinal = world;
    threadScheduler.addScheduledTask(() -> {
        Entity physicsEntity = worldFinal.getEntityByID(message.physicsObjectWrapperID);
        Entity subspacedEntity = worldFinal.getEntityByID(message.entitySubspacedID);
        if (physicsEntity != null && subspacedEntity != null) {
            PhysicsWrapperEntity wrapperEntity = (PhysicsWrapperEntity) physicsEntity;
            ISubspacedEntityRecord record = message.createRecordForThisMessage(
                (ISubspacedEntity) subspacedEntity, wrapperEntity.getPhysicsObject()
                    .getSubspace());
            IDraggable draggable = (IDraggable) subspacedEntity;
            draggable.setForcedRelativeSubspace(wrapperEntity);
            wrapperEntity.getPhysicsObject().getSubspace()
                .forceSubspaceRecord(record.getParentEntity(), record);
            // Now just synchronize the player to the data sent by the client.
        } else {
            System.err.println("An incorrect SubspacedEntityRecordMessage has been thrown out");
        }
    });
    return null;
}
 

private void handle(PacketToggleMode message, MessageContext ctx) {
    EntityPlayerMP playerEntity = ctx.getServerHandler().player;
    ItemStack heldItem = playerEntity.getHeldItem(EnumHand.MAIN_HAND);
    if (!heldItem.isEmpty() && heldItem.getItem() instanceof ItemWand) {
        ItemWand wand = (ItemWand) (heldItem.getItem());
        wand.toggleMode(playerEntity, heldItem);
    }
}
 

@Override
protected void onMessageSynchronized(final MessageBookCodeData message, final MessageContext context) {
  final EntityPlayer player = context.getServerHandler().player;
  if (player != null) {
    final ItemStack stack = player.getHeldItem(EnumHand.MAIN_HAND);
    if (ItemBookCode.isBookCode(stack)) {
      final ItemBookCode.Data data = ItemBookCode.Data.loadFromNBT(message.getNbt());
      ItemBookCode.Data.saveToStack(stack, data);
    }
  }
}
 

@Override
public IMessage onMessage(final MessageProcessorAction message, MessageContext ctx) {
  if (message.action == null) {
    return null;
  }
  final EntityPlayerMP payer = ctx.getServerHandler().player;
  payer.getServerWorld().addScheduledTask(new Worker(payer, message));
  return null;
}
 

@Override
public IMessage onMessage(final MessageEnableGuiUpdates message, MessageContext ctx) {
  if (message.pos == null) {
    return null;
  }
  final EntityPlayerMP payer = ctx.getServerHandler().player;
  payer.getServerWorld().addScheduledTask(new Worker(payer, message));
  return null;
}
 

@Override
@Nullable
public IMessage onMessage(final T message, final MessageContext context) {
  final IThreadListener thread = FMLCommonHandler.instance().getWorldThread(context.netHandler);
  if (thread.isCallingFromMinecraftThread()) {
    onMessageSynchronized(message, context);
  } else {
    thread.addScheduledTask(() -> onMessageSynchronized(message, context));
  }
  return null;
}
 

@Nullable
protected static World getWorld(final int dimension, final MessageContext context) {
  switch (context.side) {
    case CLIENT:
      return getWorldClient(dimension);
    case SERVER:
      return getWorldServer(dimension);
  }
  return null;
}
 

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

  if (message.processorData == null || message.processorData == null) {
    return null;
  }

  IThreadListener mainThread = Minecraft.getMinecraft();

  mainThread.addScheduledTask(new Runnable() {
    @Override
    public void run() {
      if (GuiMinecoprocessor.INSTANCE == null) {
        return;
      }

      if (!GuiMinecoprocessor.INSTANCE.getPos().equals(message.pos)) {
        Minecoprocessors.NETWORK.sendToServer(new MessageEnableGuiUpdates(message.pos, false));
        return;
      }

      GuiMinecoprocessor.INSTANCE.updateData(message.processorData, message.name);
    }
  });

  return null;
}