minecraft-kajetans-mod/src/main/java/me/km/snuviscript/ScriptEvents.java

package me.km.snuviscript;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import me.km.KajetansMod;
import me.km.api.Location;
import me.km.api.ModuleListener;
import me.km.api.Module;
import me.km.api.Utils;
import me.km.effects.PlayerUsesEffectEvent;
import me.km.events.PlayerHurtEvent;
import me.km.events.PlayerJoinMessageEvent;
import me.km.events.PlayerLeaveMessageEvent;
import me.km.events.PlayerMoveEvent;
import me.km.events.PlayerRespawnAtEvent;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.passive.EntitySheep;
import net.minecraft.entity.passive.EntityVillager;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.inventory.ClickType;
import net.minecraft.item.ItemStack;
import net.minecraft.server.management.PlayerList;
import net.minecraft.util.EnumHand;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.RayTraceResult;
import net.minecraft.world.WorldServer;
import net.minecraftforge.event.CommandEvent;
import net.minecraftforge.event.entity.EntityMountEvent;
import net.minecraftforge.event.entity.ThrowableImpactEvent;
import net.minecraftforge.event.entity.item.ItemTossEvent;
import net.minecraftforge.event.entity.living.*;
import net.minecraftforge.event.entity.player.EntityItemPickupEvent;
import net.minecraftforge.event.entity.player.FillBucketEvent;
import net.minecraftforge.event.entity.player.ItemFishedEvent;
import net.minecraftforge.event.entity.player.PlayerDropsEvent;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.world.BlockEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.PlayerEvent;

public class ScriptEvents extends ModuleListener
{               
    private final HashMap<UUID, UUID> questJoin;
                 
    public ScriptEvents(Module m)
    {    
        super(m);
        questJoin = new HashMap<>();
    }  
    
    // -------------------------------------------------------------------------
    // Basics
    // -------------------------------------------------------------------------
        
    private void doInEvent(Script data, EntityPlayer p, String event, Consumer<Script> before, Consumer<Script> after)
    {
        data.setVar("event", event);
        if(p != null)
        {
            ScriptVars.setPlayerVars(data, p); 
        }
        if(before != null)
        {
            before.accept(data);
        }
        data.runCode();
        if(after != null)
        {
            after.accept(data);
        }
    }
    
    private void handleEvent(EntityPlayer p, String event, Predicate<? super Script> pre, Consumer<Script> before, Consumer<Script> after)
    {      
        KajetansMod.scripts.getScripts().stream().filter(pre).filter(qd -> qd.isEventLoaded(event)).forEach(data -> 
        {
            doInEvent(data, p, event, before, after);
        });
        
        if(p != null && KajetansMod.scripts.hasQuest(p))
        {
            Script data = KajetansMod.scripts.getQuestData(p);
            if(data != null && data.isEventLoaded(event) && pre.test(data))
            {
                doInEvent(data, p, event, before, after);
            }
        }      
    }
    
    private void handleEvent(EntityPlayer p, String event, Consumer<Script> before, Consumer<Script> after)
    {      
        handleEvent(p, event, (qd) -> true, before, after);    
    }
    
    private void handleEvent(EntityPlayer p, String event, Consumer<Script> before)
    {      
        handleEvent(p, event, before, null);
    }
         
    // -------------------------------------------------------------------------
    // Questevents
    // -------------------------------------------------------------------------
    
