Thread: All 377 Server > Client Packets

Good Job.

Some things for Hyperion:

Spoiler for Code:

ActionSender:

Code:

package org.hyperion.rs2.net;

import org.hyperion.rs2.Constants;
import org.hyperion.rs2.model.Item;
import org.hyperion.rs2.model.Palette;
import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.model.Skills;
import org.hyperion.rs2.model.Palette.PaletteTile;
import org.hyperion.rs2.model.container.Equipment;
import org.hyperion.rs2.model.container.Inventory;
import org.hyperion.rs2.model.container.impl.EquipmentContainerListener;
import org.hyperion.rs2.model.container.impl.InterfaceContainerListener;
import org.hyperion.rs2.model.container.impl.WeaponContainerListener;
import org.hyperion.rs2.net.Packet.Type;

/**
 * A utility class for sending packets.
 * 
 * @author Graham Edgecombe
 * 
 */
public class ActionSender {

	/**
	 * The player.
	 */
	private Player player;

	/**
	 * Creates an action sender for the specified player.
	 * 
	 * @param player
	 *            The player to create the action sender for.
	 */
	public ActionSender(Player player) {
		this.player = player;
	}

	/**
	 * Sends an inventory interface.
	 * 
	 * @param interfaceId
	 *            The interface id.
	 * @param inventoryInterfaceId
	 *            The inventory interface id.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendInterfaceInventory(int interfaceId,
			int inventoryInterfaceId) {
		player.getInterfaceState().interfaceOpened(interfaceId);
		player.write(new PacketBuilder(128).putShortA(interfaceId).putLEShortA(
				inventoryInterfaceId).toPacket());
		return this;
	}

	public ActionSender resetCameraPosition() {
		player.write(new PacketBuilder(148).toPacket());
		return this;
	}

	public ActionSender resetButtons() {
		player.write(new PacketBuilder(113).toPacket());
		return this;
	}

	public ActionSender resetItems(int interfaceId) {
		player.write(new PacketBuilder(219).putLEInt(interfaceId).toPacket());
		return this;
	}

	public ActionSender sendConfig(int id, int value) {
		if (value > 254) {
			player.write(new PacketBuilder(115).putInt2(value).putLEShort(id)
					.toPacket());
		} else {
			player.write(new PacketBuilder(182).putShortA(id)
					.putByteS((byte) value).toPacket());
		}
		return this;
	}

	public ActionSender sendInterface(int interfaceId) {
		player
				.write(new PacketBuilder(159).putLEShortA(interfaceId)
						.toPacket());
		return this;
	}

	public ActionSender sendClearScreen() {
		player
				.write(new PacketBuilder(29).toPacket());
		return this;
	}

	public ActionSender sendChatInterface(int interfaceId) {
		player
				.write(new PacketBuilder(109).putShort(interfaceId)
						.toPacket());
		return this;
	}

	public ActionSender sendInterfaceConfig(int interfaceId, boolean active) {
		player.write(new PacketBuilder(82).put((byte) (active ? 0 : 1))
				.putShort(interfaceId).toPacket());
		return this;
	}

	public ActionSender sendInterfaceAnimation(int interfaceId, int animation) {
		player.write(new PacketBuilder(2).putLEShort(interfaceId)
				.putShort(animation).toPacket());
		return this;
	}

	public ActionSender sendPlayerHead(int id) {
		player.write(new PacketBuilder(255).putLEShortA(id).toPacket());
		return this;
	}

	/**
	 * Sends all the login packets.
	 * 
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendLogin() {
		player.setActive(true);

		resetCameraPosition();
		resetButtons();

		sendWelcomeScreen();

		sendDetails();
		sendMessage("Welcome to RuneScape.");

		sendMapRegion();
		sendSidebarInterfaces();
		sendSkills();
		// player.write(new PacketBuilder(251).put((byte)2).toPacket());

		InterfaceContainerListener inventoryListener = new InterfaceContainerListener(
				player, Inventory.INTERFACE);
		player.getInventory().addListener(inventoryListener);

		InterfaceContainerListener equipmentListener = new InterfaceContainerListener(
				player, Equipment.INTERFACE);
		player.getEquipment().addListener(equipmentListener);
		player.getEquipment().addListener(
				new EquipmentContainerListener(player));
		player.getEquipment().addListener(new WeaponContainerListener(player));

		sendInterfaceConfig(12323, true);
		sendConfig(300, 857);
		sendConfig(301, 1);

		sendInteractionOption("Attack", 1, false);
		// player.write(new
		// PacketBuilder(82).put((byte)0).putShort(12323).toPacket());

		// for (int i = 12325; i <= 12334; i ++) {
		// player.write(new
		// PacketBuilder(166).putLEShort(500).putLEShort(0).putShort(i).toPacket());
		// }

		return this;
	}

	public ActionSender sendWelcomeScreen() {
		PacketBuilder packet = new PacketBuilder(76);
		packet.putLEShort(0); // Days ago requested recovery question changes.
		packet.putLEShortA(0);
		packet.putShort(0);
		packet.putShort(0);
		packet.putLEShort(0);
		packet.putShortA(0); // Unread messages.
		packet.putShortA(0);
		packet.putShort(30); // Days of membership credit remaining.
		packet.putLEInt(0); // Last IP.
		packet.putLEShort(0);
		packet.putByteS((byte) 1); // Membership
		sendFullScreenInterface(15244, 5993);
		player.write(packet.toPacket());
		return this;
	}

	public ActionSender sendFullScreenInterface(int interfaceID,
			int bgInterfaceID) {
		player.write(new PacketBuilder(253).putLEShort(bgInterfaceID)
				.putShortA(interfaceID).toPacket());
		return this;
	}

	/**
	 * Sends the packet to construct a map region.
	 * 
	 * @param palette
	 *            The palette of map regions.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendConstructMapRegion(Palette palette) {
		player.setLastKnownRegion(player.getLocation());
		PacketBuilder bldr = new PacketBuilder(53, Type.VARIABLE_SHORT);
		bldr.putShortA(player.getLocation().getRegionX() + 6);
		bldr.startBitAccess();
		for (int z = 0; z < 4; z++) {
			for (int x = 0; x < 13; x++) {
				for (int y = 0; y < 13; y++) {
					PaletteTile tile = palette.getTile(x, y, z);
					bldr.putBits(1, tile != null ? 1 : 0);
					if (tile != null) {
						bldr.putBits(26, tile.getX() << 14 | tile.getY() << 3
								| tile.getZ() << 24 | tile.getRotation() << 1);
					}
				}
			}
		}
		bldr.finishBitAccess();
		bldr.putShort(player.getLocation().getRegionY() + 6);
		player.write(bldr.toPacket());
		return this;
	}

	/**
	 * Sends the initial login packet (e.g. members, player id).
	 * 
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendDetails() {
		// player.write(new PacketBuilder(249).putByteA(player.isMembers() ? 1 :
		// 0).putLEShortA(player.getIndex()).toPacket());
		// player.write(new PacketBuilder(107).toPacket());
		return this;
	}

	/**
	 * Sends the player's skills.
	 * 
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendSkills() {
		for (int i = 0; i < Skills.SKILL_COUNT; i++) {
			sendSkill(i);
		}
		return this;
	}

	/**
	 * Sends a specific skill.
	 * 
	 * @param skill
	 *            The skill to send.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendSkill(int skill) {
		PacketBuilder bldr = new PacketBuilder(49);
		bldr.putByteC((byte) skill);
		bldr.put((byte) player.getSkills().getLevel(skill));
		bldr.putInt((int) player.getSkills().getExperience(skill));
		player.write(bldr.toPacket());
		return this;
	}

	/**
	 * Sends all the sidebar interfaces.
	 * 
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendSidebarInterfaces() {
		final int[] icons = Constants.SIDEBAR_INTERFACES[0];
		final int[] interfaces = Constants.SIDEBAR_INTERFACES[1];
		for (int i = 0; i < icons.length; i++) {
			sendSidebarInterface(icons[i], interfaces[i]);
		}
		return this;
	}

	/**
	 * Sends a specific sidebar interface.
	 * 
	 * @param icon
	 *            The sidebar icon.
	 * @param interfaceId
	 *            The interface id.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendSidebarInterface(int icon, int interfaceId) {
		player.write(new PacketBuilder(10).putByteS((byte) icon).putShortA(
				interfaceId).toPacket());
		return this;
	}

	/**
	 * Sends a message.
	 * 
	 * @param message
	 *            The message to send.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendMessage(String message) {
		player.write(new PacketBuilder(63, Type.VARIABLE).putRS2String(message)
				.toPacket());
		return this;
	}

	/**
	 * Sends the map region load command.
	 * 
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendMapRegion() {
		player.setLastKnownRegion(player.getLocation());
		player.write(new PacketBuilder(222).putShort(
				player.getLocation().getRegionY() + 6).putLEShortA(
				player.getLocation().getRegionX() + 6).toPacket());
		return this;
	}

	/**
	 * Sends the logout packet.
	 * 
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendLogout() {
		player.write(new PacketBuilder(5).toPacket()); // TODO IoFuture
		return this;
	}

	/**
	 * Sends a packet to update a group of items.
	 * 
	 * @param interfaceId
	 *            The interface id.
	 * @param items
	 *            The items.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendUpdateItems(int interfaceId, Item[] items) {
		PacketBuilder bldr = new PacketBuilder(206, Type.VARIABLE_SHORT);
		bldr.putShort(interfaceId);
		bldr.putShort(items.length);
		for (Item item : items) {
			if (item != null) {
				bldr.putLEShortA(item.getId() + 1);
				int count = item.getCount();
				if (count > 254) {
					bldr.putByteC((byte) 255);
					bldr.putLEInt(count);
				} else {
					bldr.putByteC((byte) count);
				}
			} else {
				bldr.putLEShortA(0);
				bldr.putByteC((byte) 0);
			}
		}
		player.write(bldr.toPacket());
		return this;
	}

	/**
	 * Sends a packet to update a single item.
	 * 
	 * @param interfaceId
	 *            The interface id.
	 * @param slot
	 *            The slot.
	 * @param item
	 *            The item.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendUpdateItem(int interfaceId, int slot, Item item) {
		PacketBuilder bldr = new PacketBuilder(134, Type.VARIABLE_SHORT);
		bldr.putShort(interfaceId).putSmart(slot);
		if (item != null) {
			bldr.putShort(item.getId() + 1);
			int count = item.getCount();
			if (count > 254) {
				bldr.put((byte) 255);
				bldr.putInt(count);
			} else {
				bldr.put((byte) count);
			}
		} else {
			bldr.putShort(0);
			bldr.put((byte) 0);
		}
		player.write(bldr.toPacket());
		return this;
	}

	/**
	 * Sends a packet to update multiple (but not all) items.
	 * 
	 * @param interfaceId
	 *            The interface id.
	 * @param slots
	 *            The slots.
	 * @param items
	 *            The item array.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendUpdateItems(int interfaceId, int[] slots,
			Item[] items) {
		PacketBuilder bldr = new PacketBuilder(134, Type.VARIABLE_SHORT)
				.putShort(interfaceId);
		for (int slot : slots) {
			Item item = items[slot];
			bldr.putSmart(slot);
			if (item != null) {
				bldr.putShort(item.getId() + 1);
				int count = item.getCount();
				if (count > 254) {
					bldr.put((byte) 255);
					bldr.putInt(count);
				} else {
					bldr.put((byte) count);
				}
			} else {
				bldr.putShort(0);
				bldr.put((byte) 0);
			}
		}
		player.write(bldr.toPacket());
		return this;
	}

	/**
	 * Sends the enter amount interface.
	 * 
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendEnterAmountInterface() {
		player.write(new PacketBuilder(58).toPacket());
		return this;
	}

	/**
	 * Sends the player an option.
	 * 
	 * @param slot
	 *            The slot to place the option in the menu.
	 * @param top
	 *            Flag which indicates the item should be placed at the top.
	 * @param option
	 *            Option string which is the actual text.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendInteractionOption(String option, int slot,
			boolean top) {
		PacketBuilder bldr = new PacketBuilder(157, Type.VARIABLE);
		bldr.putByteC((byte) slot);
		bldr.putRS2String(option);
		bldr.put(top ? (byte) 0 : (byte) 1);
		player.write(bldr.toPacket());
		return this;
	}

	/**
	 * Sends a string.
	 * 
	 * @param id
	 *            The interface id.
	 * @param string
	 *            The string.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendString(int id, String string) {
		PacketBuilder bldr = new PacketBuilder(232, Type.VARIABLE_SHORT);
		bldr.putLEShortA(id);
		bldr.putRS2String(string);
		player.write(bldr.toPacket());
		return this;
	}

	/**
	 * Sends a model in an interface.
	 * 
	 * @param id
	 *            The interface id.
	 * @param zoom
	 *            The zoom.
	 * @param model
	 *            The model id.
	 * @return The action sender instance, for chaining.
	 */
	public ActionSender sendInterfaceModel(int id, int zoom, int model) {
		PacketBuilder bldr = new PacketBuilder(21);
		bldr.putShort(zoom).putLEShort(model).putLEShortA(id);
		player.write(bldr.toPacket());
		return this;
	}
}

