adding PlayerInteractionListener

Mumfrey
1 parent 1dd64987
Showing 11 changed files with 452 additions and 13 deletions
.classpath
java/client/com/mumfrey/liteloader/client/CallbackProxyClient.java
java/common/com/mumfrey/liteloader/PlayerInteractionListener.java
java/common/com/mumfrey/liteloader/common/transformers/LiteLoaderEventTransformer.java
java/common/com/mumfrey/liteloader/common/transformers/PacketEvent.java
java/common/com/mumfrey/liteloader/core/IEventState.java
java/common/com/mumfrey/liteloader/core/LiteLoaderEventBroker.java
java/common/com/mumfrey/liteloader/core/PacketEvents.java
java/common/com/mumfrey/liteloader/core/PlayerEventState.java
java/common/com/mumfrey/liteloader/core/runtime/Methods.java
java/common/com/mumfrey/liteloader/util/EntityUtilities.java
@@ -18,7 +18,7 @@
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/net/java/jinput/jinput/2.0.5/jinput-2.0.5.jar"/>
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/com/mojang/authlib/1.5.17/authlib-1.5.17.jar"/>
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/org/lwjgl/lwjgl/lwjgl/2.9.1/lwjgl-2.9.1.jar"/>
-	<classpathentry exported="true" kind="lib" path="lib/asm-debug-all-5.0.3.jar"/>
+	<classpathentry exported="true" kind="lib" path="lib/asm-debug-all-5.0.3.jar" sourcepath="/ASM/src"/>
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/org/lwjgl/lwjgl/lwjgl_util/2.9.1/lwjgl_util-2.9.1.jar"/>
 	<classpathentry exported="true" kind="lib" path="/Client/jars/libraries/com/mojang/realms/1.5.5/realms-1.5.5.jar"/>
 	<classpathentry kind="output" path="bin"/>
@@ -14,15 +14,27 @@ import net.minecraft.client.shader.Framebuffer;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.NetHandlerPlayServer;
 import net.minecraft.network.NetworkManager;
+import net.minecraft.network.play.client.C07PacketPlayerDigging;
+import net.minecraft.network.play.client.C08PacketPlayerBlockPlacement;
+import net.minecraft.network.play.client.C0APacketAnimation;
+import net.minecraft.network.play.server.S23PacketBlockChange;
+import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.integrated.IntegratedServer;
+import net.minecraft.server.management.ItemInWorldManager;
 import net.minecraft.server.management.ServerConfigurationManager;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.IChatComponent;
 import net.minecraft.util.ScreenShotHelper;
 import net.minecraft.util.Session;
+import net.minecraft.world.World;
 import net.minecraft.world.WorldSettings;
 import com.mojang.authlib.GameProfile;
+import com.mumfrey.liteloader.core.LiteLoaderEventBroker.InteractType;
 import com.mumfrey.liteloader.transformers.event.EventInfo;
 import com.mumfrey.liteloader.transformers.event.ReturnEventInfo;
@@ -207,6 +219,80 @@ public class CallbackProxyClient
 		CallbackProxyClient.eventBroker.onPostRenderEntity(e.getSource(), entity, xPos, yPos, zPos, yaw, partialTicks, render);
 	}