    @SubscribeEvent
    public void joinOtherPlayersQuests(PlayerInteractEvent.EntityInteract e)
    {              
        if(e.getHand() == EnumHand.OFF_HAND || !(e.getTarget() instanceof EntityPlayer))
        {
            return;
        }
        EntityPlayer p = e.getEntityPlayer();   
        EntityPlayer affectedPlayer = (EntityPlayer) e.getTarget();
        if(KajetansMod.scripts.hasQuest(p) && !KajetansMod.scripts.hasQuest(affectedPlayer))
        {
            if(questJoin.get(affectedPlayer.getUniqueID()) != null)
            {
                if(questJoin.get(affectedPlayer.getUniqueID()).equals(p.getUniqueID()))
                {
                    return;
                }
            }           
            questJoin.put(affectedPlayer.getUniqueID(), p.getUniqueID());
            this.getModule().send(affectedPlayer, p.getName() + " fragt dich, ob du seiner Quest beitreten willst.");
            this.getModule().send(p, affectedPlayer.getName() + " wurde eine Anfrage gesendet.");
            return;
        }
        if(!KajetansMod.scripts.hasQuest(p) && questJoin.get(p.getUniqueID()) != null && KajetansMod.scripts.hasQuest(affectedPlayer))
        {
            if(questJoin.get(p.getUniqueID()).equals(affectedPlayer.getUniqueID()))
            {
                questJoin.remove(p.getUniqueID());
                KajetansMod.scripts.addPlayerToPlayer(p, affectedPlayer);
            }
        }
    }

    @SubscribeEvent
    public void onPlayerMove(PlayerMoveEvent e)
    {      
        EntityPlayer p = e.getEntityPlayer();
        KajetansMod.scripts.getScripts().stream().filter(qd -> qd.isEventLoaded("player-move")).forEach(data -> 
        {
            if(data.removeLocation(Location.rounded(p)))
            {
                doInEvent(data, p, "player-move", null, null);
            }
        });

        if(KajetansMod.scripts.hasQuest(p))
        {
            Script data = KajetansMod.scripts.getQuestData(p);
            if(data != null && data.isEventLoaded("player-move") && data.removeLocation(Location.rounded(p)))
            {
                doInEvent(data, p, "player-move", null, null);
            }
        }  
    } 
    
    public boolean QuestClickInventory(Script qd, SnuviInventory inv, int slot, ClickType click, EntityPlayer p)
    {
        qd.setVar("event", "inv-click");
        ScriptVars.setPlayerVars(qd, p); 
        qd.setVar("inv-id", inv.getId());
        qd.setVar("inv-name", inv.getName());
        qd.setVar("inv-slot", slot);
        ScriptVars.setItemVars(qd, inv.getStackInSlot(slot));
        qd.setVar("cancel", false); 
        qd.runCode();
        return qd.getBoolean("cancel");
    }

    public boolean QuestCloseInventory(Script qd, SnuviInventory inv, EntityPlayer p)
    {
        qd.setVar("event", "inv-close");
        ScriptVars.setPlayerVars(qd, p); 
        qd.setVar("inv-id", inv.getId());
        qd.setVar("inv-name", inv.getName());
        qd.setVar("cancel", false); 
        qd.runCode();
        return qd.getBoolean("cancel");
    }
    
    @SubscribeEvent
    public void QuestOnPlayerRespawn(PlayerRespawnAtEvent e)
    {
        handleEvent(e.getEntityPlayer(), "player-respawn", (qd) -> 
        {
            qd.setVar("keep-inventory", e.isInventoryKeepingForced());
            qd.setVar("respawn-loc", new Location(e.getWorld(), e.getRespawnLoc()));
        }, (qd) -> 
        {
            try 
            {
                e.setForcedInventoryKeeping(qd.getBoolean("keep-inventory"));
                Location l = (Location) qd.getVar("respawn-loc");
                e.setRespawnLoc(l.getPos());
                e.setWorld((WorldServer) l.getWorld());
            } 
            catch(ClassCastException | NullPointerException ex) 
            {
                KajetansMod.scripts.getQuestParser().printQuestException(qd, ex, "(respawn-loc)");
            }
        });
    }
    