Packets:

WieldPacketHandler:

Code:

package org.hyperion.rs2.packet;

import org.hyperion.rs2.model.Item;
import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.model.container.Equipment;
import org.hyperion.rs2.model.container.Inventory;
import org.hyperion.rs2.model.container.Equipment.EquipmentType;
import org.hyperion.rs2.net.Packet;

/**
 * Handles the 'wield' option on items.
 * 
 * @author Graham Edgecombe
 * 
 */
public class WieldPacketHandler implements PacketHandler {

	public void handle(Player player, Packet packet) {
		int interfaceId = packet.getLEShort() & 0xFFFF;
		int id = packet.getLEShort() & 0xFFFF;
		int slot = packet.getShortA() & 0xFFFF;
		switch (interfaceId) {
		case Inventory.INTERFACE:
			if (slot >= 0 && slot < Inventory.SIZE) {
				Item item = player.getInventory().get(slot);
				if (item != null && item.getId() == id) {
					EquipmentType type = Equipment.getType(item);
					Item oldEquip = null;
					boolean stackable = item.getDefinition().isStackable();
					if (player.getEquipment().isSlotUsed(type.getSlot())
							&& !stackable) {
						oldEquip = player.getEquipment().get(type.getSlot());
						player.getEquipment().set(type.getSlot(), null);
					}
					player.getInventory().set(slot, null);
					if (oldEquip != null) {
						player.getInventory().add(oldEquip);
					}
					if (!stackable) {
						player.getEquipment().set(type.getSlot(), item);
					} else {
						player.getEquipment().add(item);
					}
				}
			}
			break;
		}
	}

}

WalkingPacketHandler:

Code:

package org.hyperion.rs2.packet;

import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.net.Packet;

/**
 * A packet which handles walking requests.
 * 
 * @author Graham Edgecombe
 * 
 */
public class WalkingPacketHandler implements PacketHandler {

	public void handle(Player player, Packet packet) {
		int size = packet.getLength();
		if (packet.getOpcode() == 213) {
			size -= 14;
		}
	
		player.getActionSender().sendClearScreen();
		player.getWalkingQueue().reset();
		player.getActionQueue().clearNonWalkableActions();
		player.resetInteractingEntity();

		final int steps = (size - 5) / 2;
		final int[][] path = new int[steps][2];

		final int firstX = packet.getLEShortA();
		final boolean runSteps = packet.getByte() == 1;
		final int firstY = packet.getLEShortA();

		for (int i = 0; i < steps; i++) {
			path[i][0] = packet.getByte();
			path[i][1] = packet.getByteS();
		}

		player.getWalkingQueue().setRunningQueue(runSteps);
		player.getWalkingQueue().addStep(firstX, firstY);

		for (int i = 0; i < steps; i++) {
			path[i][0] += firstX;
			path[i][1] += firstY;
			player.getWalkingQueue().addStep(path[i][0], path[i][1]);
		}
		player.getWalkingQueue().finish();
	}

}