+	public static void onServerTick(EventInfo<MinecraftServer> e)
+	{
+		CallbackProxyClient.eventBroker.onServerTick(e.getSource());
+	}
+	
+	public static void onPlaceBlock(EventInfo<NetHandlerPlayServer> e, C08PacketPlayerBlockPlacement packet)
+	{
+		NetHandlerPlayServer netHandler = e.getSource();
+		
+		EntityPlayerMP playerMP = netHandler.playerEntity;
+		BlockPos pos = packet.getPosition();
+		EnumFacing facing = EnumFacing.getFront(packet.getPlacedBlockDirection());
+		if (!CallbackProxyClient.eventBroker.onPlayerInteract(InteractType.PLACE_BLOCK_MAYBE, playerMP, pos, facing))
+		{
+			S23PacketBlockChange cancellation = new S23PacketBlockChange(playerMP.worldObj, pos.offset(facing));
+			netHandler.playerEntity.playerNetServerHandler.sendPacket(cancellation);
+			playerMP.sendContainerToPlayer(playerMP.inventoryContainer);
+			e.cancel();
+		}
+	}
+	
+	public static void onClickedAir(EventInfo<NetHandlerPlayServer> e, C0APacketAnimation packet)
+	{
+		NetHandlerPlayServer netHandler = e.getSource();
+		if (!CallbackProxyClient.eventBroker.onPlayerInteract(InteractType.LEFT_CLICK, netHandler.playerEntity, null, EnumFacing.SOUTH))
+		{
+			e.cancel();
+		}
+	}
+
+	public static void onPlayerDigging(EventInfo<NetHandlerPlayServer> e, C07PacketPlayerDigging packet)
+	{
+		if (packet.getStatus() == C07PacketPlayerDigging.Action.START_DESTROY_BLOCK)
+		{
+			NetHandlerPlayServer netHandler = e.getSource();
+			BlockPos pos = packet.func_179715_a();
+			EntityPlayerMP playerMP = netHandler.playerEntity;
+			if (!CallbackProxyClient.eventBroker.onPlayerInteract(InteractType.DIG_BLOCK_MAYBE, playerMP, pos, EnumFacing.SOUTH))
+			{
+				S23PacketBlockChange cancellation = new S23PacketBlockChange(playerMP.worldObj, pos);
+				netHandler.playerEntity.playerNetServerHandler.sendPacket(cancellation);
+				e.cancel();
+			}
+		}
+	}
+	
+	public static void onUseItem(ReturnEventInfo<ItemInWorldManager, Boolean> e, EntityPlayer player, World world, ItemStack itemStack, BlockPos pos, EnumFacing side, float par8, float par9, float par10)
+	{
+		if (player instanceof EntityPlayerMP)
+		{
+			EntityPlayerMP playerMP = (EntityPlayerMP)player;
+			
+			if (!CallbackProxyClient.eventBroker.onPlayerInteract(InteractType.PLACE_BLOCK_MAYBE, playerMP, pos, side))
+			{
+				System.err.println(pos);
+				S23PacketBlockChange cancellation = new S23PacketBlockChange(playerMP.worldObj, pos);
+				playerMP.playerNetServerHandler.sendPacket(cancellation);
+				e.setReturnValue(false);
+			}
+		}
+	}
+	
+	public static void onBlockClicked(EventInfo<ItemInWorldManager> e, BlockPos pos, EnumFacing side)
+	{
+		ItemInWorldManager manager = e.getSource();
+		
+		if (!CallbackProxyClient.eventBroker.onPlayerInteract(InteractType.LEFT_CLICK_BLOCK, manager.thisPlayerMP, pos, side))
+		{
+			S23PacketBlockChange cancellation = new S23PacketBlockChange(manager.theWorld, pos);
+			manager.thisPlayerMP.playerNetServerHandler.sendPacket(cancellation);
+			e.cancel();
+		}
+	}
+	
 	/**
 	 * Compatiblbe behaviour with FML, this method is called to generate a consistent offline UUID between client and server
 	 * for a given username.
+package com.mumfrey.liteloader;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.MovingObjectPosition.MovingObjectType;
+
+/**
+ * Interface for mods which want to observe the player's "interaction" status (player mouse clicks), allows block interaction
+ * events to be cancelled.
+ * 
+ * @author Adam Mummery-Smith
+ */
+public interface PlayerInteractionListener extends LiteMod
+{
+	/**
+	 * Mouse buttons
+	 */
+	public static enum MouseButton
+	{
+		LEFT,
+		RIGHT
+	}
+	
+	/**
+	 * Called when the player clicks but does not "hit" a block, the trace position is raytraced to the player's current view
+	 * distance and represents the block which the player is "looking at". This method is NOT called when the player right clicks
+	 * with an empty hand.
+	 * 
+	 * @param player Player
+	 * @param button Mouse button the user clicked
+	 * @param tracePos Raytraced location of the block which was hit
+	 * @param traceSideHit Raytraced side hit
+	 * @param traceHitType Type of hit, will be MISS if the trace expired without hitting anything (eg. the player clicked the sky)
+	 */
+	public abstract void onPlayerClickedAir(EntityPlayerMP player, MouseButton button, BlockPos tracePos, EnumFacing traceSideHit, MovingObjectType traceHitType);
+	
+	/**
+	 * Calls when the player clicks and hits a block, usually indicates that the player is digging or placing a block, although
+	 * a block placement does not necessarily succeed. Return true from this callback to allow the action to proceed, or false to
+	 * cancel the action. Cancelling the action does not prevent further handlers from receiving the event.
+	 * 
+	 * @param player Player
+	 * @param button Mouse button that was pressed (left = dig, right = interact/place)
+	 * @param hitPos Block which was *hit*. Note that block placement will normally be at hitPos.offset(sideHit) 
+	 * @param sideHit Side of the block which was hit
+	 * @return
+	 */
+	public abstract boolean onPlayerClickedBlock(EntityPlayerMP player, MouseButton button, BlockPos hitPos, EnumFacing sideHit);
+}
 package com.mumfrey.liteloader.common.transformers;
 import static com.mumfrey.liteloader.core.runtime.Methods.*;