    @SubscribeEvent
    public void QuestPlayerDamage(PlayerHurtEvent e)
    {        
        EntityPlayer p = e.getEntityPlayer();  
        handleEvent(p, "player-hurt", (qd) -> 
        {
            if(p.getHealth() <= e.getAmount())
            {
                qd.setVar("player-killed", true);   
            }  
            else
            {
                qd.setVar("player-killed", false); 
            }
            qd.setVar("player-damage", e.getAmount());   
            qd.setVar("player-damage-cause", e.getSource().getDamageType());
            EntityPlayer ent = Utils.getDamager(e.getSource());
            if(ent != null)
            {
                qd.setVar("player-involved", true);
                ScriptVars.setSecPlayer(qd, ent);
            }
            else
            {
                qd.setVar("player-involved", false);
            }
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    } 
    
    @SubscribeEvent
    public void QuestDeath(LivingDeathEvent e)
    {        
        if(!(e.getEntityLiving() instanceof EntityPlayer))
        {
            handleEvent(null, "entity-death", (qd) -> 
            {
                EntityLivingBase ent = e.getEntityLiving();
                ScriptVars.setEntityVars(qd, ent);
                EntityPlayer p = Utils.getDamager(e.getSource());
                if(p != null)
                {
                    qd.setVar("player-involved", true);
                    ScriptVars.setPlayerVars(qd, p);
                }  
                else
                {
                    qd.setVar("player-involved", false);
                }
                qd.setVar("cancel", e.isCanceled()); 
            }, (qd) -> 
            {
                e.setCanceled(qd.getBoolean("cancel")); 
            });
            return;
        }
        EntityPlayer p = (EntityPlayer) e.getEntity();    
        handleEvent(p, "player-death", (qd) -> 
        {
            //qd.setVar("message", e.getDeathMessage());
            qd.setVar("clear", false);
            EntityPlayer ent = Utils.getDamager(e.getSource());
            if(ent != null)
            {
                ScriptVars.setSecPlayer(qd, ent);
            }
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            //e.setDeathMessage(String.valueOf(qd.getVar("message")));
            if(qd.getBoolean("clear"))
            {
                p.inventory.clear();
            } 
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    } 
       
    @SubscribeEvent
    public void QuestEntityDamage(LivingHurtEvent e)
    {        
        EntityPlayer p = Utils.getDamager(e.getSource());
        if(p == null)
        {
            return;
        }
        handleEvent(p, "entity-hurt", (qd) -> 
        {
            qd.setVar("entity-killed", e.getEntityLiving().getHealth() <= e.getAmount());        
            ScriptVars.setEntityVars(qd, e.getEntity()); 
            qd.setVar("entity-damage", e.getAmount());   
            qd.setVar("entity-damage-cause", e.getSource().getDamageType());
            qd.setVar("cancel", e.isCanceled());   
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel"));
        });
    }
    
    @SubscribeEvent
    public void QuestEntityDrop(LivingDropsEvent e)
    {             
        try
        {
            handleEvent(null, "entity-drop", (qd) -> 
            {
                qd.setVar("drops", e.getDrops());
                ScriptVars.setEntityVars(qd, e.getEntityLiving());
                EntityPlayer p = Utils.getDamager(e.getSource());
                if(p != null)
                {
                    qd.setVar("player-involved", true);
                    ScriptVars.setPlayerVars(qd, p);
                }  
                else
                {
                    qd.setVar("player-involved", false);
                }
                qd.setVar("cancel", e.isCanceled()); 
            }, (qd) -> 
            {
                e.setCanceled(qd.getBoolean("cancel"));
            });
        }
        catch(NullPointerException ex)
        {
            KajetansMod.scripts.sendWarningToConsole(ex.toString() + "  " + ex.getMessage());
        }
    } 
            
    @SubscribeEvent
    public void QuestPlayerDrop(PlayerDropsEvent e)
    {             
        handleEvent(e.getEntityPlayer(), "player-drop", (qd) -> 
        {
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel"));
        });
    } 
    
    @SubscribeEvent
    public void QuestProjectileHit(ThrowableImpactEvent e)
    {        
        EntityPlayer p = Utils.getPlayerFromProjectile(e.getEntityThrowable());
        if(p != null)
        {
            handleEvent(p, "throw-hit", (qd) -> 
            {
                if(e.getRayTraceResult().entityHit != null)
                {
                    qd.setVar("is-entity-hit", true);
                    qd.setVar("entity-hit", e.getRayTraceResult().entityHit);
                }
                else
                {
                    qd.setVar("is-entity-hit", false);
                }
                ScriptVars.setEntityVars(qd, e.getEntityThrowable());
            });
        }           
    }
    
    public void onEntityItemProjectileHit(EntityPlayer p, ItemStack stack, List<Entity> ents)
    {        
        handleEvent(p, "item-hit", (qd) -> 
        {
            ScriptVars.setItemVars(qd, stack);
            qd.setVar("entities", ents);
        });      
    }
    
    @SubscribeEvent
    public void QuestEntityShear(PlayerInteractEvent.EntityInteract e)
    {              
        if(e.getHand() == EnumHand.OFF_HAND || !(e.getTarget() instanceof EntitySheep))
        {
            return;
        }
        EntityPlayer p = e.getEntityPlayer();   
        if(p.getHeldItemMainhand().getItem() != Items.SHEARS)
        {
            return;
        }
        EntitySheep sheep = (EntitySheep) e.getTarget();
        handleEvent(p, "entity-shear", (qd) -> 
        {
            ScriptVars.setEntityVars(qd, sheep);
            qd.setVar("entity-sheared", sheep.getSheared());
            qd.setVar("entity-color", sheep.getFleeceColor().toString());
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
            sheep.setSheared(qd.getBoolean("entity-sheared"));
        });
    }
       
    @SubscribeEvent
    public void QuestBlockBreak(BlockEvent.BreakEvent e)
    {        
        handleEvent(e.getPlayer(), "block-break", (qd) -> 
        {
            ScriptVars.setBlockVars(qd, e.getWorld(), e.getPos());
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }
    
    @SubscribeEvent
    public void QuestPlayerLogin(PlayerEvent.PlayerLoggedInEvent e)
    {    
        EntityPlayer p = e.player;
        if(p == null)
        {
            return;
        }
        handleEvent(p, "player-login", (qd) -> 
        {       
            qd.setVar("first-join", Utils.hasPlayedBefore(p));
            PlayerList list = KajetansMod.server.getPlayerList();
            qd.setVar("is-banned", list.getBannedPlayers().isBanned(p.getGameProfile()));
            qd.setVar("is-whitelisted", list.getWhitelistedPlayers().isWhitelisted(p.getGameProfile()));
        });
    }
    
    @SubscribeEvent
    public void QuestPlayerJoin(PlayerJoinMessageEvent e)
    {    
        EntityPlayer p = e.getEntityPlayer();
        handleEvent(p, "player-join-server", (qd) -> 
        {       
            qd.setVar("message", e.getMessage());
            qd.setVar("changed-name", e.hasNameChanged());
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setMessage(String.valueOf(qd.getVar("message"))); 
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }
    
    @SubscribeEvent
    public void onPlayerLeave(PlayerLeaveMessageEvent e)
    {      
        EntityPlayer p = e.getEntityPlayer();
        handleEvent(p, "player-leave", (qd) -> 
        {       
            qd.setVar("message", e.getMessage());
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setMessage(String.valueOf(qd.getVar("message"))); 
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }
    
    @SubscribeEvent
    public void QuestBucketFill(FillBucketEvent e)
    {      
        handleEvent(e.getEntityPlayer(), "bucket-fill", (qd) -> 
        {
            RayTraceResult ray = e.getTarget();
            if(ray != null)
            {
                BlockPos pos = ray.getBlockPos();
                if(pos != null)
                {
                    qd.setVar("has-block", true); 
                    ScriptVars.setBlockVars(qd, e.getWorld(), pos);
                }
                else
                {
                    qd.setVar("has-block", false); 
                }
            }
            else
            {
                qd.setVar("has-block", false); 
            }
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    } 
       
    @SubscribeEvent
    public void QuestBlockPlace(BlockEvent.PlaceEvent e)
    {
        handleEvent(e.getPlayer(), "block-place", (qd) -> 
        {
            qd.setVar("block-type-after", e.getPlacedBlock().getBlock().getRegistryName());
            ScriptVars.setBlockVars(qd, e.getWorld(), e.getPos());
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }    
    
    @SubscribeEvent
    public void QuestClickBlockRight(PlayerInteractEvent.RightClickBlock e)
    {
        if(e.getHand() == EnumHand.OFF_HAND)
        {
            return;
        }
        handleEvent(e.getEntityPlayer(), "block-click", (qd) -> 
        {
            qd.setVar("action", "right");
            ScriptVars.setBlockVars(qd, e.getWorld(), e.getPos());
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });       
    }
    
    @SubscribeEvent
    public void QuestClickBlockLeft(PlayerInteractEvent.LeftClickBlock e)
    {
        if(e.getHand() == EnumHand.OFF_HAND)
        {
            return;
        }
        handleEvent(e.getEntityPlayer(), "block-click", (qd) -> 
        {
            qd.setVar("action", "left");
            ScriptVars.setBlockVars(qd, e.getWorld(), e.getPos());
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });       
    }
    
    @SubscribeEvent
    public void QuestClickEntity(PlayerInteractEvent.EntityInteract e)
    {
        if(e.getHand() != EnumHand.OFF_HAND)
        {
            handleEvent(e.getEntityPlayer(), "entity-click", (qd) -> 
            {
                ScriptVars.setEntityVars(qd, e.getTarget());
                qd.setVar("cancel", e.isCanceled()); 
            }, (qd) -> 
            {
                e.setCanceled(qd.getBoolean("cancel")); 
            });
        }
    }
    
    @SubscribeEvent
    public void QuestFishing(ItemFishedEvent e)
    {
        handleEvent(e.getEntityPlayer(), "fishing", (qd) -> 
        {
            qd.setVar("drops", e.getDrops());
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }
    
    @SubscribeEvent
    public void QuestUseitem(LivingEntityUseItemEvent.Start e)
    {        
        if(!(e.getEntityLiving() instanceof EntityPlayer))
        {
            return;
        }
        handleEvent((EntityPlayer) e.getEntityLiving(), "item-use-start", (qd) -> 
        {
            qd.setVar("duration", e.getDuration());
            qd.setVar("cancel", e.isCanceled());  
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel"));
            try
            {
                e.setDuration((int) qd.getVar("duration"));
            }
            catch(Exception ex)
            {
                KajetansMod.scripts.getQuestParser().printQuestException(qd, ex, "(duration)");           
            }
        });
    }
    
    @SubscribeEvent
    public void QuestConsuming(LivingEntityUseItemEvent.Finish e)
    {
        if(!(e.getEntityLiving() instanceof EntityPlayer))
        {
            return;
        }
        handleEvent((EntityPlayer) e.getEntityLiving(), "item-use-finish", (qd) -> 
        {
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }
    
    @SubscribeEvent
    public void QuestCrafting(PlayerEvent.ItemCraftedEvent e)
    {  
        handleEvent(e.player, "craft", (qd) -> 
        {
            ScriptVars.setItemVars(qd, e.crafting);
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });   
    } 
    
    @SubscribeEvent
    public void QuestDropItem(ItemTossEvent e)
    {
        handleEvent(e.getPlayer(), "player-toss", (qd) -> 
        {
            ScriptVars.setItemVars(qd, e.getEntityItem().getEntityItem());   
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }
    
    @SubscribeEvent
    public void QuestPickupItem(EntityItemPickupEvent e)
    {
        handleEvent(e.getEntityPlayer(), "player-pickup", (qd) -> 
        {
            ScriptVars.setItemVars(qd, e.getItem().getEntityItem());  
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }
    
    @SubscribeEvent
    public void VehicleEnterEvent(EntityMountEvent e)
    {
        if(!(e.getEntityMounting() instanceof EntityPlayer))
        {
            return;
        }
        EntityPlayer p = (EntityPlayer) e.getEntityMounting();
        handleEvent(p, "entity-mount", (qd) -> 
        {
            qd.setVar("mounting", e.isMounting()); 
            ScriptVars.setEntityVars(qd, e.getEntityBeingMounted()); 
            qd.setVar("cancel", e.isCanceled()); 
        }, (qd) -> 
        {
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }
    
    @SubscribeEvent
    public void PlayerPortalEvent(PlayerEvent.PlayerChangedDimensionEvent e)
    {
        handleEvent(e.player, "portal", (qd) -> 
        {
            qd.setVar("from", e.fromDim);
            qd.setVar("to", e.toDim);
        });
    }
    
    @SubscribeEvent
    public void onCommand(CommandEvent e)
    {
        if(e.getSender() instanceof EntityPlayer)
        {
            handleEvent((EntityPlayer) e.getSender(), "command", (qd) -> 
            {
                qd.setVar("command", e.getCommand().getName()); 
                qd.setVar("args", Arrays.stream(e.getParameters()).map(s -> ScriptUtils.convertInput(s)).collect(Collectors.toList()));
                qd.setVar("cancel", e.isCanceled()); 
            }, (qd) -> 
            {
                e.setCanceled(qd.getBoolean("cancel")); 
            });
        }
    }
    
    public void onCustomCommand(EntityPlayer p, String command, String args)
    {
        handleEvent(p, "custom-command", (qd) -> 
        {
            qd.setVar("command", command);
            if(args.length() == 0)
            {
                qd.setVar("args", new ArrayList<>());
            }
            qd.setVar("args", Arrays.stream(args.trim().split(" ")).map(s -> ScriptUtils.convertInput(s)).collect(Collectors.toList()));
        });
    }
      
    public void useEffectEvent(PlayerUsesEffectEvent e)
    {    
        handleEvent(e.getPlayer(), "player-use-effect", (qd) -> 
        {       
            qd.setVar("power", e.getPower());
            qd.setVar("mana-cost", e.getMana());
            qd.setVar("cause", e.getCause().toString());
            qd.setVar("effect", e.getEffect());
            qd.setVar("cancel", e.isCanceled());
        }, (qd) -> 
        {
            try
            {
                int power = (int) qd.getVar("power");
                if(power < 1 || power > 20)
                {
                    throw new IllegalArgumentException();
                }
                e.setPower(power);
            }
            catch(Exception ex)
            {
                KajetansMod.scripts.getQuestParser().printQuestException(qd, ex, "(power)");           
            }
            try
            {
                int mana = (int) qd.getVar("mana-cost");
                if(mana < 0)
                {
                    throw new IllegalArgumentException();
                }
                e.setMana(mana);
            }
            catch(Exception ex)
            {
                KajetansMod.scripts.getQuestParser().printQuestException(qd, ex, "(mana-cost)");           
            }
            e.setCanceled(qd.getBoolean("cancel")); 
        });
    }
    
    @SubscribeEvent
    public void QuestVillagerPickUpItem(ItemTossEvent e)
    {             
        EntityPlayer p = e.getPlayer();
        if(KajetansMod.scripts.hasQuest(p))
        {           
            Script qd = KajetansMod.scripts.getQuestData(p);
            if(qd == null || !qd.isEventLoaded("villager-give"))
            {
                return;
            }
            final EntityItem itemEnt = e.getEntityItem();
            KajetansMod.scheduler.scheduleTask(() -> 
            {
                if(itemEnt.isDead)
                {
                    return;
                }
                EntityVillager v = Utils.getNearestEntity(p.world, itemEnt.getPositionVector(), 2, EntityVillager.class);
                if(v == null)
                {
                    return;
                }
                Script data = KajetansMod.scripts.getQuestData(p);
                if(data == null || !data.isEventLoaded("villager-give"))
                {
                    return;
                }
                data.setVar("event", "villager-give");
                ScriptVars.setPlayerVars(data, p); 
                ScriptVars.setItemVars(data, itemEnt.getEntityItem());
                data.setVar("villager-loc", new Location(v));                    
                data.setVar("villager-prof", v.getProfessionForge().getRegistryName());
                data.setVar("cancel", e.isCanceled()); 
                data.runCode();
                if(data.getBoolean("cancel"))
                {
                    return;
                }                  
                itemEnt.setDead();                
            }, 40);          
        }               
    }
}