SwitchItemPacketHandler:

Code:

package org.hyperion.rs2.packet;

import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.model.container.Bank;
import org.hyperion.rs2.model.container.Inventory;
import org.hyperion.rs2.net.Packet;

/**
 * Switch item packet handler.
 * 
 * @author Graham Edgecombe
 * 
 */
public class SwitchItemPacketHandler implements PacketHandler {

	@Override
	public void handle(Player player, Packet packet) {
		int interfaceId = packet.getLEShortA();
		packet.getByteC();
		int fromSlot = packet.getLEShortA();
		int toSlot = packet.getLEShort();

		switch (interfaceId) {
		case Bank.PLAYER_INVENTORY_INTERFACE:
		case Inventory.INTERFACE:
			if (fromSlot >= 0 && fromSlot < Inventory.SIZE && toSlot >= 0
					&& toSlot < Inventory.SIZE && toSlot != fromSlot) {
				player.getInventory().swap(fromSlot, toSlot);
			}
			break;
		case Bank.BANK_INVENTORY_INTERFACE:
			if (fromSlot >= 0 && fromSlot < Bank.SIZE && toSlot >= 0
					&& toSlot < Bank.SIZE && toSlot != fromSlot) {
				if (player.getSettings().isSwapping()) {
					player.getBank().swap(fromSlot, toSlot);
				} else {
					player.getBank().insert(fromSlot, toSlot);
				}
			}
			break;
		}
	}

}

PlayerOptionPacketHandler:

Code:

package org.hyperion.rs2.packet;

import org.hyperion.rs2.Constants;
import org.hyperion.rs2.action.impl.AttackAction;
import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.model.World;
import org.hyperion.rs2.net.Packet;

public class PlayerOptionPacketHandler implements PacketHandler {

	@Override
	public void handle(Player player, Packet packet) {
		switch (packet.getOpcode()) {
		case 245:
			/*
			 * Option 1.
			 */
			option1(player, packet);
			break;
		case 37:
			/*
			 * Option 2.
			 */
			option2(player, packet);
			break;
		case 227:
			/*
			 * Option 3.
			 */
			option3(player, packet);
			break;
		}
	}

	/**
	 * Handles the first option on a player option menu.
	 * 
	 * @param player
	 * @param packet
	 */
	private void option1(final Player player, Packet packet) {
		int id = packet.getLEShortA() & 0xFFFF;
		System.out.println(id);
		if (id < 0 || id >= Constants.MAX_PLAYERS) {
			return;
		}
		Player victim = (Player) World.getWorld().getPlayers().get(id);
		if (victim != null
				&& player.getLocation().isWithinInteractionDistance(
						victim.getLocation())) {
			player.getActionQueue().addAction(new AttackAction(player, victim));
		}
	}

	/**
	 * Handles the second option on a player option menu.
	 * 
	 * @param player
	 * @param packet
	 */
	private void option2(Player player, Packet packet) {
		int id = packet.getShort() & 0xFFFF;
		if (id < 0 || id >= Constants.MAX_PLAYERS) {
			return;
		}
	}

	/**
	 * Handles the third option on a player option menu.
	 * 
	 * @param player
	 * @param packet
	 */
	private void option3(Player player, Packet packet) {
		int id = packet.getLEShortA() & 0xFFFF;
		if (id < 0 || id >= Constants.MAX_PLAYERS) {
			return;
		}
	}

}

ObjectOptionPacketHandler:

Code:

package org.hyperion.rs2.packet;

import org.hyperion.rs2.model.Location;
import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.net.Packet;

/**
 * Object option packet handler.
 * 
 * @author Graham Edgecombe
 * 
 */
public class ObjectOptionPacketHandler implements PacketHandler {

	/**
	 * Option 1 opcode.
	 */
	private static final int OPTION_1 = 181, OPTION_2 = 241, OPTION_3 = 50;

	@Override
	public void handle(Player player, Packet packet) {
		switch (packet.getOpcode()) {
		case OPTION_1:
			handleOption1(player, packet);
			break;
		case OPTION_2:
			handleOption2(player, packet);
			break;
		case OPTION_3:
			handleOption3(player, packet);
			break;
		}
	}

	/**
	 * Handles the option 1 packet.
	 * 
	 * @param player
	 *            The player.
	 * @param packet
	 *            The packet.
	 */
	private void handleOption1(Player player, Packet packet) {
		int x = packet.getShortA() & 0xFFFF;
		int y = packet.getLEShort() & 0xFFFF;
		int id = packet.getLEShort() & 0xFFFF;
		Location loc = Location.create(x, y, player.getLocation().getZ());
		player.getActionSender().sendMessage("" + loc + " id: " + id);
	}

	/**
	 * Handles the option 2 packet.
	 * 
	 * @param player
	 *            The player.
	 * @param packet
	 *            The packet.
	 */
	private void handleOption2(Player player, Packet packet) {
		int id = packet.getShortA() & 0xFFFF;
		int x = packet.getShort() & 0xFFFF;
		int y = packet.getShortA() & 0xFFFF;
		Location loc = Location.create(x, y, player.getLocation().getZ());
		player.getActionSender().sendMessage("" + loc + " id: " + id);
	}

	/**
	 * Handles the option 3 packet.
	 * 
	 * @param player
	 *            The player.
	 * @param packet
	 *            The packet.
	 */
	private void handleOption3(Player player, Packet packet) {
		int y = packet.getShortA() & 0xFFFF;
		int id = packet.getLEShort() & 0xFFFF;
		int x = packet.getLEShortA() & 0xFFFF;
		Location loc = Location.create(x, y, player.getLocation().getZ());
		player.getActionSender().sendMessage("" + loc + " id: " + id);
	}
}

ItemOptionPacketHandler:

Code:

package org.hyperion.rs2.packet;

import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.model.container.Bank;
import org.hyperion.rs2.model.container.Container;
import org.hyperion.rs2.model.container.Equipment;
import org.hyperion.rs2.model.container.Inventory;
import org.hyperion.rs2.net.Packet;

/**
 * Remove item options.
 * 
 * @author Graham Edgecombe
 * 
 */
public class ItemOptionPacketHandler implements PacketHandler {

	/**
	 * Option 1 opcode.
	 */
	private static final int OPTION_1 = 3;

	/**
	 * Option 2 opcode.
	 */
	private static final int OPTION_2 = 177;

	/**
	 * Option 3 opcode.
	 */
	private static final int OPTION_3 = 91;

	/**
	 * Option 4 opcode.
	 */
	private static final int OPTION_4 = 231;

	/**
	 * Option 5 opcode.
	 */
	private static final int OPTION_5 = 158;

	public void handle(Player player, Packet packet) {
		switch (packet.getOpcode()) {
		case OPTION_1:
			handleItemOption1(player, packet);
			break;
		case OPTION_2:
			handleItemOption2(player, packet);
			break;
		case OPTION_3:
			handleItemOption3(player, packet);
			break;
		case OPTION_4:
			handleItemOption4(player, packet);
			break;
		case OPTION_5:
			handleItemOption5(player, packet);
			break;
		}
	}