+import static com.mumfrey.liteloader.transformers.event.InjectionPoint.*;
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.transformers.event.Event;
 import com.mumfrey.liteloader.transformers.event.EventInjectionTransformer;
 import com.mumfrey.liteloader.transformers.event.InjectionPoint;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
+import com.mumfrey.liteloader.transformers.event.inject.BeforeInvoke;
 import com.mumfrey.liteloader.transformers.event.inject.BeforeNew;
 import com.mumfrey.liteloader.transformers.event.inject.BeforeReturn;
+import com.mumfrey.liteloader.transformers.event.inject.MethodHead;
 /**
  * Injector for LiteLoader's common events
@@ -28,18 +31,32 @@ public abstract class LiteLoaderEventTransformer extends EventInjectionTransform
 		Event onPlayerLogout                   = Event.getOrCreate("onPlayerLogout",               false);
 		Event onSpawnPlayer                    = Event.getOrCreate("onSpawnPlayer",                false);
 		Event onRespawnPlayer                  = Event.getOrCreate("onRespawnPlayer",              false);
+		Event onServerTick                     = Event.getOrCreate("onServerTick",                 false);
+		Event onBlockClickedEvent              = Event.getOrCreate("onBlockClicked",               true);
+		Event onActivateBlockOrUseItem         = Event.getOrCreate("onActivateBlockOrUseItem",     true);
+		Event onPlayerDigging                  = Event.getOrCreate("onPlayerDigging",              true);
+		Event onPlaceBlock                     = Event.getOrCreate("onPlaceBlock",                 true);
+		Event onClickedAir                     = Event.getOrCreate("onClickedAir",                 true);
 		Event onSessionProfileBad              = Event.getOrCreate("onSessionProfileBad",          true);
 		// Injection Points
+		InjectionPoint methodHead              = new MethodHead();
 		InjectionPoint methodReturn            = new BeforeReturn();
 		InjectionPoint beforeNewGameProfile    = new BeforeNew(1, Obf.GameProfile);
+		InjectionPoint beforeThreadMarshall    = new BeforeInvoke(checkThreadAndEnqueue);
 		// Hooks
-		this.add(onInitializePlayerConnection, initPlayerConnection, (methodReturn),         "onInitializePlayerConnection");
-		this.add(onPlayerLogin,                playerLoggedIn,       (methodReturn),         "onPlayerLogin");
-		this.add(onPlayerLogout,               playerLoggedOut,      (methodReturn),         "onPlayerLogout");
-		this.add(onSpawnPlayer,                spawnPlayer,          (methodReturn),         "onSpawnPlayer");
-		this.add(onRespawnPlayer,              respawnPlayer,        (methodReturn),         "onRespawnPlayer");
+		this.add(onInitializePlayerConnection, initPlayerConnection,        (methodReturn),          "onInitializePlayerConnection");
+		this.add(onPlayerLogin,                playerLoggedIn,              (methodReturn),          "onPlayerLogin");
+		this.add(onPlayerLogout,               playerLoggedOut,             (methodReturn),          "onPlayerLogout");
+		this.add(onSpawnPlayer,                spawnPlayer,                 (methodReturn),          "onSpawnPlayer");
+		this.add(onRespawnPlayer,              respawnPlayer,               (methodReturn),          "onRespawnPlayer");
+		this.add(onServerTick,                 serverJobs,                  (methodHead),            "onServerTick");
+		this.add(onBlockClickedEvent,          onBlockClicked,              (methodHead),            "onBlockClicked");
+		this.add(onActivateBlockOrUseItem,     activateBlockOrUseItem,      (methodHead),            "onUseItem");
+		this.add(onPlaceBlock,                 processBlockPlacement,  after(beforeThreadMarshall) , "onPlaceBlock");
+		this.add(onClickedAir,                 handleAnimation,        after(beforeThreadMarshall),  "onClickedAir");
+		this.add(onPlayerDigging,              processPlayerDigging,   after(beforeThreadMarshall),  "onPlayerDigging");
 		// Compatibility handlers
 		this.add(onSessionProfileBad,          getProfile,           (beforeNewGameProfile), "generateOfflineUUID");
@@ -45,7 +45,7 @@ public class PacketEvent extends Event
 	 * @see com.mumfrey.liteloader.transformers.event.Event#invokeEventInfoConstructor(org.objectweb.asm.tree.InsnList, boolean)
 	 */
 	@Override
