diff --git a/src/main/java/noppes/npcs/EventHooks.java b/src/main/java/noppes/npcs/EventHooks.java
index d880305bf..f1367a235 100644
--- a/src/main/java/noppes/npcs/EventHooks.java
+++ b/src/main/java/noppes/npcs/EventHooks.java
@@ -23,6 +23,7 @@ import noppes.npcs.controllers.data.ForgeDataScript;
 import noppes.npcs.controllers.data.PlayerDataScript;
 import noppes.npcs.entity.EntityNPCInterface;
 import noppes.npcs.scripted.*;
+import noppes.npcs.scripted.entity.ScriptPlayer;
 import noppes.npcs.scripted.event.*;
 import noppes.npcs.scripted.event.PlayerEvent.ChatEvent;
 import noppes.npcs.scripted.event.PlayerEvent.ContainerOpen;
@@ -53,14 +54,14 @@ public class EventHooks {
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerInit(PlayerDataScript handler) {
-        noppes.npcs.scripted.event.PlayerEvent.InitEvent event = new noppes.npcs.scripted.event.PlayerEvent.InitEvent(handler.getPlayer());
+    public static void onPlayerInit(PlayerDataScript handler, ScriptPlayer player) {
+        noppes.npcs.scripted.event.PlayerEvent.InitEvent event = new noppes.npcs.scripted.event.PlayerEvent.InitEvent(player);
         handler.callScript(EnumScriptType.INIT, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerTick(PlayerDataScript handler) {
-        noppes.npcs.scripted.event.PlayerEvent.UpdateEvent event = new noppes.npcs.scripted.event.PlayerEvent.UpdateEvent(handler.getPlayer());
+    public static void onPlayerTick(PlayerDataScript handler, ScriptPlayer player) {
+        noppes.npcs.scripted.event.PlayerEvent.UpdateEvent event = new noppes.npcs.scripted.event.PlayerEvent.UpdateEvent(player);
         handler.callScript(EnumScriptType.TICK, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
@@ -70,89 +71,89 @@ public class EventHooks {
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static boolean onStartUsingItem(PlayerDataScript handler, int duration, ItemStack item){
-        PlayerEvent.StartUsingItem event = new PlayerEvent.StartUsingItem(handler.getPlayer(), item, duration);
+    public static boolean onStartUsingItem(PlayerDataScript handler, ScriptPlayer player, int duration, ItemStack item){
+        PlayerEvent.StartUsingItem event = new PlayerEvent.StartUsingItem(player, item, duration);
         handler.callScript(EnumScriptType.START_USING_ITEM, event);
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static boolean onUsingItem(PlayerDataScript handler, int duration, ItemStack item){
-        PlayerEvent.UsingItem event = new PlayerEvent.UsingItem(handler.getPlayer(), item, duration);
+    public static boolean onUsingItem(PlayerDataScript handler, ScriptPlayer player, int duration, ItemStack item){
+        PlayerEvent.UsingItem event = new PlayerEvent.UsingItem(player, item, duration);
         handler.callScript(EnumScriptType.USING_ITEM, event);
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static boolean onStopUsingItem(PlayerDataScript handler, int duration, ItemStack item){
-        PlayerEvent.StopUsingItem event = new PlayerEvent.StopUsingItem(handler.getPlayer(), item, duration);
+    public static boolean onStopUsingItem(PlayerDataScript handler, ScriptPlayer player, int duration, ItemStack item){
+        PlayerEvent.StopUsingItem event = new PlayerEvent.StopUsingItem(player, item, duration);
         handler.callScript(EnumScriptType.STOP_USING_ITEM, event);
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onFinishUsingItem(PlayerDataScript handler, int duration, ItemStack item){
-        PlayerEvent.FinishUsingItem event = new PlayerEvent.FinishUsingItem(handler.getPlayer(), item, duration);
+    public static void onFinishUsingItem(PlayerDataScript handler, ScriptPlayer player, int duration, ItemStack item){
+        PlayerEvent.FinishUsingItem event = new PlayerEvent.FinishUsingItem(player, item, duration);
         handler.callScript(EnumScriptType.FINISH_USING_ITEM, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static boolean onPlayerDropItems(PlayerDataScript handler, ArrayList<EntityItem> entityItems) {
+    public static boolean onPlayerDropItems(PlayerDataScript handler, ScriptPlayer player, ArrayList<EntityItem> entityItems) {
         IItemStack[] items = new IItemStack[entityItems.size()];
         for(int i = 0; i < entityItems.size(); i++){ items[i] = NpcAPI.Instance().getIItemStack(entityItems.get(i).getEntityItem()); }
 
-        DropEvent event = new DropEvent(handler.getPlayer(), items);
+        DropEvent event = new DropEvent(player, items);
         handler.callScript(EnumScriptType.DROP, event);
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerPickupXP(PlayerDataScript handler, EntityXPOrb orb) {
-        PlayerEvent.PickupXPEvent event = new PlayerEvent.PickupXPEvent(handler.getPlayer(), orb);
+    public static void onPlayerPickupXP(PlayerDataScript handler, ScriptPlayer player, EntityXPOrb orb) {
+        PlayerEvent.PickupXPEvent event = new PlayerEvent.PickupXPEvent(player, orb);
         handler.callScript(EnumScriptType.PICKUP_XP, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static boolean onPlayerToss(PlayerDataScript handler, EntityItem entityItem) {
-        PlayerEvent.TossEvent event = new PlayerEvent.TossEvent(handler.getPlayer(), NpcAPI.Instance().getIItemStack(entityItem.getEntityItem()));
+    public static boolean onPlayerToss(PlayerDataScript handler, ScriptPlayer player, EntityItem entityItem) {
+        PlayerEvent.TossEvent event = new PlayerEvent.TossEvent(player, NpcAPI.Instance().getIItemStack(entityItem.getEntityItem()));
         handler.callScript(EnumScriptType.TOSS, event);
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static boolean onPlayerPickUp(PlayerDataScript handler, EntityItem entityItem) {
-        PickUpEvent event = new PickUpEvent(handler.getPlayer(), new ScriptItemStack(entityItem.getEntityItem()));//NpcAPI.Instance().getIItemStack(entityItem.getEntityItem()));
+    public static boolean onPlayerPickUp(PlayerDataScript handler, ScriptPlayer player, EntityItem entityItem) {
+        PickUpEvent event = new PickUpEvent(player, new ScriptItemStack(entityItem.getEntityItem()));//NpcAPI.Instance().getIItemStack(entityItem.getEntityItem()));
         handler.callScript(EnumScriptType.PICKUP, event);
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerContainerOpen(PlayerDataScript handler, Container container) {
-        ContainerOpen event = new ContainerOpen(handler.getPlayer(), NpcAPI.Instance().getIContainer(container));
+    public static void onPlayerContainerOpen(PlayerDataScript handler, ScriptPlayer player, Container container) {
+        ContainerOpen event = new ContainerOpen(player, NpcAPI.Instance().getIContainer(container));
         handler.callScript(EnumScriptType.CONTAINER_OPEN, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerUseHoe(PlayerDataScript handler, ItemStack hoe, int x, int y, int z) {
-        noppes.npcs.scripted.event.PlayerEvent.UseHoe event = new noppes.npcs.scripted.event.PlayerEvent.UseHoe(handler.getPlayer(), hoe, x, y, z);
+    public static void onPlayerUseHoe(PlayerDataScript handler, ScriptPlayer player, ItemStack hoe, int x, int y, int z) {
+        noppes.npcs.scripted.event.PlayerEvent.UseHoe event = new noppes.npcs.scripted.event.PlayerEvent.UseHoe(player, hoe, x, y, z);
         handler.callScript(EnumScriptType.USE_HOE, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerSleep(PlayerDataScript handler, int x, int y, int z) {
-        noppes.npcs.scripted.event.PlayerEvent.Sleep event = new noppes.npcs.scripted.event.PlayerEvent.Sleep(handler.getPlayer(), x, y, z);
+    public static void onPlayerSleep(PlayerDataScript handler, ScriptPlayer player, int x, int y, int z) {
+        noppes.npcs.scripted.event.PlayerEvent.Sleep event = new noppes.npcs.scripted.event.PlayerEvent.Sleep(player, x, y, z);
         handler.callScript(EnumScriptType.SLEEP, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerWakeUp(PlayerDataScript handler, boolean setSpawn) {
-        noppes.npcs.scripted.event.PlayerEvent.WakeUp event = new noppes.npcs.scripted.event.PlayerEvent.WakeUp(handler.getPlayer(), setSpawn);
+    public static void onPlayerWakeUp(PlayerDataScript handler, ScriptPlayer player, boolean setSpawn) {
+        noppes.npcs.scripted.event.PlayerEvent.WakeUp event = new noppes.npcs.scripted.event.PlayerEvent.WakeUp(player, setSpawn);
         handler.callScript(EnumScriptType.WAKE_UP, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerDeath(PlayerDataScript handler, DamageSource source, Entity entity) {
-        noppes.npcs.scripted.event.PlayerEvent.DiedEvent event = new noppes.npcs.scripted.event.PlayerEvent.DiedEvent(handler.getPlayer(), source, entity);
+    public static void onPlayerDeath(PlayerDataScript handler, ScriptPlayer player, DamageSource source, Entity entity) {
+        noppes.npcs.scripted.event.PlayerEvent.DiedEvent event = new noppes.npcs.scripted.event.PlayerEvent.DiedEvent(player, source, entity);
         handler.callScript(EnumScriptType.KILLED, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerKills(PlayerDataScript handler, EntityLivingBase entityLiving) {
-        noppes.npcs.scripted.event.PlayerEvent.KilledEntityEvent event = new noppes.npcs.scripted.event.PlayerEvent.KilledEntityEvent(handler.getPlayer(), entityLiving);
+    public static void onPlayerKills(PlayerDataScript handler, ScriptPlayer player, EntityLivingBase entityLiving) {
+        noppes.npcs.scripted.event.PlayerEvent.KilledEntityEvent event = new noppes.npcs.scripted.event.PlayerEvent.KilledEntityEvent(player, entityLiving);
         handler.callScript(EnumScriptType.KILLS, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
@@ -162,62 +163,62 @@ public class EventHooks {
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static boolean onPlayerLightning(PlayerDataScript handler) {
-        PlayerEvent.LightningEvent event = new PlayerEvent.LightningEvent(handler.getPlayer());
+    public static boolean onPlayerLightning(PlayerDataScript handler, ScriptPlayer player) {
+        PlayerEvent.LightningEvent event = new PlayerEvent.LightningEvent(player);
         handler.callScript(EnumScriptType.LIGHTNING, event);
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static boolean onPlayerSound(PlayerDataScript handler, String name, float pitch, float volume) {
-        PlayerEvent.SoundEvent event = new PlayerEvent.SoundEvent(handler.getPlayer(), name, pitch, volume);
+    public static boolean onPlayerSound(PlayerDataScript handler, ScriptPlayer player, String name, float pitch, float volume) {
+        PlayerEvent.SoundEvent event = new PlayerEvent.SoundEvent(player, name, pitch, volume);
         handler.callScript(EnumScriptType.PLAYSOUND, event);
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerFall(PlayerDataScript handler, float distance) {
-        PlayerEvent.FallEvent event = new PlayerEvent.FallEvent(handler.getPlayer(),distance);
+    public static void onPlayerFall(PlayerDataScript handler, ScriptPlayer player, float distance) {
+        PlayerEvent.FallEvent event = new PlayerEvent.FallEvent(player,distance);
         handler.callScript(EnumScriptType.FALL, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerJump(PlayerDataScript handler) {
-        PlayerEvent.JumpEvent event = new PlayerEvent.JumpEvent(handler.getPlayer());
+    public static void onPlayerJump(PlayerDataScript handler, ScriptPlayer player) {
+        PlayerEvent.JumpEvent event = new PlayerEvent.JumpEvent(player);
         handler.callScript(EnumScriptType.JUMP, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerLogin(PlayerDataScript handler) {
-        LoginEvent event = new LoginEvent(handler.getPlayer());
+    public static void onPlayerLogin(PlayerDataScript handler, ScriptPlayer player) {
+        LoginEvent event = new LoginEvent(player);
         handler.callScript(EnumScriptType.LOGIN, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerAchievement(PlayerDataScript handler, String description) {
-        PlayerEvent.Achievement event = new PlayerEvent.Achievement(handler.getPlayer(), description);
+    public static void onPlayerAchievement(PlayerDataScript handler, ScriptPlayer player, String description) {
+        PlayerEvent.Achievement event = new PlayerEvent.Achievement(player, description);
         handler.callScript(EnumScriptType.ACHIEVEMENT, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerFillBucket(PlayerDataScript handler, ItemStack current, ItemStack result) {
-        PlayerEvent.FillBucket event = new PlayerEvent.FillBucket(handler.getPlayer(), current, result);
+    public static void onPlayerFillBucket(PlayerDataScript handler, ScriptPlayer player, ItemStack current, ItemStack result) {
+        PlayerEvent.FillBucket event = new PlayerEvent.FillBucket(player, current, result);
         handler.callScript(EnumScriptType.FILL_BUCKET, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerBonemeal(PlayerDataScript handler, int x, int y, int z, World world) {
-        PlayerEvent.Bonemeal event = new PlayerEvent.Bonemeal(handler.getPlayer(), x, y, z, world);
+    public static void onPlayerBonemeal(PlayerDataScript handler, ScriptPlayer player, int x, int y, int z, World world) {
+        PlayerEvent.Bonemeal event = new PlayerEvent.Bonemeal(player, x, y, z, world);
         handler.callScript(EnumScriptType.BONEMEAL, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerRespawn(PlayerDataScript handler) {
-        PlayerEvent.RespawnEvent event = new PlayerEvent.RespawnEvent(handler.getPlayer());
+    public static void onPlayerRespawn(PlayerDataScript handler, ScriptPlayer player) {
+        PlayerEvent.RespawnEvent event = new PlayerEvent.RespawnEvent(player);
         handler.callScript(EnumScriptType.RESPAWN, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerLogout(PlayerDataScript handler) {
-        LogoutEvent event = new LogoutEvent(handler.getPlayer());
+    public static void onPlayerLogout(PlayerDataScript handler, ScriptPlayer player) {
+        LogoutEvent event = new LogoutEvent(player);
         handler.callScript(EnumScriptType.LOGOUT, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
@@ -242,29 +243,29 @@ public class EventHooks {
         return WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
-    public static void onPlayerChangeDim(PlayerDataScript handler, int fromDim, int toDim) {
-        PlayerEvent.ChangedDimension event = new PlayerEvent.ChangedDimension(handler.getPlayer(), fromDim, toDim);
+    public static void onPlayerChangeDim(PlayerDataScript handler, ScriptPlayer player, int fromDim, int toDim) {
+        PlayerEvent.ChangedDimension event = new PlayerEvent.ChangedDimension(player, fromDim, toDim);
         handler.callScript(EnumScriptType.CHANGED_DIM, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
     public static void onPlayerMouseClicked(EntityPlayerMP player, int button, int mouseWheel, boolean buttonDown) {
-        PlayerDataScript handler = PlayerData.get(player).scriptData;
-        PlayerEvent.MouseClickedEvent event = new PlayerEvent.MouseClickedEvent(handler.getPlayer(), button, mouseWheel, buttonDown);
+        PlayerDataScript handler = ScriptController.Instance.playerScripts;
+        PlayerEvent.MouseClickedEvent event = new PlayerEvent.MouseClickedEvent((ScriptPlayer)ScriptController.Instance.getScriptForEntity(player), button, mouseWheel, buttonDown);
         handler.callScript(EnumScriptType.MOUSE_CLICKED, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
     public static void onPlayerKeyPressed(EntityPlayerMP player, int button, boolean isCtrlPressed, boolean isShiftPressed, boolean isAltPressed, boolean isMetaPressed, boolean buttonDown) {
-        PlayerDataScript handler = PlayerData.get(player).scriptData;
-        KeyPressedEvent event = new KeyPressedEvent(handler.getPlayer(), button, isCtrlPressed, isAltPressed, isShiftPressed, isMetaPressed, buttonDown);
+        PlayerDataScript handler = ScriptController.Instance.playerScripts;
+        KeyPressedEvent event = new KeyPressedEvent((ScriptPlayer)ScriptController.Instance.getScriptForEntity(player), button, isCtrlPressed, isAltPressed, isShiftPressed, isMetaPressed, buttonDown);
         handler.callScript(EnumScriptType.KEY_PRESSED, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
 
     public static void onPlayerTimer(PlayerData data, int id) {
-        PlayerDataScript handler = data.scriptData;
-        noppes.npcs.scripted.event.PlayerEvent.TimerEvent event = new noppes.npcs.scripted.event.PlayerEvent.TimerEvent(handler.getPlayer(), id);
+        PlayerDataScript handler = ScriptController.Instance.playerScripts;
+        noppes.npcs.scripted.event.PlayerEvent.TimerEvent event = new noppes.npcs.scripted.event.PlayerEvent.TimerEvent((ScriptPlayer)ScriptController.Instance.getScriptForEntity(data.player), id);
         handler.callScript(EnumScriptType.TIMER, event);
         WrapperNpcAPI.EVENT_BUS.post(event);
     }
diff --git a/src/main/java/noppes/npcs/ScriptPlayerEventHandler.java b/src/main/java/noppes/npcs/ScriptPlayerEventHandler.java
index 1a5628905..334c63465 100644
--- a/src/main/java/noppes/npcs/ScriptPlayerEventHandler.java
+++ b/src/main/java/noppes/npcs/ScriptPlayerEventHandler.java
@@ -51,6 +51,7 @@ import noppes.npcs.controllers.PlayerDataController;
 import noppes.npcs.controllers.data.PlayerDataScript;
 import noppes.npcs.entity.EntityNPCInterface;
 import noppes.npcs.scripted.NpcAPI;
+import noppes.npcs.scripted.entity.ScriptPlayer;
 import noppes.npcs.scripted.event.ForgeEvent;
 import noppes.npcs.controllers.PixelmonHelper;
 import noppes.npcs.controllers.ScriptController;
@@ -63,13 +64,14 @@ public class ScriptPlayerEventHandler {
     public void onServerTick(TickEvent.PlayerTickEvent event) {
         if(event.side == Side.SERVER && event.phase == TickEvent.Phase.START) {
             EntityPlayer player = event.player;
-            PlayerData data = PlayerData.get(player);
 
-            if(player.ticksExisted%10 == 0)
-                EventHooks.onPlayerTick(data.scriptData);
+            if(player.ticksExisted%10 == 0) {
+                PlayerDataScript handler = ScriptController.Instance.playerScripts;
+                ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(player);
+                EventHooks.onPlayerTick(handler, scriptPlayer);
+            }
 
             if(PlayerDataController.instance != null) {
-                PlayerDataController.instance.getPlayerData(player).scriptData = data.scriptData;
                 if(PlayerDataController.instance.getPlayerData(player).timers.size() > 0)
                     PlayerDataController.instance.getPlayerData(player).timers.update();
             }
@@ -79,8 +81,9 @@ public class ScriptPlayerEventHandler {
     @SubscribeEvent
     public void invoke(EntityInteractEvent event) {
         if(!event.entityPlayer.worldObj.isRemote && event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            noppes.npcs.scripted.event.PlayerEvent.InteractEvent ev = new noppes.npcs.scripted.event.PlayerEvent.InteractEvent(handler.getPlayer(), 1, NpcAPI.Instance().getIEntity(event.target));
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            noppes.npcs.scripted.event.PlayerEvent.InteractEvent ev = new noppes.npcs.scripted.event.PlayerEvent.InteractEvent(scriptPlayer, 1, NpcAPI.Instance().getIEntity(event.target));
             event.setCanceled(EventHooks.onPlayerInteract(handler, ev));
         }
     }
@@ -88,8 +91,9 @@ public class ScriptPlayerEventHandler {
     @SubscribeEvent
     public void invoke(ArrowNockEvent event) {
         if(!event.entityPlayer.worldObj.isRemote && event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            noppes.npcs.scripted.event.PlayerEvent.RangedChargeEvent ev = new noppes.npcs.scripted.event.PlayerEvent.RangedChargeEvent(handler.getPlayer());
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            noppes.npcs.scripted.event.PlayerEvent.RangedChargeEvent ev = new noppes.npcs.scripted.event.PlayerEvent.RangedChargeEvent(scriptPlayer);
             EventHooks.onPlayerBowCharge(handler, ev);
         }
     }
@@ -97,8 +101,9 @@ public class ScriptPlayerEventHandler {
     @SubscribeEvent
     public void invoke(ArrowLooseEvent event) {
         if(!event.entityPlayer.worldObj.isRemote && event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            noppes.npcs.scripted.event.PlayerEvent.RangedLaunchedEvent ev = new noppes.npcs.scripted.event.PlayerEvent.RangedLaunchedEvent(handler.getPlayer(), event.bow, event.charge);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            noppes.npcs.scripted.event.PlayerEvent.RangedLaunchedEvent ev = new noppes.npcs.scripted.event.PlayerEvent.RangedLaunchedEvent(scriptPlayer, event.bow, event.charge);
             EventHooks.onPlayerRanged(handler, ev);
         }
     }
@@ -106,8 +111,9 @@ public class ScriptPlayerEventHandler {
     @SubscribeEvent
     public void invoke(BlockEvent.BreakEvent event) {
         if(!event.getPlayer().worldObj.isRemote && event.world instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.getPlayer()).scriptData;
-            noppes.npcs.scripted.event.PlayerEvent.BreakEvent ev = new noppes.npcs.scripted.event.PlayerEvent.BreakEvent(handler.getPlayer(), NpcAPI.Instance().getIBlock(event.world, new BlockPos(event.x,event.y,event.z)), event.getExpToDrop());
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.getPlayer());
+            noppes.npcs.scripted.event.PlayerEvent.BreakEvent ev = new noppes.npcs.scripted.event.PlayerEvent.BreakEvent(scriptPlayer, NpcAPI.Instance().getIBlock(event.world, new BlockPos(event.x,event.y,event.z)), event.getExpToDrop());
             event.setCanceled(EventHooks.onPlayerBreak(handler, ev));
             event.setExpToDrop(ev.exp);
         }
@@ -116,135 +122,151 @@ public class ScriptPlayerEventHandler {
     @SubscribeEvent
     public void invoke(PlayerUseItemEvent.Start event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            event.setCanceled(EventHooks.onStartUsingItem(handler, event.duration, event.item));
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            event.setCanceled(EventHooks.onStartUsingItem(handler, scriptPlayer, event.duration, event.item));
         }
     }
     @SubscribeEvent
     public void invoke(PlayerUseItemEvent.Tick event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            event.setCanceled(EventHooks.onUsingItem(handler, event.duration, event.item));
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            event.setCanceled(EventHooks.onUsingItem(handler, scriptPlayer, event.duration, event.item));
         }
     }
     @SubscribeEvent
     public void invoke(PlayerUseItemEvent.Stop event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            event.setCanceled(EventHooks.onStopUsingItem(handler, event.duration, event.item));
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            event.setCanceled(EventHooks.onStopUsingItem(handler, scriptPlayer, event.duration, event.item));
         }
     }
     @SubscribeEvent
     public void invoke(PlayerUseItemEvent.Finish event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            EventHooks.onFinishUsingItem(handler, event.duration, event.item);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            EventHooks.onFinishUsingItem(handler, scriptPlayer, event.duration, event.item);
         }
     }
 
     @SubscribeEvent
     public void invoke(PlayerDropsEvent event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            event.setCanceled(EventHooks.onPlayerDropItems(handler, event.drops));
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            event.setCanceled(EventHooks.onPlayerDropItems(handler, scriptPlayer, event.drops));
         }
     }
 
     @SubscribeEvent
     public void invoke(PlayerPickupXpEvent event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            EventHooks.onPlayerPickupXP(handler, event.orb);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            EventHooks.onPlayerPickupXP(handler, scriptPlayer, event.orb);
         }
     }
 
     @SubscribeEvent
     public void invoke(PlayerEvent.PlayerChangedDimensionEvent event) {
         if(event.player.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.player).scriptData;
-            EventHooks.onPlayerChangeDim(handler, event.fromDim, event.toDim);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.player);
+            EventHooks.onPlayerChangeDim(handler, scriptPlayer, event.fromDim, event.toDim);
         }
     }
 
     @SubscribeEvent
     public void invoke(PlayerEvent.ItemPickupEvent event) {
         if(event.player.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.player).scriptData;
-            EventHooks.onPlayerPickUp(handler, event.pickedUp);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.player);
+            EventHooks.onPlayerPickUp(handler, scriptPlayer, event.pickedUp);
         }
     }
 
     @SubscribeEvent
     public void invoke(PlayerOpenContainerEvent event) {
         if(event.entityPlayer.worldObj instanceof WorldServer && !(event.entityPlayer.openContainer instanceof ContainerPlayer)) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            EventHooks.onPlayerContainerOpen(handler, event.entityPlayer.openContainer);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            EventHooks.onPlayerContainerOpen(handler, scriptPlayer, event.entityPlayer.openContainer);
         }
     }
 
     @SubscribeEvent
     public void invoke(UseHoeEvent event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            EventHooks.onPlayerUseHoe(handler, event.current, event.x, event.y, event.z);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            EventHooks.onPlayerUseHoe(handler, scriptPlayer, event.current, event.x, event.y, event.z);
         }
     }
 
     @SubscribeEvent
     public void invoke(PlayerSleepInBedEvent event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            EventHooks.onPlayerSleep(handler, event.x, event.y, event.z);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            EventHooks.onPlayerSleep(handler, scriptPlayer, event.x, event.y, event.z);
         }
     }
 
     @SubscribeEvent
     public void invoke(PlayerWakeUpEvent event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            EventHooks.onPlayerWakeUp(handler, event.setSpawn);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            EventHooks.onPlayerWakeUp(handler, scriptPlayer, event.setSpawn);
         }
     }
 
     @SubscribeEvent
     public void invoke(FillBucketEvent event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            EventHooks.onPlayerFillBucket(handler, event.current, event.result);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            EventHooks.onPlayerFillBucket(handler, scriptPlayer, event.current, event.result);
         }
     }
 
     @SubscribeEvent
     public void invoke(BonemealEvent event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            EventHooks.onPlayerBonemeal(handler, event.x, event.y, event.z, event.world);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            EventHooks.onPlayerBonemeal(handler, scriptPlayer, event.x, event.y, event.z, event.world);
         }
     }
 
     @SubscribeEvent
     public void invoke(AchievementEvent event) {
         if(event.entityPlayer.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.entityPlayer).scriptData;
-            EventHooks.onPlayerAchievement(handler, CustomNpcs.proxy.getAchievementDesc(event.achievement));
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityPlayer);
+            EventHooks.onPlayerAchievement(handler, scriptPlayer, CustomNpcs.proxy.getAchievementDesc(event.achievement));
         }
     }
 
     @SubscribeEvent
     public void invoke(ItemTossEvent event) {
         if(event.player.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.player).scriptData;
-            EventHooks.onPlayerToss(handler, event.entityItem);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.player);
+            EventHooks.onPlayerToss(handler, scriptPlayer, event.entityItem);
         }
     }
 
     @SubscribeEvent
     public void invoke(LivingFallEvent event) {
         if(event.entityLiving.worldObj instanceof WorldServer) {
-            PlayerDataScript handler;
             if (event.entityLiving instanceof EntityPlayer) {
-                handler = PlayerData.get((EntityPlayer)event.entityLiving).scriptData;
-                EventHooks.onPlayerFall(handler, event.distance);
+                PlayerDataScript handler = ScriptController.Instance.playerScripts;
+                ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityLiving);
+                EventHooks.onPlayerFall(handler, scriptPlayer, event.distance);
             }
         }
     }
@@ -252,10 +274,10 @@ public class ScriptPlayerEventHandler {
     @SubscribeEvent
     public void invoke(LivingEvent.LivingJumpEvent event) {
         if(event.entityLiving.worldObj instanceof WorldServer) {
-            PlayerDataScript handler;
             if (event.entityLiving instanceof EntityPlayer) {
-                handler = PlayerData.get((EntityPlayer)event.entityLiving).scriptData;
-                EventHooks.onPlayerJump(handler);
+                PlayerDataScript handler = ScriptController.Instance.playerScripts;
+                ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityLiving);
+                EventHooks.onPlayerJump(handler, scriptPlayer);
             }
         }
     }
@@ -263,10 +285,10 @@ public class ScriptPlayerEventHandler {
     @SubscribeEvent
     public void invoke(EntityStruckByLightningEvent event) {
         if(event.entity.worldObj instanceof WorldServer) {
-            PlayerDataScript handler;
             if (event.entity instanceof EntityPlayer) {
-                handler = PlayerData.get((EntityPlayer)event.entity).scriptData;
-                EventHooks.onPlayerLightning(handler);
+                PlayerDataScript handler = ScriptController.Instance.playerScripts;
+                ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entity);
+                EventHooks.onPlayerLightning(handler, scriptPlayer);
             }
         }
     }
@@ -274,10 +296,10 @@ public class ScriptPlayerEventHandler {
     @SubscribeEvent
     public void invoke(PlaySoundAtEntityEvent event) {
         if(event.entity.worldObj instanceof WorldServer) {
-            PlayerDataScript handler;
             if (event.entity instanceof EntityPlayer) {
-                handler = PlayerData.get((EntityPlayer)event.entity).scriptData;
-                EventHooks.onPlayerSound(handler,event.name,event.pitch,event.volume);
+                PlayerDataScript handler = ScriptController.Instance.playerScripts;
+                ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entity);
+                EventHooks.onPlayerSound(handler,scriptPlayer,event.name,event.pitch,event.volume);
             }
         }
     }
@@ -286,15 +308,15 @@ public class ScriptPlayerEventHandler {
     public void invoke(LivingDeathEvent event) {
         if(event.entityLiving.worldObj instanceof WorldServer) {
             Entity source = NoppesUtilServer.GetDamageSourcee(event.source);
-            PlayerDataScript handler;
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
             if(event.entityLiving instanceof EntityPlayer) {
-                handler = PlayerData.get((EntityPlayer)event.entityLiving).scriptData;
-                EventHooks.onPlayerDeath(handler, event.source, source);
+                ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.entityLiving);
+                EventHooks.onPlayerDeath(handler,scriptPlayer, event.source, source);
             }
 
             if(source instanceof EntityPlayer) {
-                handler = PlayerData.get((EntityPlayer)source).scriptData;
-                EventHooks.onPlayerKills(handler, event.entityLiving);
+                ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.source.getEntity());
+                EventHooks.onPlayerKills(handler,scriptPlayer, event.entityLiving);
             }
 
         }
@@ -304,17 +326,15 @@ public class ScriptPlayerEventHandler {
     public void invoke(LivingHurtEvent event) {
         if(event.entityLiving.worldObj instanceof WorldServer) {
             Entity source = NoppesUtilServer.GetDamageSourcee(event.source);
-            PlayerDataScript handler;
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
             if(event.entityLiving instanceof EntityPlayer) {
-                handler = PlayerData.get((EntityPlayer)event.entityLiving).scriptData;
-                noppes.npcs.scripted.event.PlayerEvent.DamagedEvent pevent = new noppes.npcs.scripted.event.PlayerEvent.DamagedEvent(handler.getPlayer(), source, event.ammount, event.source);
+                noppes.npcs.scripted.event.PlayerEvent.DamagedEvent pevent = new noppes.npcs.scripted.event.PlayerEvent.DamagedEvent((ScriptPlayer)ScriptController.Instance.getScriptForEntity((EntityPlayer)event.entityLiving), source, event.ammount, event.source);
                 event.setCanceled(EventHooks.onPlayerDamaged(handler, pevent));
                 event.ammount = pevent.damage;
             }
 
             if(source instanceof EntityPlayer) {
-                handler = PlayerData.get((EntityPlayer)source).scriptData;
-                noppes.npcs.scripted.event.PlayerEvent.DamagedEntityEvent pevent1 = new noppes.npcs.scripted.event.PlayerEvent.DamagedEntityEvent(handler.getPlayer(), event.entityLiving, event.ammount, event.source);
+                noppes.npcs.scripted.event.PlayerEvent.DamagedEntityEvent pevent1 = new noppes.npcs.scripted.event.PlayerEvent.DamagedEntityEvent((ScriptPlayer)ScriptController.Instance.getScriptForEntity((EntityPlayer)event.source.getEntity()), event.entityLiving, event.ammount, event.source);
                 event.setCanceled(EventHooks.onPlayerDamagedEntity(handler, pevent1));
                 event.ammount = pevent1.damage;
             }
@@ -325,24 +345,27 @@ public class ScriptPlayerEventHandler {
     @SubscribeEvent
     public void invoke(PlayerEvent.PlayerRespawnEvent event) {
         if(event.player.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.player).scriptData;
-            EventHooks.onPlayerRespawn(handler);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.player);
+            EventHooks.onPlayerRespawn(handler, scriptPlayer);
         }
     }
 
     @SubscribeEvent
     public void invoke(PlayerEvent.PlayerLoggedInEvent event) {
         if(event.player.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.player).scriptData;
-            EventHooks.onPlayerLogin(handler);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.player);
+            EventHooks.onPlayerLogin(handler, scriptPlayer);
         }
     }
 
     @SubscribeEvent
     public void invoke(PlayerEvent.PlayerLoggedOutEvent event) {
         if(event.player.worldObj instanceof WorldServer) {
-            PlayerDataScript handler = PlayerData.get(event.player).scriptData;
-            EventHooks.onPlayerLogout(handler);
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.player);
+            EventHooks.onPlayerLogout(handler, scriptPlayer);
         }
     }
 
@@ -351,9 +374,10 @@ public class ScriptPlayerEventHandler {
     )
     public void invoke(net.minecraftforge.event.ServerChatEvent event) {
         if(event.player.worldObj instanceof WorldServer && !event.player.equals(EntityNPCInterface.chateventPlayer)) {
-            PlayerDataScript handler = PlayerData.get(event.player).scriptData;
+            PlayerDataScript handler = ScriptController.Instance.playerScripts;
+            ScriptPlayer scriptPlayer = (ScriptPlayer) ScriptController.Instance.getScriptForEntity(event.player);
             String message = event.message;
-            noppes.npcs.scripted.event.PlayerEvent.ChatEvent ev = new noppes.npcs.scripted.event.PlayerEvent.ChatEvent(handler.getPlayer(), event.message);
+            noppes.npcs.scripted.event.PlayerEvent.ChatEvent ev = new noppes.npcs.scripted.event.PlayerEvent.ChatEvent(scriptPlayer, event.message);
             EventHooks.onPlayerChat(handler, ev);
             event.setCanceled(ev.isCanceled());
             if(!message.equals(ev.message)) {
diff --git a/src/main/java/noppes/npcs/controllers/PlayerData.java b/src/main/java/noppes/npcs/controllers/PlayerData.java
index ec37e4cb4..28b018239 100644
--- a/src/main/java/noppes/npcs/controllers/PlayerData.java
+++ b/src/main/java/noppes/npcs/controllers/PlayerData.java
@@ -28,7 +28,6 @@ public class PlayerData implements IExtendedEntityProperties{
 	public PlayerFactionData factionData = new PlayerFactionData();
 	public PlayerItemGiverData itemgiverData = new PlayerItemGiverData();
 	public PlayerMailData mailData = new PlayerMailData();
-	public PlayerDataScript scriptData;
 	public DataTimers timers = new DataTimers(this);
 
 	public EntityNPCInterface editingNpc;
@@ -232,7 +231,6 @@ public class PlayerData implements IExtendedEntityProperties{
 			PlayerData data = new PlayerData();
 			if (data.player == null) {
 				data.player = player;
-				data.scriptData = new PlayerDataScript(player);
 				NBTTagCompound compound = loadPlayerData(player.getPersistentID().toString());
 				if (compound.hasNoTags()) {
 					compound = loadPlayerDataOld(player.getCommandSenderName());
diff --git a/src/main/java/noppes/npcs/controllers/data/PlayerDataScript.java b/src/main/java/noppes/npcs/controllers/data/PlayerDataScript.java
index 288e35846..b3614e6b9 100644
--- a/src/main/java/noppes/npcs/controllers/data/PlayerDataScript.java
+++ b/src/main/java/noppes/npcs/controllers/data/PlayerDataScript.java
@@ -20,6 +20,7 @@ import noppes.npcs.scripted.NpcAPI;
 import noppes.npcs.constants.EnumScriptType;
 import noppes.npcs.controllers.IScriptHandler;
 import noppes.npcs.controllers.ScriptController;
+import noppes.npcs.scripted.entity.ScriptPlayer;
 import noppes.npcs.scripted.event.PlayerEvent;
 import noppes.npcs.scripted.interfaces.IPlayer;
 import noppes.npcs.scripted.interfaces.IWorld;
@@ -33,19 +34,13 @@ public class PlayerDataScript implements IScriptHandler {
     private IPlayer playerAPI;
     private long lastPlayerUpdate = 0L;
     public long lastInited = -1L;
-    public boolean hadInteract = true;
     public boolean enabled = false;
     private Map<Long, String> console = new TreeMap();
     public List<Integer> errored = new ArrayList();
-    public IPlayer dummyPlayer;
-    public IWorld dummyWorld;
+
     public PlayerDataScript(EntityPlayer player) {
         if(player != null) {
             this.player = player;
-            if (player instanceof EntityPlayer)
-                dummyPlayer = (IPlayer) ScriptController.Instance.getScriptForEntity(this.player);
-            if (player.worldObj instanceof WorldServer)
-                dummyWorld = (IWorld) NpcAPI.Instance().getIWorld((WorldServer) this.player.worldObj);
         }
     }
     public void clear() {
@@ -73,27 +68,17 @@ public class PlayerDataScript implements IScriptHandler {
             if (ScriptController.Instance.lastLoaded > this.lastInited || ScriptController.Instance.lastPlayerUpdate > this.lastPlayerUpdate) {
                 this.lastInited = ScriptController.Instance.lastLoaded;
                 errored.clear();
-                if(this.player != null) {
-                    this.scripts.clear();
-                    Iterator i = ScriptController.Instance.playerScripts.scripts.iterator();
-
-                    while(i.hasNext()) {
-                        script = (ScriptContainer)i.next();
-                        ScriptContainer s = new ScriptContainer(this);
-                        s.readFromNBT(script.writeToNBT(new NBTTagCompound()));
-
-                        this.scripts.add(s);
-                    }
-                }
 
                 this.lastPlayerUpdate = ScriptController.Instance.lastPlayerUpdate;
+
                 if (type != EnumScriptType.INIT) {
-                    EventHooks.onPlayerInit(this);
+                    noppes.npcs.scripted.event.PlayerEvent playerEvent = (noppes.npcs.scripted.event.PlayerEvent)event;
+                    EventHooks.onPlayerInit(this, (ScriptPlayer) playerEvent.player);
                 }
             }
 
-            for(int i = 0; i < this.scripts.size(); ++i) {
-                script = (ScriptContainer)this.scripts.get(i);
+            for(int i = 0; i < ScriptController.Instance.playerScripts.scripts.size(); ++i) {
+                script = (ScriptContainer)ScriptController.Instance.playerScripts.scripts.get(i);
                 if (!errored.contains(i)) {
                     if(script == null || script.errored || !script.hasCode() || ScriptController.Instance.playerScripts.errored.contains(i))
                         return;