	/**
	 * Handles item option 1.
	 * 
	 * @param player
	 *            The player.
	 * @param packet
	 *            The packet.
	 */
	private void handleItemOption1(Player player, Packet packet) {
		int id = packet.getShortA() & 0xFFFF;
		int interfaceId = packet.getShort() & 0xFFFF;
		int slot = packet.getShort() & 0xFFFF;

		switch (interfaceId) {
		case Equipment.INTERFACE:
			if (slot >= 0 && slot < Equipment.SIZE) {
				if (!Container.transfer(player.getEquipment(), player
						.getInventory(), slot, id)) {
					// indicate it failed
				}
			}
			break;
		case Bank.PLAYER_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Inventory.SIZE) {
				Bank.deposit(player, slot, id, 1);
			}
			break;
		case Bank.BANK_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Bank.SIZE) {
				Bank.withdraw(player, slot, id, 1);
			}
			break;
		}
	}

	/**
	 * Handles item option 2.
	 * 
	 * @param player
	 *            The player.
	 * @param packet
	 *            The packet.
	 */
	private void handleItemOption2(Player player, Packet packet) {
		int slot = packet.getShortA() & 0xFFFF;
		int id = packet.getLEShort() & 0xFFFF;
		int interfaceId = packet.getLEShort() & 0xFFFF;

		switch (interfaceId) {
		case Bank.PLAYER_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Inventory.SIZE) {
				Bank.deposit(player, slot, id, 5);
			}
			break;
		case Bank.BANK_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Bank.SIZE) {
				Bank.withdraw(player, slot, id, 5);
			}
			break;
		}
	}

	/**
	 * Handles item option 3.
	 * 
	 * @param player
	 *            The player.
	 * @param packet
	 *            The packet.
	 */
	private void handleItemOption3(Player player, Packet packet) {
		int id = packet.getLEShort() & 0xFFFF;
		int slot = packet.getLEShortA() & 0xFFFF;
		int interfaceId = packet.getShort() & 0xFFFF;

		switch (interfaceId) {
		case Bank.PLAYER_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Inventory.SIZE) {
				Bank.deposit(player, slot, id, 10);
			}
			break;
		case Bank.BANK_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Bank.SIZE) {
				Bank.withdraw(player, slot, id, 10);
			}
			break;
		}
	}

	/**
	 * Handles item option 4.
	 * 
	 * @param player
	 *            The player.
	 * @param packet
	 *            The packet.
	 */
	private void handleItemOption4(Player player, Packet packet) {
		int interfaceId = packet.getLEShortA() & 0xFFFF;
		int slot = packet.getLEShort() & 0xFFFF;
		int id = packet.getShort() & 0xFFFF;

		switch (interfaceId) {
		case Bank.PLAYER_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Inventory.SIZE) {
				Bank.deposit(player, slot, id, player.getInventory().getCount(
						id));
			}
			break;
		case Bank.BANK_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Bank.SIZE) {
				Bank.withdraw(player, slot, id, player.getBank().getCount(id));
			}
			break;
		}
	}

	/**
	 * Handles item option 5.
	 * 
	 * @param player
	 *            The player.
	 * @param packet
	 *            The packet.
	 */
	private void handleItemOption5(Player player, Packet packet) {
		int slot = packet.getLEShortA() & 0xFFFF;
		int id = packet.getLEShortA() & 0xFFFF;
		int interfaceId = packet.getLEShort() & 0xFFFF;

		switch (interfaceId) {
		case Bank.PLAYER_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Inventory.SIZE) {
				player.getInterfaceState().openEnterAmountInterface(
						interfaceId, slot, id);
			}
			break;
		case Bank.BANK_INVENTORY_INTERFACE:
			if (slot >= 0 && slot < Bank.SIZE) {
				player.getInterfaceState().openEnterAmountInterface(
						interfaceId, slot, id);
			}
			break;
		}
	}

}

EnterAmountPacketHandler:

Code:

package org.hyperion.rs2.packet;

import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.net.Packet;

/**
 * A packet sent when the player enters a custom amount for banking etc.
 * 
 * @author Graham Edgecombe
 * 
 */
public class EnterAmountPacketHandler implements PacketHandler {

	@Override
	public void handle(Player player, Packet packet) {
		int amount = packet.getInt();
		if (player.getInterfaceState().isEnterAmountInterfaceOpen()) {
			player.getInterfaceState().closeEnterAmountInterface(amount);
		}
	}

}

ChatPacketHandler:

Code:

package org.hyperion.rs2.packet;

import org.hyperion.rs2.model.ChatMessage;
import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.net.Packet;
import org.hyperion.rs2.util.TextUtils;

/**
 * Handles public chat messages.
 * 
 * @author Graham Edgecombe
 * 
 */
public class ChatPacketHandler implements PacketHandler {

	private static final int CHAT_QUEUE_SIZE = 4;

	public void handle(Player player, Packet packet) {
		int effects = packet.getByteC() & 0xFF;
		int colour = packet.getByteA() & 0xFF;
		int size = packet.getLength() - 2;
		byte[] rawChatData = new byte[size];
		packet.get(rawChatData);
		if (player.getChatMessageQueue().size() >= CHAT_QUEUE_SIZE) {
			return;
		}
		String unpacked = TextUtils.textUnpack(rawChatData, size);
		unpacked = TextUtils.filterText(unpacked);
		unpacked = TextUtils.optimizeText(unpacked);
		byte[] packed = new byte[size];
		TextUtils.textPack(packed, unpacked);
		player.getChatMessageQueue().add(
				new ChatMessage(effects, colour, packed));
	}

}

Updating:

PlayerUpdateTask:

Code:

package org.hyperion.rs2.task.impl;

import java.util.Iterator;

import org.hyperion.rs2.GameEngine;
import org.hyperion.rs2.model.Appearance;
import org.hyperion.rs2.model.ChatMessage;
import org.hyperion.rs2.model.Entity;
import org.hyperion.rs2.model.Item;
import org.hyperion.rs2.model.Location;
import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.model.UpdateFlags;
import org.hyperion.rs2.model.World;
import org.hyperion.rs2.model.UpdateFlags.UpdateFlag;
import org.hyperion.rs2.model.container.Container;
import org.hyperion.rs2.model.container.Equipment;
import org.hyperion.rs2.model.container.Equipment.EquipmentType;
import org.hyperion.rs2.net.Packet;
import org.hyperion.rs2.net.PacketBuilder;
import org.hyperion.rs2.task.Task;

/**
 * A task which creates and sends the player update block.
 * 
 * @author Graham Edgecombe
 * 
 */
public class PlayerUpdateTask implements Task {

	/**
	 * The player.
	 */
	private Player player;

	/**
	 * Creates an update task.
	 * 
	 * @param player
	 *            The player.
	 */
	public PlayerUpdateTask(Player player) {
		this.player = player;
	}

	public void execute(GameEngine context) {
		/*
		 * If the map region changed send the new one. We do this immediately as
		 * the client can begin loading it before the actual packet is received.
		 */
		if (player.isMapRegionChanging()) {
			player.getActionSender().sendMapRegion();
		}

		/*
		 * The update block packet holds update blocks and is send after the
		 * main packet.
		 */
		PacketBuilder updateBlock = new PacketBuilder();

		/*
		 * The main packet is written in bits instead of bytes and holds
		 * information about the local list, players to add and remove, movement
		 * and which updates are required.
		 */
		PacketBuilder packet = new PacketBuilder(90, Packet.Type.VARIABLE_SHORT);
		packet.startBitAccess();

		/*
		 * Updates this player.
		 */
		updateThisPlayerMovement(packet);
		updatePlayer(updateBlock, player, false, true);

		/*
		 * Write the current size of the player list.
		 */
		packet.putBits(8, player.getLocalPlayers().size());

		/*
		 * Iterate through the local player list.
		 */
		for (Iterator<Player> it$ = player.getLocalPlayers().iterator(); it$
				.hasNext();) {
			/*
			 * Get the next player.
			 */
			Player otherPlayer = it$.next();

			/*
			 * If the player should still be in our list.
			 */
			if (World.getWorld().getPlayers().contains(otherPlayer)
					&& !otherPlayer.isTeleporting()
					&& otherPlayer.getLocation().isWithinDistance(
							player.getLocation())) {
				/*
				 * Update the movement.
				 */
				updatePlayerMovement(packet, otherPlayer);

				/*
				 * Check if an update is required, and if so, send the update.
				 */
				if (otherPlayer.getUpdateFlags().isUpdateRequired()) {
					updatePlayer(updateBlock, otherPlayer, false, false);
				}
			} else {
				/*
				 * Otherwise, remove the player from the list.
				 */
				it$.remove();

				/*
				 * Tell the client to remove the player from the list.
				 */
				packet.putBits(1, 1);
				packet.putBits(2, 3);
			}
		}

		/*
		 * Loop through every player.
		 */
		for (Player otherPlayer : World.getWorld().getRegionManager()
				.getLocalPlayers(player)) {
			/*
			 * Check if there is room left in the local list.
			 */
			if (player.getLocalPlayers().size() >= 255) {
				/*
				 * There is no more room left in the local list. We cannot add
				 * more players, so we just ignore the extra ones. They will be
				 * added as other players get removed.
				 */
				break;
			}

			/*
			 * If they should not be added ignore them.
			 */
			if (otherPlayer == player
					|| player.getLocalPlayers().contains(otherPlayer)) {
				continue;
			}

			/*
			 * Add the player to the local list if it is within distance.
			 */
			player.getLocalPlayers().add(otherPlayer);

			/*
			 * Add the player in the packet.
			 */
			addNewPlayer(packet, otherPlayer);

			/*
			 * Update the player, forcing the appearance flag.
			 */
			updatePlayer(updateBlock, otherPlayer, true, false);
		}

		/*
		 * Check if the update block is not empty.
		 */
		if (!updateBlock.isEmpty()) {
			/*
			 * Write a magic id indicating an update block follows.
			 */
			packet.putBits(11, 2047);
			packet.finishBitAccess();

			/*
			 * Add the update block at the end of this packet.
			 */
			packet.put(updateBlock.toPacket().getPayload());
		} else {
			/*
			 * Terminate the packet normally.
			 */
			packet.finishBitAccess();
		}

		/*
		 * Write the packet.
		 */
		player.write(packet.toPacket());
	}