-	protected int invokeEventInfoConstructor(InsnList insns, boolean cancellable)
+	protected int invokeEventInfoConstructor(InsnList insns, boolean cancellable, boolean pushReturnValue, int marshallVar)
 	{
 		int ctorMAXS = 0;
+package com.mumfrey.liteloader.core;
+
+
+public interface IEventState
+{
+	public abstract void onTick();
+}
 package com.mumfrey.liteloader.core;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
 import net.minecraft.command.ICommandManager;
 import net.minecraft.command.ServerCommandManager;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.network.NetworkManager;
+import net.minecraft.network.play.client.C15PacketClientSettings;
 import net.minecraft.profiler.Profiler;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.management.ServerConfigurationManager;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.MovingObjectPosition.MovingObjectType;
 import net.minecraft.world.World;
 import net.minecraft.world.WorldSettings;
 import com.mojang.authlib.GameProfile;
 import com.mumfrey.liteloader.LiteMod;
+import com.mumfrey.liteloader.PlayerInteractionListener;
+import com.mumfrey.liteloader.PlayerInteractionListener.MouseButton;
 import com.mumfrey.liteloader.PluginChannelListener;
 import com.mumfrey.liteloader.ServerCommandProvider;
 import com.mumfrey.liteloader.ServerPlayerListener;
@@ -21,8 +31,11 @@ import com.mumfrey.liteloader.api.Listener;
 import com.mumfrey.liteloader.common.GameEngine;
 import com.mumfrey.liteloader.common.LoadingProgress;
 import com.mumfrey.liteloader.core.event.HandlerList;
+import com.mumfrey.liteloader.core.event.HandlerList.ReturnLogicOp;
 import com.mumfrey.liteloader.interfaces.FastIterable;
+import com.mumfrey.liteloader.interfaces.FastIterableDeque;
 import com.mumfrey.liteloader.launch.LoaderProperties;
+import com.mumfrey.liteloader.util.PrivateFields;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
 /**
@@ -69,6 +82,20 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 		}
 	}
+	public static enum InteractType
+	{
+		RIGHT_CLICK,
+		LEFT_CLICK,
+		LEFT_CLICK_BLOCK,
+		PLACE_BLOCK_MAYBE,
+		DIG_BLOCK_MAYBE
+	}
+	
+	/**
+	 * Singleton
+	 */
+	static LiteLoaderEventBroker<?, ?> broker; 
+	
 	/**
 	 * Reference to the loader instance
 	 */
@@ -86,6 +113,9 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 	protected LiteLoaderMods mods;
+	private Map<UUID, PlayerEventState> playerStates = new HashMap<UUID, PlayerEventState>();
+	private FastIterableDeque<IEventState> playerStateList = new HandlerList<IEventState>(IEventState.class);
+	
 	/**
 	 * List of mods which provide server commands
 	 */
@@ -97,6 +127,11 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 	private FastIterable<ServerPlayerListener> serverPlayerListeners = new HandlerList<ServerPlayerListener>(ServerPlayerListener.class);
 	/**
+	 * List of mods which handle player interaction events 
+	 */
+	private FastIterable<PlayerInteractionListener> playerInteractionListeners = new HandlerList<PlayerInteractionListener>(PlayerInteractionListener.class, ReturnLogicOp.AND);
+	
+	/**
 	 * ctor
 	 * 
 	 * @param loader
@@ -108,6 +143,8 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 		this.loader   = loader;
 		this.engine   = engine;
 		this.profiler = engine.getProfiler();
+		
+		LiteLoaderEventBroker.broker = this;
 	}
 	/**
@@ -149,6 +186,7 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 	{
 		delegate.registerInterface(ServerCommandProvider.class);
 		delegate.registerInterface(ServerPlayerListener.class);
+		delegate.registerInterface(PlayerInteractionListener.class);
 		delegate.registerInterface(CommonPluginChannelListener.class);
 	}
@@ -180,6 +218,14 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 	{
 		this.serverPlayerListeners.add(serverPlayerListener);
 	}
+	
+	/**
+	 * @param playerInteractionListener
+	 */
+	public void addPlayerInteractionListener(PlayerInteractionListener playerInteractionListener)
+	{
+		this.playerInteractionListeners.add(playerInteractionListener);
+	}
 	/**
 	 * @param instance
@@ -198,6 +244,8 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 		}
 		LiteLoader.getServerPluginChannels().onServerStartup();
+		
+		this.playerStates.clear();
 	}
 	/**
@@ -208,6 +256,8 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 	public void onSpawnPlayer(ServerConfigurationManager scm, EntityPlayerMP player, GameProfile profile)
 	{
 		this.serverPlayerListeners.all().onPlayerConnect(player, profile);
+		PlayerEventState playerState = this.getPlayerState(player);
+		playerState.onSpawned();
 	}
 	/**
@@ -248,6 +298,7 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 	public void onPlayerLogout(ServerConfigurationManager scm, EntityPlayerMP player)
 	{
 		this.serverPlayerListeners.all().onPlayerLogout(player);
+		this.removePlayer(player);
 	}
 	/**
@@ -274,4 +325,51 @@ public abstract class LiteLoaderEventBroker&lt;TClient, TServer extends MinecraftSe
 	{
 		this.loader.onWorldChanged(world);
 	}
+	
+	public void onServerTick(MinecraftServer minecraftServer)
+	{
+		this.playerStateList.all().onTick();
+	}
+	
+	public boolean onPlayerInteract(InteractType action, EntityPlayerMP player, BlockPos position, EnumFacing side)
+	{
+		PlayerEventState eventState = this.getPlayerState(player);
+		return eventState.onPlayerInteract(action, player, position, side);
+	}
+	
+	void onPlayerClickedAir(EntityPlayerMP player, MouseButton button, BlockPos tracePos, EnumFacing traceSideHit, MovingObjectType traceHitType)
+	{
+		this.playerInteractionListeners.all().onPlayerClickedAir(player, button, tracePos, traceSideHit, traceHitType);
+	}
+	
+	boolean onPlayerClickedBlock(EntityPlayerMP player, MouseButton button, BlockPos hitPos, EnumFacing sideHit)
+	{
+		return this.playerInteractionListeners.all().onPlayerClickedBlock(player, button, hitPos, sideHit);
+	}
+	
+	void onPlayerSettingsReceived(EntityPlayerMP player, C15PacketClientSettings packet)
+	{
+		this.getPlayerState(player).setTraceDistance(PrivateFields.viewDistance.get(packet));
+	}
+
+	protected PlayerEventState getPlayerState(EntityPlayerMP player)
+	{
+		PlayerEventState playerState = this.playerStates.get(player.getUniqueID());
+		if (playerState == null)
+		{
+			playerState = new PlayerEventState(player, this);
+			this.playerStates.put(player.getUniqueID(), playerState);
+			this.playerStateList.add(playerState);
+		}
+		return playerState;
+	}
+
+	protected void removePlayer(EntityPlayerMP player)
+	{
+		PlayerEventState playerState = this.playerStates.remove(player.getUniqueID());
+		if (playerState != null)
+		{
+			this.playerStateList.remove(playerState);
+		}
+	}
 }
@@ -8,6 +8,7 @@ import net.minecraft.network.NetHandlerPlayServer;
 import net.minecraft.network.Packet;
 import net.minecraft.network.login.server.S02PacketLoginSuccess;
 import net.minecraft.network.play.client.C01PacketChatMessage;
+import net.minecraft.network.play.client.C15PacketClientSettings;
 import net.minecraft.network.play.client.C17PacketCustomPayload;
 import net.minecraft.network.play.server.S01PacketJoinGame;
 import net.minecraft.network.play.server.S02PacketChat;
@@ -49,12 +50,13 @@ public abstract class PacketEvents implements InterfaceProvider
 	private FastIterable<ServerChatFilter> serverChatFilters = new HandlerList<ServerChatFilter>(ServerChatFilter.class, ReturnLogicOp.AND_BREAK_ON_FALSE);
-	private final int loginSuccessPacketId  = Packets.S02PacketLoginSuccess.getIndex();
-	private final int serverChatPacketId    = Packets.S02PacketChat.getIndex();
-	private final int clientChatPacketId    = Packets.C01PacketChatMessage.getIndex();
-	private final int joinGamePacketId      = Packets.S01PacketJoinGame.getIndex();
-	private final int serverPayloadPacketId = Packets.S3FPacketCustomPayload.getIndex();
-	private final int clientPayloadPacketId = Packets.C17PacketCustomPayload.getIndex();
+	private final int loginSuccessPacketId   = Packets.S02PacketLoginSuccess.getIndex();
+	private final int serverChatPacketId     = Packets.S02PacketChat.getIndex();
+	private final int clientChatPacketId     = Packets.C01PacketChatMessage.getIndex();
+	private final int joinGamePacketId       = Packets.S01PacketJoinGame.getIndex();
+	private final int serverPayloadPacketId  = Packets.S3FPacketCustomPayload.getIndex();
+	private final int clientPayloadPacketId  = Packets.C17PacketCustomPayload.getIndex();
+	private final int clientSettingsPacketId = Packets.C15PacketClientSettings.getIndex();
 	public PacketEvents()
 	{
@@ -192,6 +194,12 @@ public abstract class PacketEvents implements InterfaceProvider
 			return true;
 		}
+		if (packetId == this.clientSettingsPacketId)
+		{
+			this.handlePacket(e, netHandler, (C15PacketClientSettings)packet);
+			return true;
+		}
+		
 		return false;
 	}
@@ -258,4 +266,23 @@ public abstract class PacketEvents implements InterfaceProvider
 	{
 		LiteLoader.getServerPluginChannels().onPluginChannelMessage(netHandler, packet);
 	}
+	
+	/**
+	 * C15PacketClientSettings::processPacket()
+	 * 
+	 * @param e
+	 * @param netHandler
+	 * @param packet
+	 */
+	private void handlePacket(PacketEventInfo<Packet> e, INetHandler netHandler, C15PacketClientSettings packet)
+	{
+		if (netHandler instanceof NetHandlerPlayServer)
+		{
+			LiteLoaderEventBroker.broker.onPlayerSettingsReceived(((NetHandlerPlayServer)netHandler).playerEntity, packet);
+		}
+		else
+		{
+			System.err.println("ACTUALLY: handler is " + netHandler);
+		}
+	}
 }