	/**
	 * Updates a non-this player's movement.
	 * 
	 * @param packet
	 *            The packet.
	 * @param otherPlayer
	 *            The player.
	 */
	public void updatePlayerMovement(PacketBuilder packet, Player otherPlayer) {
		/*
		 * Check which type of movement took place.
		 */
		if (otherPlayer.getSprites().getPrimarySprite() == -1) {
			/*
			 * If no movement did, check if an update is required.
			 */
			if (otherPlayer.getUpdateFlags().isUpdateRequired()) {
				/*
				 * Signify that an update happened.
				 */
				packet.putBits(1, 1);

				/*
				 * Signify that there was no movement.
				 */
				packet.putBits(2, 0);
			} else {
				/*
				 * Signify that nothing changed.
				 */
				packet.putBits(1, 0);
			}
		} else if (otherPlayer.getSprites().getSecondarySprite() == -1) {
			/*
			 * The player moved but didn't run. Signify that an update is
			 * required.
			 */
			packet.putBits(1, 1);

			/*
			 * Signify we moved one tile.
			 */
			packet.putBits(2, 1);

			/*
			 * Write the primary sprite (i.e. walk direction).
			 */
			packet.putBits(3, otherPlayer.getSprites().getPrimarySprite());

			/*
			 * Write a flag indicating if a block update happened.
			 */
			packet.putBits(1,
					otherPlayer.getUpdateFlags().isUpdateRequired() ? 1 : 0);
		} else {
			/*
			 * The player ran. Signify that an update happened.
			 */
			packet.putBits(1, 1);

			/*
			 * Signify that we moved two tiles.
			 */
			packet.putBits(2, 2);

			/*
			 * Write the primary sprite (i.e. walk direction).
			 */
			packet.putBits(3, otherPlayer.getSprites().getPrimarySprite());

			/*
			 * Write the secondary sprite (i.e. run direction).
			 */
			packet.putBits(3, otherPlayer.getSprites().getSecondarySprite());

			/*
			 * Write a flag indicating if a block update happened.
			 */
			packet.putBits(1,
					otherPlayer.getUpdateFlags().isUpdateRequired() ? 1 : 0);
		}
	}

	/**
	 * Adds a new player.
	 * 
	 * @param packet
	 *            The packet.
	 * @param otherPlayer
	 *            The player.
	 */
	public void addNewPlayer(PacketBuilder packet, Player otherPlayer) {
		/*
		 * Write the player index.
		 */
		packet.putBits(11, otherPlayer.getIndex());

		int yPos = otherPlayer.getLocation().getY()
				- player.getLocation().getY();
		int xPos = otherPlayer.getLocation().getX()
				- player.getLocation().getX();

		packet.putBits(5, xPos);

		/*
		 * Write two flags here: the first indicates an update is required (this
		 * is always true as we add the appearance after adding a player) and
		 * the second to indicate we should discard client-side walk queues.
		 */
		packet.putBits(1, 1);
		packet.putBits(1, 1);

		/*
		 * Write the x and y offsets.
		 */
		packet.putBits(5, yPos);
	}

	private static void appendHit2Update(final Player p,
			final PacketBuilder updateBlock) {
		updateBlock.put((byte) p.getDamage().getHitDamage2());
		updateBlock.putByteS((byte) p.getDamage().getHitType2());
		updateBlock.put((byte) p.getSkills().getLevel(3));
		updateBlock.putByteC(p.getSkills().getLevelForExperience(3));
	}

	private static void appendHitUpdate(final Player p,
			final PacketBuilder updateBlock) {
		updateBlock.put((byte) p.getDamage().getHitDamage1());
		updateBlock.putByteA(p.getDamage().getHitType1());
		updateBlock.putByteC(p.getSkills().getLevel(3));
		updateBlock.put((byte) p.getSkills().getLevelForExperience(3));
	}

	/**
	 * Updates a player.
	 * 
	 * @param packet
	 *            The packet.
	 * @param otherPlayer
	 *            The other player.
	 * @param forceAppearance
	 *            The force appearance flag.
	 * @param noChat
	 *            Indicates chat should not be relayed to this player.
	 */
	public void updatePlayer(PacketBuilder packet, Player otherPlayer,
			boolean forceAppearance, boolean noChat) {
		/*
		 * If no update is required and we don't have to force an appearance
		 * update, don't write anything.
		 */
		if (!otherPlayer.getUpdateFlags().isUpdateRequired()
				&& !forceAppearance) {
			return;
		}

		/*
		 * We can used the cached update block!
		 */
		synchronized (otherPlayer) {
			if (otherPlayer.hasCachedUpdateBlock() && otherPlayer != player
					&& !forceAppearance && !noChat) {
				packet.put(otherPlayer.getCachedUpdateBlock().getPayload()
						.flip());
				return;
			}

			/*
			 * We have to construct and cache our own block.
			 */
			PacketBuilder block = new PacketBuilder();

			/*
			 * Calculate the bitmask.
			 */
			int mask = 0;
			final UpdateFlags flags = otherPlayer.getUpdateFlags();

			// TODO mask 0x400
			if (flags.get(UpdateFlag.ANIMATION)) {
				mask |= 0x8;
			}
			if (flags.get(UpdateFlag.FORCED_CHAT)) {
				mask |= 0x10;
			}
			if (flags.get(UpdateFlag.FACE_ENTITY)) {
				mask |= 0x1;
			}
			if (flags.get(UpdateFlag.FACE_COORDINATE)) {
				mask |= 0x2;
			}
			if (flags.get(UpdateFlag.GRAPHICS)) {
				mask |= 0x200;
			}
			if (flags.get(UpdateFlag.APPEARANCE) || forceAppearance) {
				mask |= 0x4;
			}
			if (flags.get(UpdateFlag.CHAT) && !noChat) {
				mask |= 0x40;
			}
			if (flags.get(UpdateFlag.HIT)) {
				// mask |= 0x20;
			}
			if (flags.get(UpdateFlag.HIT_2)) {
				// mask |= 0x200;
			}

			/*
			 * Check if the bitmask would overflow a byte.
			 */
			if (mask >= 0xff) {
				/*
				 * Write it as a short and indicate we have done so.
				 */
				mask |= 0x20;
				block.put((byte) (mask & 0xFF));
				block.put((byte) (mask >> 8));
			} else {
				/*
				 * Write it as a byte.
				 */
				block.put((byte) (mask));
			}

			/*
			 * Append the appropriate updates.
			 */
			if (flags.get(UpdateFlag.ANIMATION)) {
				appendAnimationUpdate(block, otherPlayer);
			}
			if (flags.get(UpdateFlag.FORCED_CHAT)) {
				// chat
			}
			if (flags.get(UpdateFlag.FACE_ENTITY)) {
				Entity entity = otherPlayer.getInteractingEntity();
				block.putShortA(entity == null ? -1 : entity.getClientIndex());
			}
			if (flags.get(UpdateFlag.FACE_COORDINATE)) {
				Location loc = otherPlayer.getFaceLocation();
				if (loc == null) {
					block.putShort(0);
					block.putShort(0);
				} else {
					block.putShort(loc.getX() * 2 + 1);
					block.putShort(loc.getY() * 2 + 1);
				}
			}
			if (flags.get(UpdateFlag.GRAPHICS)) {
				appendGraphicsUpdate(block, otherPlayer);
			}
			if (flags.get(UpdateFlag.APPEARANCE) || forceAppearance) {
				appendPlayerAppearanceUpdate(block, otherPlayer);
			}
			if (flags.get(UpdateFlag.CHAT) && !noChat) {
				appendChatUpdate(block, otherPlayer);
			}
			if (flags.get(UpdateFlag.HIT)) {
				// appendHitUpdate(otherPlayer, block);
			}
			if (flags.get(UpdateFlag.HIT_2)) {
				// appendHit2Update(otherPlayer, block);
			}

			/*
			 * Convert the block builder to a packet.
			 */
			Packet blockPacket = block.toPacket();

			/*
			 * Now it is over, cache the block if we can.
			 */
			if (otherPlayer != player && !forceAppearance && !noChat) {
				otherPlayer.setCachedUpdateBlock(blockPacket);
			}

			/*
			 * And finally append the block at the end.
			 */
			packet.put(blockPacket.getPayload());
		}
	}

	/**
	 * Appends an animation update.
	 * 
	 * @param block
	 *            The update block.
	 * @param otherPlayer
	 *            The player.
	 */
	private void appendAnimationUpdate(PacketBuilder block, Player otherPlayer) {
		block.putShort(otherPlayer.getCurrentAnimation().getId());
		block.putByteS((byte) otherPlayer.getCurrentAnimation().getDelay());
	}

	/**
	 * Appends a graphics update.
	 * 
	 * @param block
	 *            The update block.
	 * @param otherPlayer
	 *            The player.
	 */
	private void appendGraphicsUpdate(PacketBuilder block, Player otherPlayer) {
		block.putShortA(otherPlayer.getCurrentGraphic().getId());
		block.putInt2(otherPlayer.getCurrentGraphic().getDelay());
	}

	/**
	 * Appends a chat text update.
	 * 
	 * @param packet
	 *            The packet.
	 * @param otherPlayer
	 *            The player.
	 */
	private void appendChatUpdate(PacketBuilder packet, Player otherPlayer) {
		ChatMessage cm = otherPlayer.getCurrentChatMessage();

		byte[] bytes = cm.getText();

		packet.putShort(((cm.getColour() & 0xFF) << 8)
				+ (cm.getEffects() & 0xFF));
		packet.putByteC((byte) otherPlayer.getRights().toInteger());
		packet.putByteA(bytes.length);
		for (byte aByte : bytes) {
			packet.putByteA(aByte);
		}
	}

	/**
	 * Appends an appearance update.
	 * 
	 * @param packet
	 *            The packet.
	 * @param otherPlayer
	 *            The player.
	 */
	private void appendPlayerAppearanceUpdate(PacketBuilder packet,
			Player otherPlayer) {
		Appearance app = otherPlayer.getAppearance();
		Container eq = otherPlayer.getEquipment();

		PacketBuilder playerProps = new PacketBuilder();
		playerProps.put((byte) app.getGender()); // gender
		playerProps.put((byte) -1); // skull icon
		playerProps.put((byte) -1); // prayer icon

		for (int i = 0; i < 4; i++) {
			if (eq.isSlotUsed(i)) {
				playerProps.putShort((short) 0x200 + eq.get(i).getId());
			} else {
				playerProps.put((byte) 0);
			}
		}
		if (eq.isSlotUsed(Equipment.SLOT_CHEST)) {
			playerProps.putShort((short) 0x200
					+ eq.get(Equipment.SLOT_CHEST).getId());
		} else {
			playerProps.putShort((short) 0x100 + app.getChest()); // chest
		}
		if (eq.isSlotUsed(Equipment.SLOT_SHIELD)) {
			playerProps.putShort((short) 0x200
					+ eq.get(Equipment.SLOT_SHIELD).getId());
		} else {
			playerProps.put((byte) 0);
		}
		Item chest = eq.get(Equipment.SLOT_CHEST);
		if (chest != null) {
			if (!Equipment.is(EquipmentType.PLATEBODY, chest)) {
				playerProps.putShort((short) 0x100 + app.getArms());
			} else {
				playerProps.putShort((short) 0x200 + chest.getId());
			}
		} else {
			playerProps.putShort((short) 0x100 + app.getArms());
		}
		if (eq.isSlotUsed(Equipment.SLOT_BOTTOMS)) {
			playerProps.putShort((short) 0x200
					+ eq.get(Equipment.SLOT_BOTTOMS).getId());
		} else {
			playerProps.putShort((short) 0x100 + app.getLegs());
		}
		Item helm = eq.get(Equipment.SLOT_HELM);
		if (helm != null) {
			if (!Equipment.is(EquipmentType.FULL_HELM, helm)
					&& !Equipment.is(EquipmentType.FULL_MASK, helm)) {
				playerProps.putShort((short) 0x100 + app.getHead());
			} else {
				playerProps.put((byte) 0);
			}
		} else {
			playerProps.putShort((short) 0x100 + app.getHead());
		}
		if (eq.isSlotUsed(Equipment.SLOT_GLOVES)) {
			playerProps.putShort((short) 0x200
					+ eq.get(Equipment.SLOT_GLOVES).getId());
		} else {
			playerProps.putShort((short) 0x100 + app.getHands());
		}
		if (eq.isSlotUsed(Equipment.SLOT_BOOTS)) {
			playerProps.putShort((short) 0x200
					+ eq.get(Equipment.SLOT_BOOTS).getId());
		} else {
			playerProps.putShort((short) 0x100 + app.getFeet());
		}
		boolean fullHelm = false;
		if (helm != null) {
			fullHelm = !Equipment.is(EquipmentType.FULL_HELM, helm);
		}
		if (fullHelm || app.getGender() == 1) {
			playerProps.put((byte) 0);
		} else {
			playerProps.putShort((short) 0x100 + app.getBeard());
		}

		playerProps.put((byte) app.getHairColour()); // hairc
		playerProps.put((byte) app.getTorsoColour()); // torsoc
		playerProps.put((byte) app.getLegColour()); // legc
		playerProps.put((byte) app.getFeetColour()); // feetc
		playerProps.put((byte) app.getSkinColour()); // skinc

		Item weapon = eq.get(Equipment.SLOT_WEAPON);
		playerProps.putShort((short) Equipment.getStandAnim(weapon)); // stand
		playerProps.putShort((short) 0x337); // stand turn
		playerProps.putShort((short) Equipment.getWalkAnim(weapon)); // walk
		playerProps.putShort((short) 0x334); // turn 180
		playerProps.putShort((short) 0x335); // turn 90 cw
		playerProps.putShort((short) 0x336); // turn 90 ccw
		playerProps.putShort((short) Equipment.getRunAnim(weapon)); // run

		playerProps.putLong(otherPlayer.getNameAsLong()); // player name
		playerProps.put((byte) otherPlayer.getSkills().getCombatLevel()); // combat
																			// level
		playerProps.putShort(0); // (skill-level instead of combat-level)
									// otherPlayer.getSkills().getTotalLevel());
									// // total level

		Packet propsPacket = playerProps.toPacket();

		byte[] buffer = new byte[propsPacket.getLength()];
		propsPacket.getReverse(buffer, 0, propsPacket.getLength());

		packet.put((byte) propsPacket.getLength());
		packet.put(buffer);
	}