+package com.mumfrey.liteloader.core;
+
+import java.lang.ref.WeakReference;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.MovingObjectPosition.MovingObjectType;
+
+import com.mumfrey.liteloader.PlayerInteractionListener.MouseButton;
+import com.mumfrey.liteloader.core.LiteLoaderEventBroker.InteractType;
+import com.mumfrey.liteloader.util.EntityUtilities;
+
+public class PlayerEventState implements IEventState
+{
+	private static long MISS = new BlockPos(-1, -1, -1).toLong();
+	
+	private WeakReference<EntityPlayerMP> playerRef;
+	
+	private final LiteLoaderEventBroker<?, ?> broker;
+	
+	private double traceDistance = 256.0;
+	
+	private int suppressLeftTicks; 
+	private int suppressRightTicks; 
+	private boolean leftClick;
+	private boolean rightClick;
+	
+	private MovingObjectPosition hit;
+
+	public PlayerEventState(EntityPlayerMP player, LiteLoaderEventBroker<?, ?> broker)
+	{
+		this.playerRef = new WeakReference<EntityPlayerMP>(player);
+		this.broker = broker;
+	}
+	
+	public void setTraceDistance(int renderDistance)
+	{
+		this.traceDistance = renderDistance * 16.0;
+	}
+
+	public EntityPlayerMP getPlayer()
+	{
+		return this.playerRef.get();
+	}
+	
+	public void onSpawned()
+	{
+	}
+	
+	@Override
+	public void onTick()
+	{
+		if (this.leftClick && this.suppressLeftTicks == 0)
+		{
+			this.broker.onPlayerClickedAir(this.getPlayer(), MouseButton.LEFT, this.hit.getBlockPos(), this.hit.sideHit, this.hit.typeOfHit);
+		}
+		
+		if (this.rightClick && this.suppressRightTicks == 0)
+		{
+			this.broker.onPlayerClickedAir(this.getPlayer(), MouseButton.RIGHT, this.hit.getBlockPos(), this.hit.sideHit,  this.hit.typeOfHit);
+		}
+		
+		if (this.suppressLeftTicks > 0) this.suppressLeftTicks--;
+		if (this.suppressRightTicks > 0) this.suppressRightTicks--;
+		
+		this.leftClick = false;
+		this.rightClick = false;
+	}
+
+	public boolean onPlayerInteract(InteractType action, EntityPlayerMP player, BlockPos position, EnumFacing side)
+	{
+		this.hit = EntityUtilities.rayTraceFromEntity(player, this.traceDistance, 0.0F);
+
+		if (action == InteractType.LEFT_CLICK)
+		{
+			this.leftClick = true;
+			return true;
+		}
+		
+		if (action == InteractType.RIGHT_CLICK)
+		{
+			this.rightClick = true;
+			return true;
+		}
+		
+		if ((action == InteractType.LEFT_CLICK_BLOCK || action == InteractType.DIG_BLOCK_MAYBE) && this.suppressLeftTicks == 0)
+		{
+			this.suppressLeftTicks += 2;
+			return this.broker.onPlayerClickedBlock(player, MouseButton.LEFT, position, side);
+		}
+		
+		if (action == InteractType.PLACE_BLOCK_MAYBE)
+		{
+			if (this.suppressRightTicks > 0)
+			{
+				return true;
+			}
+			
+			if (position.toLong() == PlayerEventState.MISS)
+			{
+				MovingObjectPosition actualHit = EntityUtilities.rayTraceFromEntity(player, player.capabilities.isCreativeMode ? 5.0 : 4.5, 0.0F);
+				if (actualHit.typeOfHit == MovingObjectType.MISS)
+				{
+					this.rightClick = true;
+					return true;
+				}
+			}
+			
+			this.suppressRightTicks++;
+			this.suppressLeftTicks++;
+			return this.broker.onPlayerClickedBlock(player, MouseButton.RIGHT, position, side);
+		}
+
+		return true;
+	}
+}
@@ -42,6 +42,13 @@ public abstract class Methods
 	public static final MethodInfo doRenderShadowAndFire  = new MethodInfo(Obf.Render,                     Obf.doRenderShadowAndFire,        Void.TYPE, Obf.Entity, Double.TYPE, Double.TYPE, Double.TYPE, Float.TYPE, Float.TYPE);
 	public static final MethodInfo realmsPlay             = new MethodInfo(Obf.RealmsMainScreen,           "play",                           Void.TYPE, Long.TYPE);
 	public static final MethodInfo realmsStopFetcher      = new MethodInfo(Obf.RealmsMainScreen,           "stopRealmsFetcherAndPinger",     Void.TYPE);