	/**
	 * Updates this player's movement.
	 * 
	 * @param packet
	 *            The packet.
	 */
	private void updateThisPlayerMovement(PacketBuilder packet) {
		/*
		 * Check if the player is teleporting.
		 */
		if (player.isTeleporting() || player.isMapRegionChanging()) {
			/*
			 * They are, so an update is required.
			 */
			packet.putBits(1, 1);

			/*
			 * This value indicates the player teleported.
			 */
			packet.putBits(2, 3);

			/*
			 * This indicates that the client should discard the walking queue.
			 */
			packet.putBits(1, player.isTeleporting() ? 1 : 0);

			/*
			 * This is the new player height.
			 */
			packet.putBits(2, player.getLocation().getZ());

			/*
			 * These are the positions.
			 */
			packet.putBits(7, player.getLocation().getLocalY(
					player.getLastKnownRegion()));
			packet.putBits(7, player.getLocation().getLocalX(
					player.getLastKnownRegion()));

			/*
			 * This flag indicates if an update block is appended.
			 */
			packet.putBits(1, player.getUpdateFlags().isUpdateRequired() ? 1
					: 0);
		} else {
			/*
			 * Otherwise, check if the player moved.
			 */
			if (player.getSprites().getPrimarySprite() == -1) {
				/*
				 * The player didn't move. Check if an update is required.
				 */
				if (player.getUpdateFlags().isUpdateRequired()) {
					/*
					 * Signifies an update is required.
					 */
					packet.putBits(1, 1);

					/*
					 * But signifies that we didn't move.
					 */
					packet.putBits(2, 0);
				} else {
					/*
					 * Signifies that nothing changed.
					 */
					packet.putBits(1, 0);
				}
			} else {
				/*
				 * Check if the player was running.
				 */
				if (player.getSprites().getSecondarySprite() == -1) {
					/*
					 * The player walked, an update is required.
					 */
					packet.putBits(1, 1);

					/*
					 * This indicates the player only walked.
					 */
					packet.putBits(2, 1);

					/*
					 * This is the player's walking direction.
					 */
					packet.putBits(3, player.getSprites().getPrimarySprite());

					/*
					 * This flag indicates an update block is appended.
					 */
					packet.putBits(1, player.getUpdateFlags()
							.isUpdateRequired() ? 1 : 0);
				} else {
					/*
					 * The player ran, so an update is required.
					 */
					packet.putBits(1, 1);

					/*
					 * This indicates the player ran.
					 */
					packet.putBits(2, 2);

					/*
					 * This is the walking direction.
					 */
					packet.putBits(3, player.getSprites().getPrimarySprite());

					/*
					 * And this is the running direction.
					 */
					packet.putBits(3, player.getSprites().getSecondarySprite());

					/*
					 * And this flag indicates an update block is appended.
					 */
					packet.putBits(1, player.getUpdateFlags()
							.isUpdateRequired() ? 1 : 0);
				}
			}
		}
	}

}

NPCUpdateTask:

Code:

package org.hyperion.rs2.task.impl;

import java.util.Iterator;

import org.hyperion.rs2.GameEngine;
import org.hyperion.rs2.model.NPC;
import org.hyperion.rs2.model.Player;
import org.hyperion.rs2.model.UpdateFlags;
import org.hyperion.rs2.model.World;
import org.hyperion.rs2.model.UpdateFlags.UpdateFlag;
import org.hyperion.rs2.net.Packet;
import org.hyperion.rs2.net.PacketBuilder;
import org.hyperion.rs2.task.Task;

/**
 * A task which creates and sends the NPC update block.
 * 
 * @author Graham Edgecombe
 * 
 */
public class NPCUpdateTask implements Task {

	/**
	 * The player.
	 */
	private Player player;

	/**
	 * Creates an npc update task.
	 * 
	 * @param player
	 *            The player.
	 */
	public NPCUpdateTask(Player player) {
		this.player = player;
	}

	public void execute(GameEngine context) {
		/*
		 * The update block holds the update masks and data, and is written
		 * after the main block.
		 */
		PacketBuilder updateBlock = new PacketBuilder();

		/*
		 * The main packet holds information about adding, moving and removing
		 * NPCs.
		 */
		PacketBuilder packet = new PacketBuilder(71, Packet.Type.VARIABLE_SHORT);
		packet.startBitAccess();

		/*
		 * Write the current size of the npc list.
		 */
		packet.putBits(8, player.getLocalNPCs().size());

		/*
		 * Iterate through the local npc list.
		 */
		for (Iterator<NPC> it$ = player.getLocalNPCs().iterator(); it$
				.hasNext();) {
			/*
			 * Get the next NPC.
			 */
			NPC npc = it$.next();

			/*
			 * If the NPC should still be in our list.
			 */
			if (World.getWorld().getNPCs().contains(npc)
					&& !npc.isTeleporting()
					&& npc.getLocation().isWithinDistance(player.getLocation())) {
				/*
				 * Update the movement.
				 */
				updateNPCMovement(packet, npc);

				/*
				 * Check if an update is required, and if so, send the update.
				 */
				if (npc.getUpdateFlags().isUpdateRequired()) {
					updateNPC(updateBlock, npc);
				}
			} else {
				/*
				 * Otherwise, remove the NPC from the list.
				 */
				it$.remove();

				/*
				 * Tell the client to remove the NPC from the list.
				 */
				packet.putBits(1, 1);
				packet.putBits(2, 3);
			}
		}

		/*
		 * Loop through all NPCs in the world.
		 */
		for (NPC npc : World.getWorld().getRegionManager().getLocalNpcs(player)) {
			/*
			 * Check if there is room left in the local list.
			 */
			if (player.getLocalNPCs().size() >= 255) {
				/*
				 * There is no more room left in the local list. We cannot add
				 * more NPCs, so we just ignore the extra ones. They will be
				 * added as other NPCs get removed.
				 */
				break;
			}

			/*
			 * If they should not be added ignore them.
			 */
			if (player.getLocalNPCs().contains(npc)) {
				continue;
			}

			/*
			 * Add the npc to the local list if it is within distance.
			 */
			player.getLocalNPCs().add(npc);

			/*
			 * Add the npc in the packet.
			 */
			addNewNPC(packet, npc);

			/*
			 * Check if an update is required.
			 */
			if (npc.getUpdateFlags().isUpdateRequired()) {

				/*
				 * If so, update the npc.
				 */
				updateNPC(updateBlock, npc);

			}
		}

		/*
		 * Check if the update block isn't empty.
		 */
		if (!updateBlock.isEmpty()) {
			/*
			 * If so, put a flag indicating that an update block follows.
			 */
			packet.putBits(14, 16383);
			packet.finishBitAccess();

			/*
			 * And append the update block.
			 */
			packet.put(updateBlock.toPacket().getPayload());
		} else {
			/*
			 * Terminate the packet normally.
			 */
			packet.finishBitAccess();
		}

		/*
		 * Write the packet.
		 */
		player.write(packet.toPacket());
	}

	/**
	 * Adds a new NPC.
	 * 
	 * @param packet
	 *            The main packet.
	 * @param npc
	 *            The npc to add.
	 */
	private void addNewNPC(PacketBuilder packet, NPC npc) {
		/*
		 * Write the NPC's index.
		 */
		packet.putBits(14, npc.getIndex());

		/*
		 * Calculate the x and y offsets.
		 */
		int yPos = npc.getLocation().getY() - player.getLocation().getY();
		int xPos = npc.getLocation().getX() - player.getLocation().getX();

		packet.putBits(1, npc.getUpdateFlags().isUpdateRequired() ? 1 : 0);

		/*
		 * And write them.
		 */
		packet.putBits(5, yPos);
		packet.putBits(5, xPos);

		/*
		 * TODO unsure, but probably discards the client-side walk queue.
		 */
		packet.putBits(1, 0);

		/*
		 * We now write the NPC type id.
		 */
		packet.putBits(13, npc.getDefinition().getId());
	}

	/**
	 * Update an NPC's movement.
	 * 
	 * @param packet
	 *            The main packet.
	 * @param npc
	 *            The npc.
	 */
	private void updateNPCMovement(PacketBuilder packet, NPC npc) {
		/*
		 * Check if the NPC is running.
		 */
		if (npc.getSprites().getSecondarySprite() == -1) {
			/*
			 * They are not, so check if they are walking.
			 */
			if (npc.getSprites().getPrimarySprite() == -1) {
				/*
				 * They are not walking, check if the NPC needs an update.
				 */
				if (npc.getUpdateFlags().isUpdateRequired()) {
					/*
					 * Indicate an update is required.
					 */
					packet.putBits(1, 1);

					/*
					 * Indicate we didn't move.
					 */
					packet.putBits(2, 0);
				} else {
					/*
					 * Indicate no update or movement is required.
					 */
					packet.putBits(1, 0);
				}
			} else {
				/*
				 * They are walking, so indicate an update is required.
				 */
				packet.putBits(1, 1);

				/*
				 * Indicate the NPC is walking 1 tile.
				 */
				packet.putBits(2, 1);

				/*
				 * And write the direction.
				 */
				packet.putBits(3, npc.getSprites().getPrimarySprite());

				/*
				 * And write the update flag.
				 */
				packet.putBits(1, npc.getUpdateFlags().isUpdateRequired() ? 1
						: 0);
			}
		} else {
			/*
			 * They are running, so indicate an update is required.
			 */
			packet.putBits(1, 1);

			/*
			 * Indicate the NPC is running 2 tiles.
			 */
			packet.putBits(2, 2);

			/*
			 * And write the directions.
			 */
			packet.putBits(3, npc.getSprites().getPrimarySprite());
			packet.putBits(3, npc.getSprites().getSecondarySprite());

			/*
			 * And write the update flag.
			 */
			packet.putBits(1, npc.getUpdateFlags().isUpdateRequired() ? 1 : 0);
		}
	}

	/**
	 * Update an NPC.
	 * 
	 * @param packet
	 *            The update block.
	 * @param npc
	 *            The npc.
	 */
	private void updateNPC(PacketBuilder packet, NPC npc) {
		/*
		 * Calculate the mask.
		 */
		int mask = 0;
		final UpdateFlags flags = npc.getUpdateFlags();

		if (flags.get(UpdateFlag.ANIMATION)) {
			// mask |= 0x10;
		}
		if (flags.get(UpdateFlag.HIT)) {
			// mask |= 0x8;
		}
		if (flags.get(UpdateFlag.GRAPHICS)) {
			// mask |= 0x80;
		}
		if (flags.get(UpdateFlag.FACE_ENTITY)) {
			// mask |= 0x20;
		}
		if (flags.get(UpdateFlag.FORCED_CHAT)) {
			// mask |= 0x1;
		}
		if (flags.get(UpdateFlag.HIT_2)) {
			// mask |= 0x40;
		}
		if (flags.get(UpdateFlag.TRANSFORM)) {
			// mask |= 0x2;
		}
		if (flags.get(UpdateFlag.FACE_COORDINATE)) {
			// mask |= 0x4;
		}

		/*
		 * And write the mask.
		 */
		packet.put((byte) mask);

		if (flags.get(UpdateFlag.ANIMATION)) {
			// packet.putLEShort(npc.getCurrentAnimation().getId());
			// packet.put((byte) npc.getCurrentAnimation().getDelay());
		}
		if (flags.get(UpdateFlag.HIT)) {

		}
		if (flags.get(UpdateFlag.GRAPHICS)) {
			// packet.putShort(npc.getCurrentGraphic().getId());
			// packet.putInt(npc.getCurrentGraphic().getDelay());
		}
		if (flags.get(UpdateFlag.FACE_ENTITY)) {
			// Entity entity = npc.getInteractingEntity();
			// packet.putShort(entity == null ? -1 : entity.getClientIndex());
		}
		if (flags.get(UpdateFlag.FORCED_CHAT)) {

		}
		if (flags.get(UpdateFlag.HIT_2)) {

		}
		if (flags.get(UpdateFlag.TRANSFORM)) {

		}
		if (flags.get(UpdateFlag.FACE_COORDINATE)) {
			// Location loc = npc.getFaceLocation();
			// if(loc == null) {
			// packet.putLEShort(0);
			// packet.putLEShort(0);
			// } else {
			// packet.putLEShort(loc.getX() * 2 + 1);
			// packet.putLEShort(loc.getY() * 2 + 1);
			// }
		}
	}

}

configuration.cfg:

Code:

# Hyperion configuration file

# world loader
worldLoader: org.hyperion.rs2.GenericWorldLoader

# login server
loginServer: localhost
# world password
nodePassword: changeme
# world id
nodeId: 1

# quiet
# 40, 248, 19, 140, 187, 78, 6, 110, 244, 22
packetHandlers[40]: org.hyperion.rs2.packet.QuietPacketHandler
packetHandlers[248]: org.hyperion.rs2.packet.QuietPacketHandler
packetHandlers[19]: org.hyperion.rs2.packet.QuietPacketHandler
packetHandlers[140]: org.hyperion.rs2.packet.QuietPacketHandler
packetHandlers[187]: org.hyperion.rs2.packet.QuietPacketHandler
packetHandlers[78]: org.hyperion.rs2.packet.QuietPacketHandler
packetHandlers[6]: org.hyperion.rs2.packet.QuietPacketHandler
packetHandlers[110]: org.hyperion.rs2.packet.QuietPacketHandler
packetHandlers[244]: org.hyperion.rs2.packet.QuietPacketHandler
packetHandlers[22]: org.hyperion.rs2.packet.QuietPacketHandler

# object click
# 181, 241, 50
packetHandlers[50]: org.hyperion.rs2.packet.ObjectOptionPacketHandler
packetHandlers[241]: org.hyperion.rs2.packet.ObjectOptionPacketHandler
packetHandlers[181]: org.hyperion.rs2.packet.ObjectOptionPacketHandler

# player option
# 49
packetHandlers[245]: org.hyperion.rs2.packet.PlayerOptionPacketHandler

# chat
# 49
packetHandlers[49]: org.hyperion.rs2.packet.ChatPacketHandler

# walking
# 213, 28, 247
packetHandlers[213]: org.hyperion.rs2.packet.WalkingPacketHandler
packetHandlers[28]: org.hyperion.rs2.packet.WalkingPacketHandler
packetHandlers[247]: org.hyperion.rs2.packet.WalkingPacketHandler

# equipment
# 24
packetHandlers[24]: org.hyperion.rs2.packet.WieldPacketHandler

# items
# 3, 177, 91, 231, 158
packetHandlers[3]: org.hyperion.rs2.packet.ItemOptionPacketHandler
packetHandlers[177]: org.hyperion.rs2.packet.ItemOptionPacketHandler
packetHandlers[91]: org.hyperion.rs2.packet.ItemOptionPacketHandler
packetHandlers[231]: org.hyperion.rs2.packet.ItemOptionPacketHandler
packetHandlers[158]: org.hyperion.rs2.packet.ItemOptionPacketHandler

# input
# 75
packetHandlers[75]: org.hyperion.rs2.packet.EnterAmountPacketHandler

# action buttons
# 79
packetHandlers[79]: org.hyperion.rs2.packet.ActionButtonPacketHandler

# commands
# 56
packetHandlers[56]: org.hyperion.rs2.packet.CommandPacketHandler

Or if I missed any: http://www.rune-server.org/runescape...7-packets.html

Or you could just use: http://www.rune-server.org/runescape...ion-377-a.html

Nice job, may use these later on.