+	public static final MethodInfo onBlockClicked         = new MethodInfo(Obf.ItemInWorldManager,         Obf.onBlockClicked,               Void.TYPE, Obf.BlockPos, Obf.EnumFacing);
+	public static final MethodInfo activateBlockOrUseItem = new MethodInfo(Obf.ItemInWorldManager,         Obf.activateBlockOrUseItem,       Boolean.TYPE, Obf.EntityPlayer, Obf.World, Obf.ItemStack, Obf.BlockPos, Obf.EnumFacing, Float.TYPE, Float.TYPE, Float.TYPE);
+	public static final MethodInfo processBlockPlacement  = new MethodInfo(Obf.NetHandlerPlayServer,       Obf.processPlayerBlockPlacement,  Void.TYPE, Packets.C08PacketPlayerBlockPlacement);
+	public static final MethodInfo handleAnimation        = new MethodInfo(Obf.NetHandlerPlayServer,       Obf.handleAnimation,              Void.TYPE, Packets.C0APacketAnimation);
+	public static final MethodInfo processPlayerDigging   = new MethodInfo(Obf.NetHandlerPlayServer,       Obf.processPlayerDigging,         Void.TYPE, Packets.C07PacketPlayerDigging);
+	public static final MethodInfo serverJobs             = new MethodInfo(Obf.MinecraftServer,            Obf.updateTimeLightAndEntities,   Void.TYPE);
+	public static final MethodInfo checkThreadAndEnqueue  = new MethodInfo(Obf.PacketThreadUtil,           Obf.checkThreadAndEnqueue);
 	// Profiler
 	public static final MethodInfo startSection           = new MethodInfo(Obf.Profiler,                   Obf.startSection,                 Void.TYPE, String.class);
+package com.mumfrey.liteloader.util;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+
+public abstract class EntityUtilities
+{
+	public static MovingObjectPosition rayTraceFromEntity(Entity entity, double traceDistance, float partialTicks)
+	{
+		Vec3 var4 = EntityUtilities.getPositionEyes(entity, partialTicks);
+		Vec3 var5 = entity.getLook(partialTicks);
+		Vec3 var6 = var4.addVector(var5.xCoord * traceDistance, var5.yCoord * traceDistance, var5.zCoord * traceDistance);
+		return entity.worldObj.rayTraceBlocks(var4, var6, false, false, true);
+	}
+	
+	public static Vec3 getPositionEyes(Entity entity, float partialTicks)
+	{
+		if (partialTicks == 1.0F)
+		{
+			return new Vec3(entity.posX, entity.posY + entity.getEyeHeight(), entity.posZ);
+		}
+		
+		double interpX = entity.prevPosX + (entity.posX - entity.prevPosX) * partialTicks;
+		double interpY = entity.prevPosY + (entity.posY - entity.prevPosY) * partialTicks + entity.getEyeHeight();
+		double interpZ = entity.prevPosZ + (entity.posZ - entity.prevPosZ) * partialTicks;
+		return new Vec3(interpX, interpY, interpZ);
+	}
+}