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

package me.km.snuviscript;

import me.km.KajetansMod;
import me.km.afk.AfkListener;
import me.km.environment.EnvironmentAPI;
import me.km.utils.NBTUtils;
import me.km.plots.ProtectionBank;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import me.hammerle.snuviscript.code.Script;
import me.hammerle.snuviscript.code.SnuviUtils;
import me.hammerle.snuviscript.code.SnuviParser;
import me.km.api.Location;
import me.km.api.TitleAPI;
import me.km.api.Utils;
import me.km.chatchannel.ChatChannel;
import me.km.commands.CommandSilent;
import me.km.dimensions.ModDimensions;
import me.km.effects.EffectUtils;
import me.km.inventory.InventoryUtils;
import me.km.table.Table;
import me.km.utils.ItemStackUtils;
import me.km.utils.ReflectionUtils;
import me.km.utils.SpecialBlockUtils;
import net.minecraft.block.Block;
import net.minecraft.block.BlockDoor;
import net.minecraft.block.state.IBlockState;
import net.minecraft.command.ICommandSender;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItemFrame;
import net.minecraft.entity.monster.EntityCreeper;
import net.minecraft.entity.passive.EntityVillager;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.entity.projectile.EntityPotion;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.network.ThreadQuickExitException;
import net.minecraft.network.play.client.CPacketChatMessage;
import net.minecraft.network.play.client.CPacketClientStatus;
import net.minecraft.network.play.server.SPacketSpawnPosition;
import net.minecraft.potion.Potion;
import net.minecraft.potion.PotionUtils;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityChest;
import net.minecraft.tileentity.TileEntitySign;
import net.minecraft.util.DamageSource;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.SoundEvent;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.World;
import net.minecraft.world.WorldServer;
import me.km.effects.Effect;
import me.km.events.CustomEventCaller;
import me.km.events.PlayerMoveData;
import me.km.exception.IllegalStringException;
import me.km.exception.PlayerNotFoundException;
import me.km.inventory.CustomContainer;
import me.km.networking.ModPacketHandler;
import me.km.pathfinder.PathfinderUtils;
import me.km.permissions.Permissions;
import me.km.skills.LeveledSkill;
import me.km.skills.Skill;
import me.km.table.TableAPI;
import net.minecraft.block.BlockCrops;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.item.Item;
import net.minecraft.util.NonNullList;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.world.GameType;

public class MinecraftFunctions
{
    public static int inventoryIds = 0;

    @SuppressWarnings("")
    public static void registerFunctions(SnuviParser parser)
    {
        // ---------------------------------------------------------------------
        // Command-Bibliothek  
        // ---------------------------------------------------------------------
        parser.registerFunction("command.add", (sc, in) -> 
        {
            KajetansMod.scripts.registerScriptCommand(in[0].getString(sc));
            return Void.TYPE;
        }); 
        parser.registerFunction("command.remove", (sc, in) -> 
        {
            KajetansMod.scripts.unregisterScriptCommand(in[0].getString(sc));
            return Void.TYPE;
        }); 
        parser.registerFunction("command.exists", (sc, in) -> KajetansMod.scripts.isRegisteredScriptCommand(in[0].getString(sc)));
        parser.registerFunction("command.clear", (sc, in) -> 
        {
            KajetansMod.scripts.clearScriptCommands();
            return Void.TYPE;
        }); 
        
        // ---------------------------------------------------------------------
        // Permission-Bibliothek  
        // ---------------------------------------------------------------------
        parser.registerFunction("perm.clear", (sc, in) -> 
        {
            KajetansMod.perms.clear();
            return Void.TYPE;
        }); 
        parser.registerFunction("perm.registergroup", (sc, in) -> 
        {
            KajetansMod.perms.registerGroupPermission(in[0].getInt(sc), in[1].getString(sc));
            return Void.TYPE;
        }); 
        parser.registerFunction("perm.registerplayer", (sc, in) -> 
        {
            KajetansMod.perms.registerPlayerGroup(UUID.fromString(in[0].getString(sc)), in[1].getInt(sc));
            return Void.TYPE;
        }); 
        parser.registerFunction("perm.unregisterplayer", (sc, in) -> KajetansMod.perms.unregisterPlayer(UUID.fromString(in[0].getString(sc)), in[1].getInt(sc))); 
        parser.registerFunction("perm.has", (sc, in) -> KajetansMod.perms.hasPermission((ICommandSender) in[0].get(sc), in[1].getString(sc))); 
        
        // ---------------------------------------------------------------------
        // Title-Bibliothek  
        // ---------------------------------------------------------------------
        parser.registerFunction("title.settime", (sc, in) -> 
        {
            TitleAPI.setTitleTime((EntityPlayerMP) in[0].get(sc), in[1].getInt(sc), in[2].getInt(sc), in[3].getInt(sc));
            return Void.TYPE;
        });
        parser.registerFunction("title.clear", (sc, in) -> 
        { 
            TitleAPI.clearTitle((EntityPlayerMP) in[0].get(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("title.reset", (sc, in) -> 
        { 
            TitleAPI.resetTitle((EntityPlayerMP) in[0].get(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("title.send", (sc, in) -> 
        { 
            TitleAPI.setTitle((EntityPlayerMP) in[0].get(sc), SnuviUtils.connect(sc, in, 1)); 
            return Void.TYPE; 
        });
        parser.registerFunction("title.setsub", (sc, in) -> 
        { 
            TitleAPI.setSubTitle((EntityPlayerMP) in[0].get(sc), SnuviUtils.connect(sc, in, 1)); 
            return Void.TYPE; 
        });
        
        // ---------------------------------------------------------------------
        // Villager-Bibliothek  
        // ---------------------------------------------------------------------
        parser.registerFunction("villager.showtrades", (sc, in) -> 
        { 
            ((EntityPlayer) in[0].get(sc)).displayVillagerTradeGui(((EntityVillager) in[1].get(sc))); 
            return Void.TYPE; 
        });
       
        // ---------------------------------------------------------------------    
        // Player-Bibliothek
        // ---------------------------------------------------------------------  
        parser.registerFunction("player.getitemamount", (sc, in) -> (double) InventoryUtils.searchInventoryFor(((EntityPlayer) in[0].get(sc)).inventory, (ItemStack) in[2].get(sc), in[1].getBoolean(sc)));                
        parser.registerFunction("player.removeitem", (sc, in) -> 
        { 
            ItemStack stack = ((ItemStack) in[1].get(sc)).copy();
            stack.setCount(InventoryUtils.removeFromInventory(((EntityPlayer) in[0].get(sc)).inventory, stack));
            return stack;
        });                 
        parser.registerFunction("player.giveitem", (sc, in) -> 
        {       
            ItemStack stack = ((ItemStack) in[1].get(sc)).copy();
            stack.setCount(InventoryUtils.addToInventory(((EntityPlayer) in[0].get(sc)).inventory, stack));
            return stack;
        });
        parser.registerFunction("player.shootprojectile", (sc, in) -> EffectUtils.launchProjectile((EntityPlayer) in[0].get(sc), getClass(in[1].getString(sc)), in[2].getDouble(sc), in[3].get(sc)));
        parser.registerFunction("player.respawn", (sc, in) -> 
        {
            KajetansMod.scheduler.scheduleTask(() ->
            {
                try
                {
                    ((EntityPlayerMP) in[0].get(sc)).connection.processClientStatus(new CPacketClientStatus(CPacketClientStatus.State.PERFORM_RESPAWN));
                }
                catch(ThreadQuickExitException ex)
                {
                    // Minecraft needs this for canceling and queueing into main thread
                }
            });
            return Void.TYPE; 
        });
        parser.registerFunction("player.clearinventory", (sc, in) -> 
        { 
            ((EntityPlayer) in[0].get(sc)).inventory.clear();
            return Void.TYPE; 
        });  
        parser.registerFunction("player.inventorytolist", (sc, in) -> 
        { 
            in[0].set(sc, ((EntityPlayer) in[1].get(sc)).inventory.mainInventory); 
            return Void.TYPE; 
        });    
        parser.registerFunction("player.getnearest", (sc, in) -> Utils.getNearestPlayer(((Location) in[0].get(sc)).getWorld(), ((Location) in[0].get(sc)).getPos())); 
        parser.registerFunction("player.say", (sc, in) -> 
        {
            try
            {
                ((EntityPlayerMP) in[0].get(sc)).connection.processChatMessage(new CPacketChatMessage(SnuviUtils.connect(sc, in, 1)));
            }
            catch(ThreadQuickExitException ex)
            {
                // Minecraft needs this for canceling and queueing into main thread
            }
            return Void.TYPE; 
        });
        parser.registerFunction("player.isafk", (sc, in) -> KajetansMod.afkManager.getEvent(AfkListener.class).isAfk((EntityPlayer) in[0].get(sc)));
        parser.registerFunction("player.speak", (sc, in) -> 
        { 
            sendMessageToGroup(in[0].get(sc), sc, NBTUtils.concat(sc, 2, "§7[§r" + in[1].getString(sc) + "§7]§r ", in)); 
            return Void.TYPE; 
        });
        parser.registerFunction("player.setcompass", (sc, in) -> 
        { 
            ((EntityPlayerMP) in[0].get(sc)).connection.sendPacket(new SPacketSpawnPosition(((Location) in[1].get(sc)).getBlockPos())); 
            return Void.TYPE; 
        }); 
        parser.registerFunction("player.gethunger", (sc, in) -> (double) ((EntityPlayer) in[0].get(sc)).getFoodStats().getFoodLevel());
        parser.registerFunction("player.sethunger", (sc, in) -> 
        { 
            ((EntityPlayer) in[0].get(sc)).getFoodStats().setFoodLevel(in[1].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("player.getsaturation", (sc, in) -> (double) ReflectionUtils.getSaturation(((EntityPlayer) in[0].get(sc)).getFoodStats()));
        parser.registerFunction("player.setsaturation", (sc, in) -> 
        { 
            ReflectionUtils.setSaturation(((EntityPlayer) in[0].get(sc)).getFoodStats(), in[1].getFloat(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("player.getname", (sc, in) -> 
        { 
            Object o = in[0].get(sc);
            if(o instanceof EntityPlayer)
            {
                return ((EntityPlayer) o).getName();
            }
            return KajetansMod.playerbank.getDataBank().getName(o.toString());
        });
        parser.registerFunction("player.getfullname", (sc, in) -> KajetansMod.chatManager.getFullName((EntityPlayer) in[0].get(sc)));
        parser.registerFunction("player.getuuid", (sc, in) -> 
        { 
            Object o = in[0].get(sc);
            if(o instanceof EntityPlayer)
            {
                return ((EntityPlayer) o).getUniqueID().toString();
            }
            return KajetansMod.playerbank.getDataBank().getUUID(o.toString());
        });
        parser.registerFunction("player.getip", (sc, in) -> ((EntityPlayerMP) in[0].get(sc)).connection.netManager.getRemoteAddress().toString());
        parser.registerFunction("player.iscreative", (sc, in) -> ((EntityPlayer) in[0].get(sc)).isCreative());
        parser.registerFunction("player.isspectator", (sc, in) -> ((EntityPlayer) in[0].get(sc)).isSpectator());
        parser.registerFunction("player.issurvival", (sc, in) -> 
        { 
            EntityPlayer p = (EntityPlayer) in[0].get(sc);
            return !p.isCreative() && !p.isSpectator();
        });
        parser.registerFunction("player.isadventure", (sc, in) -> !((EntityPlayer) in[0].get(sc)).capabilities.allowEdit);
        parser.registerFunction("player.hasfly", (sc, in) -> ((EntityPlayer) in[0].get(sc)).capabilities.allowFlying);
        parser.registerFunction("player.setgamemode", (sc, in) -> 
        { 
            EntityPlayer p = (EntityPlayer) in[0].get(sc);
            switch(in[1].get(sc).toString()) 
            {
                case "survival":
                case "s":
                case "0":  
                    p.setGameType(GameType.SURVIVAL);
                    break;
                case "creative":
                case "c":        
                case "1":  
                    p.setGameType(GameType.CREATIVE);
                    break;
                case "adventure":         
                case "a":         
                case "2":  
                    p.setGameType(GameType.ADVENTURE);
                    break;
                case "specator":         
                case "w":         
                case "3":  
                    p.setGameType(GameType.SPECTATOR);
                    break;  
                default:
                    p.setGameType(GameType.CREATIVE);
                    break;
            }
            return Void.TYPE;
        });
        parser.registerFunction("player.getlastdamager", (sc, in) -> 
        { 
            DamageSource ds = ((EntityPlayer) in[0].get(sc)).getLastDamageSource();
            if(ds == null)
            {
                return null;
            }
            return ds.getImmediateSource();
        });
        parser.registerFunction("player.settag", (sc, in) -> 
        { 
            Object o = in[0].get(sc);
            if(o instanceof EntityPlayer)
            {
                KajetansMod.playerbank.getDataBank().setTag((EntityPlayer) o, in[1].getString(sc), in[2].getInt(sc));
                return Void.TYPE;
            }
            KajetansMod.playerbank.getDataBank().setTag(o.toString(), in[1].getString(sc), in[2].getInt(sc));
            return Void.TYPE; 
        });
        parser.registerFunction("player.gettag", (sc, in) -> 
        { 
            Object o = in[0].get(sc);
            if(o instanceof EntityPlayer)
            {
                return (double) KajetansMod.playerbank.getDataBank().getTag((EntityPlayer) o, in[1].getString(sc));
            }
            return (double) KajetansMod.playerbank.getDataBank().getTag(o.toString(), in[1].getString(sc));
        });
        parser.registerFunction("player.setguild", (sc, in) -> 
        { 
            Object o = in[0].get(sc);
            if(o instanceof EntityPlayer)
            {
                KajetansMod.playerbank.setGuildId((EntityPlayer) o, in[1].getInt(sc));
                return Void.TYPE;
            }
            KajetansMod.playerbank.setGuildId(o.toString(), in[1].getInt(sc));
            return Void.TYPE;
        });
        parser.registerFunction("player.getguild", (sc, in) ->
        {
            Object o = in[0].get(sc);
            if(o instanceof EntityPlayer)
            {
                return (double) KajetansMod.playerbank.getGuildId((EntityPlayer) o);
            }
            return (double) KajetansMod.playerbank.getGuildId(o.toString());
        });
        parser.registerFunction("player.dropinventory", (sc, in) -> 
        { 
            ((EntityPlayer) in[0].get(sc)).inventory.dropAllItems();
            return Void.TYPE; 
        });
        parser.registerFunction("player.gettarget", (sc, in) -> 
        { 
            if(in.length > 2)
            {
                return new Location(((EntityPlayer) in[0].get(sc)).world, 
                        Utils.getPlayerTarget((EntityPlayer) in[0].get(sc), in[1].getInt(sc), in[2].getBoolean(sc)));
            }
            return new Location(((EntityPlayer) in[0].get(sc)).world, Utils.getPlayerTarget((EntityPlayer) in[0].get(sc), in[1].getInt(sc)));
        });
                
        parser.registerFunction("player.gettargetentity", (sc, in) -> Utils.getTargetedEntity((EntityPlayer) in[0].get(sc), in[1].getDouble(sc), getClass(in[2].getString(sc))));
        parser.registerFunction("player.hasscript", (sc, in) -> KajetansMod.scripts.isRegistered((EntityPlayer) in[0].get(sc)));
        parser.registerAlias("player.hasscript", "player.hasquest");
        parser.registerFunction("player.action", (sc, in) -> 
        {     
            TextComponentString text = new TextComponentString(SnuviUtils.connect(sc, in, 1));
            doForGroup(in[0].get(sc), sc, p -> ((EntityPlayerMP) p).sendStatusMessage(text, true));
            return Void.TYPE; 
        }); 
        parser.registerFunction("player.kick", (sc, in) -> KajetansMod.scripts.unregisterPlayer((EntityPlayer) in[0].get(sc)));  
        parser.registerFunction("player.playsound", (sc, in) -> 
        { 
            EffectUtils.playSound((EntityPlayerMP) in[0].get(sc), SoundEvent.REGISTRY.getObject(new ResourceLocation(in[1].getString(sc))), SoundCategory.MASTER);
            return Void.TYPE; 
        });
        parser.registerFunction("player.getspawn", (sc, in) -> 
        {   
            WorldServer ws = ModDimensions.getWorldFromName(in[1].getString(sc));
            return new Location(ws, ((EntityPlayer) in[0].get(sc)).getBedLocation(ws.provider.getDimension()));
        });
        parser.registerAlias("player.getspawn", "player.getbedspawn");
        parser.registerFunction("player.setspawn", (sc, in) -> 
        {     
            Location l = (Location) in[1].get(sc);
            ((EntityPlayerMP) in[0].get(sc)).setSpawnChunk(l.getBlockPos(), true, l.getWorld().provider.getDimension());
            return Void.TYPE; 
        });
        parser.registerAlias("player.setspawn", "player.setbedspawn");
        parser.registerFunction("player.damageitem", (sc, in) -> 
        {   
            ((EntityPlayer) in[0].get(sc)).getHeldItemMainhand().damageItem(in[1].getInt(sc), (EntityPlayer) in[0].get(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("player.silentjoin", (sc, in) -> KajetansMod.perms.hasPermission((EntityPlayer) in[0].get(sc), Permissions.SILENT) && KajetansMod.generalCommands.getCommand(CommandSilent.class).silentjoin);
        
        // ---------------------------------------------------------------------    
        // Players-Bibliothek
        // --------------------------------------------------------------------- 
        parser.registerFunction("players.getamount", (sc, in) -> (double) KajetansMod.server.getCurrentPlayerCount());
        parser.registerFunction("players.tolist", (sc, in) -> 
        {     
            in[0].set(sc, new ArrayList(KajetansMod.server.getPlayerList().getPlayers())); 
            return Void.TYPE; 
        });    
        parser.registerFunction("players.toworldlist", (sc, in) -> 
        {     
            in[0].set(sc, new ArrayList(ModDimensions.getWorldFromName(in[1].getString(sc)).playerEntities)); 
            return Void.TYPE; 
        });
        parser.registerFunction("players.near", (sc, in) -> 
        {     
            Location l = (Location) in[1].get(sc);
            in[0].set(sc, Utils.getPlayers(l.getWorld(), l.getX(), l.getY(), l.getZ(), in[2].getDouble(sc))); 
            return Void.TYPE;
        });

        // ---------------------------------------------------------------------    
        // Rank-Bibliothek
        // ---------------------------------------------------------------------  
        parser.registerFunction("rank.get", (sc, in) -> 
        { 
            in[0].set(sc, KajetansMod.chatManager.getRanks((EntityPlayer) in[1].get(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("rank.register", (sc, in) -> 
        { 
            KajetansMod.chatManager.registerRank(in[0].getString(sc), in[1].getInt(sc), in[2].getString(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("rank.player", (sc, in) -> 
        { 
            KajetansMod.chatManager.registerPlayerRank(UUID.fromString(in[0].getString(sc)), in[1].getString(sc));
            return Void.TYPE; 
        });
        parser.registerFunction("rank.clear", (sc, in) -> 
        { 
            KajetansMod.chatManager.clearRanks(); 
            return Void.TYPE; 
        });
        
        // ---------------------------------------------------------------------    
        // Custom-Bibliothek
        // ---------------------------------------------------------------------
        /*parser.registerFunction("custom.registershapelessrecipe", (sc, in) -> 
        { 
            ItemStack[] stacks = new ItemStack[in.length - 1];
            for(int i = 0; i < stacks.length; i++)
            {
                stacks[i] = (ItemStack) in[i + 1].get(sc);
            }
            RecipeUtils.registerShapelessRecipe((ItemStack) in[0].get(sc), stacks); 
            return Void.TYPE; 
        });
        parser.registerFunction("custom.registershapedrecipe", (sc, in) -> 
        { 
            int counter = 0;
            while(in[counter + 1].get(sc).getClass() == String.class)
            {
                counter++;
            }
            String[] s = new String[counter];
            for(int i = 0; i < s.length; i++)
            {
                s[i] = in[i + 1].toString();
            }

            ItemStack[] stacks = new ItemStack[in.length - 1 - s.length];
            for(int i = 0; i < stacks.length; i++)
            {
                stacks[i] = (ItemStack) in[i + 1 + counter].get(sc);
            }
            RecipeUtils.registerShapedRecipe((ItemStack) in[0].get(sc), s, stacks); 
            return Void.TYPE; 
        });
        parser.registerFunction("custom.registerfurnacerecipe", (sc, in) -> 
        {
            RecipeUtils.registerFurnaceRecipe((ItemStack) in[0].get(sc), (ItemStack) in[1].get(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("custom.clearrecipes", (sc, in) -> 
        {
            RecipeUtils.clearRecipes(); 
            return Void.TYPE; 
        });*/
        
        
        // ---------------------------------------------------------------------    
        // World-Bibliothek
        // ---------------------------------------------------------------------
        
        parser.registerAlias("players.toworldlist", "world.getplayers");
        parser.registerFunction("world.setskills", (sc, in) -> 
        {     
            KajetansMod.worldManager.getWorldPreferences((World) in[0].get(sc)).skills = in[1].getBoolean(sc);
            return Void.TYPE;
        });
        parser.registerFunction("world.setblockprotections", (sc, in) -> 
        {     
            KajetansMod.worldManager.getWorldPreferences((World) in[0].get(sc)).blockProtection = in[1].getBoolean(sc);
            return Void.TYPE;
        });
        parser.registerFunction("world.setdefaultenchanting", (sc, in) -> 
        {     
            KajetansMod.worldManager.getWorldPreferences((World) in[0].get(sc)).defaultEnchanting = in[1].getBoolean(sc);
            return Void.TYPE;
        });
        parser.registerFunction("world.setpvpprotection", (sc, in) -> 
        {     
            KajetansMod.worldManager.getWorldPreferences((World) in[0].get(sc)).pvpProtection = in[1].getBoolean(sc);
            return Void.TYPE;
        });
        parser.registerFunction("world.setstatuseffects", (sc, in) -> 
        {     
            KajetansMod.worldManager.getWorldPreferences((World) in[0].get(sc)).statusEffects = in[1].getBoolean(sc);
            return Void.TYPE;
        });
        parser.registerFunction("world.setscrolls", (sc, in) -> 
        {     
            KajetansMod.worldManager.getWorldPreferences((World) in[0].get(sc)).scrolls = in[1].getBoolean(sc);
            return Void.TYPE;
        });
        parser.registerFunction("world.setdefaultproducing", (sc, in) -> 
        {     
            KajetansMod.worldManager.getWorldPreferences((World) in[0].get(sc)).defaultProducing = in[1].getBoolean(sc);
            return Void.TYPE;
        });
        parser.registerFunction("world.get", (sc, in) -> 
        {     
            return ModDimensions.getWorldFromName(in[0].getString(sc));
        });
        
        // ---------------------------------------------------------------------    
        // Item-Bibliothek   
        // ---------------------------------------------------------------------   
        parser.registerFunction("item.drop", (sc, in) -> 
        {       
            Location l = (Location) in[0].get(sc);
            World w = l.getWorld();
            BlockPos pos = l.getBlockPos();
            ItemStack stack = ((ItemStack) in[1].get(sc)).copy();
            int amount = stack.getCount();
            while(amount > stack.getMaxStackSize())
            {            
                stack.setCount(stack.getMaxStackSize());
                amount -= stack.getMaxStackSize();
                ItemStackUtils.drop(w, pos, stack.copy());
            }
            if(amount > 0)
            {
                stack.setCount(amount);
                ItemStackUtils.drop(w, pos, stack);
            }
            return Void.TYPE; 
        });                  
        parser.registerFunction("item.gettooltype", (sc, in) -> Utils.getToolType((ItemStack) in[0].get(sc)).toString());
        parser.registerFunction("item.get", (sc, in) -> ((ItemStack) in[0].get(sc)).getItem());
        parser.registerFunction("item.gettype", (sc, in) -> ((ItemStack) in[0].get(sc)).getItem().getRegistryName().toString());
        parser.registerFunction("item.getdata", (sc, in) -> (double) ((ItemStack) in[0].get(sc)).getMetadata());           
        parser.registerFunction("item.setdata", (sc, in) -> 
        {    
            ((ItemStack) in[0].get(sc)).setItemDamage(in[1].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("item.getamount", (sc, in) -> (double) ((ItemStack) in[0].get(sc)).getCount()); 
        parser.registerFunction("item.setamount", (sc, in) -> 
        {   
            ((ItemStack) in[0].get(sc)).setCount(in[1].getInt(sc));
            return Void.TYPE; 
        });   
        parser.registerFunction("item.getname", (sc, in) -> ((ItemStack) in[0].get(sc)).getDisplayName());
        parser.registerFunction("item.setname", (sc, in) -> 
        {   
            ((ItemStack) in[0].get(sc)).setStackDisplayName(SnuviUtils.connect(sc, in, 1)); 
            return Void.TYPE; 
        });
        parser.registerFunction("item.getlore", (sc, in) -> 
        {    
            in[0].set(sc, ItemStackUtils.getLore((ItemStack) in[1].get(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("item.setlore", (sc, in) -> 
        {   
            ItemStackUtils.setLore((ItemStack) in[0].get(sc), (List<String>) in[1].get(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("item.addlore", (sc, in) -> 
        {   
            ItemStackUtils.addLore((ItemStack) in[0].get(sc), SnuviUtils.connect(sc, in, 2), in[1].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("item.getenchantlevel", (sc, in) -> (double) EnchantmentHelper.getEnchantmentLevel(Enchantment.getEnchantmentByLocation(in[1].getString(sc)), (ItemStack) in[0].get(sc)));
        parser.registerFunction("item.setcooldown", (sc, in) -> 
        {   
            ((EntityPlayer) in[0].get(sc)).getCooldownTracker().setCooldown(((ItemStack) in[1].get(sc)).getItem(), in[2].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("item.gettooltype", (sc, in) -> Utils.getToolType((ItemStack) in[0].get(sc)));

        // ---------------------------------------------------------------------    
        // Location-Bibliothek
        // ---------------------------------------------------------------------  
        parser.registerFunction("loc.new", (sc, in) -> 
        { 
            if(in.length >= 6)
            {
                return new Location(ModDimensions.getWorldFromName(in[0].getString(sc)), 
                        in[1].getDouble(sc), in[2].getDouble(sc), in[3].getDouble(sc), 
                        in[4].getFloat(sc), in[5].getFloat(sc));
            }
            return new Location(ModDimensions.getWorldFromName(in[0].getString(sc)), in[1].getDouble(sc), in[2].getDouble(sc), in[3].getDouble(sc), 0, 0);
        });  
        parser.registerFunction("loc.getx", (sc, in) -> ((Location) in[0].get(sc)).getX());  
        parser.registerFunction("loc.gety", (sc, in) -> ((Location) in[0].get(sc)).getY());  
        parser.registerFunction("loc.getz", (sc, in) -> ((Location) in[0].get(sc)).getZ());  
        parser.registerFunction("loc.setx", (sc, in) -> 
        { 
            ((Location) in[0].get(sc)).setX(in[1].getDouble(sc)); 
            return Void.TYPE; 
        });  
        parser.registerFunction("loc.sety", (sc, in) -> 
        { 
            ((Location) in[0].get(sc)).setY(in[1].getDouble(sc)); 
            return Void.TYPE; 
        });  
        parser.registerFunction("loc.setz", (sc, in) -> 
        { 
            ((Location) in[0].get(sc)).setZ(in[1].getDouble(sc)); 
            return Void.TYPE; 
        });  
        parser.registerFunction("loc.addx", (sc, in) -> 
        { 
            ((Location) in[0].get(sc)).addX(in[1].getDouble(sc)); 
            return Void.TYPE; 
        });  
        parser.registerFunction("loc.addy", (sc, in) -> 
        { 
            ((Location) in[0].get(sc)).addY(in[1].getDouble(sc)); 
            return Void.TYPE; 
        });  
        parser.registerFunction("loc.addz", (sc, in) -> 
        { 
            ((Location) in[0].get(sc)).addZ(in[1].getDouble(sc)); 
            return Void.TYPE; 
        });  
        parser.registerFunction("loc.setyaw", (sc, in) -> 
        { 
            ((Location) in[0].get(sc)).setYaw(in[1].getFloat(sc)); 
            return Void.TYPE; 
        });  
        parser.registerFunction("loc.setpitch", (sc, in) -> 
        { 
            ((Location) in[0].get(sc)).setPitch(in[1].getFloat(sc)); 
            return Void.TYPE;
        });  
        parser.registerFunction("loc.distance", (sc, in) -> ((Location) in[0].get(sc)).getPos().distanceTo(((Location) in[1].get(sc)).getPos()));  
        parser.registerFunction("loc.mod", (sc, in) -> ((Location) in[0].get(sc)).copyAdd(in[1].getDouble(sc), in[2].getDouble(sc), in[3].getDouble(sc)));
        parser.registerFunction("loc.getcoord", (sc, in) -> 
        {
            Location l = (Location) in[0].get(sc);
            switch(in[1].getString(sc))
            {
                case "x":
                    return l.getX();
                case "y":
                    return l.getY();
                case "z":
                    return l.getZ();
                case "bx":
                    return (double) MathHelper.floor(l.getX());
                case "by":
                    return (double) MathHelper.floor(l.getY());
                case "bz":
                    return (double) MathHelper.floor(l.getZ());
                case "w":
                    return ModDimensions.getWorldName(l.getWorld());
                default:
                    return null;
            }
        });
        parser.registerFunction("loc.gettime", (sc, in) -> (double) ((Location) in[0].get(sc)).getWorld().getWorldTime());
        parser.registerFunction("loc.hasstorm", (sc, in) -> ((Location) in[0].get(sc)).getWorld().isRaining());
        parser.registerFunction("loc.isbetween", (sc, in) -> 
        { 
            Location l1 = (Location) in[0].get(sc);
            Location l2 = (Location) in[1].get(sc);
            Location l3 = (Location) in[2].get(sc);
            return l1.getX() >= Math.min(l2.getX(), l3.getX()) && l1.getX() <= Math.max(l2.getX(), l3.getX()) &&
                    l1.getY() >= Math.min(l2.getY(), l3.getY()) && l1.getY() <= Math.max(l2.getY(), l3.getY()) &&
                    l1.getZ() >= Math.min(l2.getZ(), l3.getZ()) && l1.getZ() <= Math.max(l2.getZ(), l3.getZ());
        });

        // ---------------------------------------------------------------------    
        // Block-Bibliothek
        // ---------------------------------------------------------------------    
        parser.registerFunction("block.gettype", (sc, in) -> 
        {
            Location l = (Location) in[0].get(sc);
            return l.getWorld().getBlockState(l.getBlockPos()).getBlock().getRegistryName().toString();
        });
        parser.registerFunction("block.get", (sc, in) -> 
        {
            Location l = (Location) in[0].get(sc);
            return l.getWorld().getBlockState(l.getBlockPos()).getBlock();
        });
        parser.registerFunction("block.getdata", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            IBlockState state = l.getWorld().getBlockState(l.getBlockPos());
            return (double) state.getBlock().getMetaFromState(state);
        });
        parser.registerFunction("block.clone", (sc, in) -> 
        { 
            Location l = (Location) in[1].get(sc);
            NBTUtils.cloneBlock(l.getWorld(), ((Location) in[0].get(sc)).getBlockPos(), l.getBlockPos());
            return Void.TYPE; 
        });
        parser.registerFunction("block.set", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            ItemStack stack = (ItemStack) in[1].get(sc);
            l.getWorld().setBlockState(l.getBlockPos(), Block.getBlockFromItem(stack.getItem()).getStateFromMeta(stack.getMetadata()));
            return Void.TYPE; 
        });
        parser.registerFunction("block.set2", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            if(in.length >= 4)
            {
                NBTUtils.setBlockWithData(l.getWorld(), l.getBlockPos(), in[2].getInt(sc), Block.getBlockFromName(in[1].getString(sc)), SnuviUtils.connect(sc, in, 3));
            }
            else
            {
                NBTUtils.setBlockWithData(l.getWorld(), l.getBlockPos(), in[2].getInt(sc), Block.getBlockFromName(in[1].getString(sc)), null);
            }
            return Void.TYPE; 
        });
        parser.registerFunction("block.setsign", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            TileEntitySign sign = (TileEntitySign) l.getWorld().getTileEntity(l.getBlockPos());
            SpecialBlockUtils.setSignLine(sign, in[1].getInt(sc), SnuviUtils.connect(sc, in, 2));
            return Void.TYPE;
        });
        parser.registerFunction("block.getsign", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            TileEntitySign sign = (TileEntitySign) l.getWorld().getTileEntity(l.getBlockPos());
            return sign.signText[in[1].getInt(sc)].getUnformattedText();
        });
        parser.registerFunction("block.setdoorstatus", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            BlockPos pos = l.getBlockPos();
            ((BlockDoor) l.getWorld().getBlockState(pos).getBlock()).toggleDoor(l.getWorld(), pos, in[1].getBoolean(sc));
            return Void.TYPE; 
        });
        parser.registerFunction("block.getdoorstatus", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            return BlockDoor.isOpen(l.getWorld(), l.getBlockPos());
        });
        parser.registerFunction("block.isdoor", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            return l.getWorld().getBlockState(l.getBlockPos()).getBlock() instanceof BlockDoor;
        });
        parser.registerFunction("block.issolid", (sc, in) -> 
        { 
            IBlockState state = getBlockState((Location) in[0].get(sc));
            return state.isFullBlock() && state.isOpaqueCube(); 
        });
        parser.registerFunction("block.tostack", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            World w = l.getWorld();
            BlockPos pos = l.getBlockPos();
            IBlockState state = w.getBlockState(pos);
            return state.getBlock().getItem(w, pos, state);
        });
        parser.registerFunction("block.getitemamount", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            TileEntity te = l.getWorld().getTileEntity(l.getBlockPos());
            if(te == null || !(te instanceof TileEntityChest))
            {
                return 0.0d;
            }        
            return (double) InventoryUtils.searchInventoryFor((TileEntityChest) te, (ItemStack) in[2].get(sc), in[1].getBoolean(sc));
        });
        parser.registerFunction("block.additem", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            ItemStack stack = ((ItemStack) in[1].get(sc));
            TileEntity te = l.getWorld().getTileEntity(l.getBlockPos());
            if(te == null || !(te instanceof TileEntityChest))
            {
                return stack;
            }        
            stack.setCount(InventoryUtils.addToInventory((TileEntityChest) te, stack));  
            return stack;
        });
        parser.registerFunction("block.subitem", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            ItemStack stack = ((ItemStack) in[1].get(sc));
            TileEntity te = l.getWorld().getTileEntity(l.getBlockPos());
            if(te == null || !(te instanceof TileEntityChest))
            {
                return stack;
            }        
            stack.setCount(InventoryUtils.removeFromInventory((TileEntityChest) te, stack));  
            return stack;
        });  
        parser.registerFunction("block.grow", (sc, in) ->
        {
            Location l1 = (Location) in[0].get(sc);
            World w = l1.getWorld();
            BlockPos pos1 = l1.getBlockPos();
            BlockPos pos2 = ((Location) in[1].get(sc)).getBlockPos();

            int x = Math.min(pos1.getX(), pos2.getX());
            int endX = Math.max(pos1.getX(), pos2.getX());

            int y = Math.min(pos1.getY(), pos2.getY());
            int endY = Math.max(pos1.getY(), pos2.getY());

            int z = Math.min(pos1.getZ(), pos2.getZ());
            int endZ = Math.max(pos1.getZ(), pos2.getZ());

            if(endX - x > 50 || endY - y > 50 || endZ - z > 50)
            {
                throw new IllegalArgumentException("uhh, that area seems way to big for growing plants");
            }

            BlockPos relative;
            IBlockState state;
            for(; x <= endX; x++)
            {
                for(; y <= endY; y++)
                {
                    for(; z <= endZ; z++)
                    {
                        relative = new BlockPos(x, y, z);
                        state = w.getBlockState(relative);
                        if(state.getBlock() instanceof BlockCrops)
                        {
                            w.setBlockState(relative, state.withProperty(BlockCrops.AGE, 7));                
                        }                      
                    }
                }
            }
            return Void.TYPE;
        });  

        // ---------------------------------------------------------------------    
        // Event-Bibliothek 
        // ---------------------------------------------------------------------  
        parser.registerFunction("event.addmovedata", (sc, in) -> CustomEventCaller.registerMoveData(new PlayerMoveData(
                sc, (Location) in[0].get(sc), (Location) in[1].get(sc), in[2].getInt(sc), in[3].getInt(sc))));
        parser.registerFunction("event.removemovedata", (sc, in) -> 
        { 
            CustomEventCaller.removeMoveData(in[0].getInt(sc));
            return Void.TYPE; 
        });

        // ---------------------------------------------------------------------    
        // Skill-Bibliothek 
        // --------------------------------------------------------------------- 
        parser.registerFunction("skill.register", (sc, in) -> 
        { 
            KajetansMod.skills.registerSkill(in[0].getInt(sc), (ItemStack) in[1].get(sc), Effect.valueOf(in[2].getString(sc)), 
                in[3].getString(sc), in[4].getString(sc), in[5].getInt(sc), in[6].getInt(sc), in[7].getInt(sc), in[8].getInt(sc));
            return Void.TYPE; 
        });              
        parser.registerFunction("skill.clear", (sc, in) -> { 
                KajetansMod.skills.clearSkills(); return Void.TYPE; });
        parser.registerFunction("skill.getactive", (sc, in) -> 
        { 
            in[0].set(sc, KajetansMod.jobs.getActiveSkills((EntityPlayer) in[1].get(sc))); 
            return Void.TYPE; 
        }); 
        parser.registerFunction("skill.getid", (sc, in) -> ((LeveledSkill) in[0].get(sc)).getId());
        parser.registerFunction("skill.fromid", (sc, in) -> 
        {
            Skill skill = KajetansMod.skills.getSkill(in[0].getInt(sc));
            if(skill == null)
            {
                return null;
            }
            byte level = (byte) EffectUtils.getEffectLevel((EntityPlayer) in[1].get(sc), skill.getEffect());
            if(level <= 0)
            {
                return null;
            }
            return new LeveledSkill(skill, level);
        });
        parser.registerFunction("skill.getstack", (sc, in) -> ((LeveledSkill) in[0].get(sc)).getItemStack());
        parser.registerFunction("skill.use", (sc, in) -> 
        { 
            ((LeveledSkill) in[0].get(sc)).useEffect((EntityPlayerMP) in[1].get(sc));
            return Void.TYPE; 
        });
        
        // ---------------------------------------------------------------------    
        // Job-Bibliothek 
        // ---------------------------------------------------------------------  
        parser.registerFunction("job.getlevel", (sc, in) -> (double) KajetansMod.jobs.getLevel((EntityPlayer) in[0].get(sc), in[1].getByte(sc)));
        parser.registerFunction("job.addlevel", (sc, in) -> 
        { 
            KajetansMod.jobs.addLevel((EntityPlayer) in[0].get(sc), in[1].getByte(sc), in[2].getByte(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("job.setlevel", (sc, in) -> 
        { 
            KajetansMod.jobs.setLevel((EntityPlayer) in[0].get(sc), in[1].getByte(sc), in[2].getByte(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("job.getxp", (sc, in) -> (double) KajetansMod.jobs.getXP((EntityPlayer) in[0].get(sc), in[1].getByte(sc)));
        parser.registerFunction("job.addxp", (sc, in) -> 
        { 
            KajetansMod.jobs.addXP((EntityPlayer) in[0].get(sc), in[1].getByte(sc), in[2].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("job.setxp", (sc, in) -> 
        { 
            KajetansMod.jobs.setXP((EntityPlayer) in[0].get(sc), in[1].getByte(sc), in[2].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("job.registerjob", (sc, in) -> 
        { 
            KajetansMod.jobs.registerJob(in[0].getByte(sc), SnuviUtils.connect(sc, in, 1)); 
            return Void.TYPE; 
        });
        parser.registerFunction("job.registerrecipe", (sc, in) -> 
        { 
            KajetansMod.jobs.registerRecipe(in[0].getByte(sc), ItemStackUtils.getItem(in[1].getString(sc)), in[2].getByte(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("job.registermaterial", (sc, in) -> 
        { 
            KajetansMod.jobs.registerPreferedBlock(in[0].getByte(sc), Block.getBlockFromName(in[1].getString(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("job.registerskill", (sc, in) -> 
        { 
            KajetansMod.jobs.registerSkill(in[0].getByte(sc), KajetansMod.skills.getSkill(in[1].getInt(sc)), in[2].getByte(sc), in[3].getByte(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("job.getamount", (sc, in) -> (double) KajetansMod.jobs.getNumberOfJobs());
        parser.registerFunction("job.getname", (sc, in) -> KajetansMod.jobs.getJobName(in[0].getByte(sc)));
        parser.registerFunction("job.geteffectlevel", (sc, in) -> (double) EffectUtils.getEffectLevel((EntityPlayer) in[0].get(sc), me.km.effects.Effect.valueOf(in[1].getString(sc))));
        parser.registerFunction("job.hasjob", (sc, in) -> KajetansMod.jobs.hasJob((EntityPlayer) in[0].get(sc), in[1].getByte(sc)));
        parser.registerFunction("job.hasrecipe", (sc, in) -> KajetansMod.jobs.hasRecipe((EntityPlayer) in[0].get(sc), ItemStackUtils.getItem(in[1].getString(sc))));
        parser.registerFunction("job.getjobs", (sc, in) -> 
        { 
            in[0].set(sc, KajetansMod.jobs.getJobs((EntityPlayer) in[1].get(sc)).stream().map(b -> (double) b).collect(Collectors.toList())); 
            return Void.TYPE; 
        });
        parser.registerFunction("job.isregmaterial", (sc, in) -> KajetansMod.jobs.isPreferedMaterial((EntityPlayer) in[0].get(sc),Block.getBlockFromName(in[1].getString(sc))));
        parser.registerFunction("job.setjob", (sc, in) -> 
        { 
            KajetansMod.jobs.setJob((EntityPlayer) in[0].get(sc), in[1].getByte(sc), in[2].getBoolean(sc)); 
            return Void.TYPE; 
        }); 
        parser.registerFunction("job.reset", (sc, in) -> 
        { 
            KajetansMod.jobs.resetAll(); 
            return Void.TYPE; 
        });  

        // ---------------------------------------------------------------------    
        // Entity - Befehle
        // ---------------------------------------------------------------------  
        parser.registerFunction("entity.getlocation", (sc, in) -> new Location((Entity) in[0].get(sc)));   
        parser.registerFunction("entity.damage", (sc, in) -> 
        { 
            // entity.damage(entity, damagefloat, DamageSource);
            if(in.length >= 3)
            {
                ((EntityLivingBase) in[0].get(sc)).attackEntityFrom((DamageSource) in[2].get(sc), in[1].getFloat(sc));
                return Void.TYPE; 
            }
            ((EntityLivingBase) in[0].get(sc)).attackEntityFrom(DamageSource.GENERIC, in[1].getFloat(sc));
            return Void.TYPE; 
        }); 
        parser.registerFunction("entity.getdamagesource", (sc, in) -> 
        { 
            Object o = in[0].get(sc);
            if(o instanceof EntityLivingBase)
            {
                EntityLivingBase ent = (EntityLivingBase) o;
                DamageSource ds;
                if(ent instanceof EntityPlayer)
                {
                    ds = DamageSource.causePlayerDamage((EntityPlayer) ent);
                }
                else
                {
                    ds = DamageSource.causeMobDamage(ent);
                }

                if(in[1].getBoolean(sc))
                {
                    ds.setDamageAllowedInCreativeMode();
                }
                if(in[2].getBoolean(sc))
                {
                    ds.setDamageBypassesArmor();
                }
                if(in[3].getBoolean(sc))
                {
                    ds.setDamageIsAbsolute();
                }
                if(in[4].getBoolean(sc))
                {
                    ds.setExplosion();
                }
                if(in[5].getBoolean(sc))
                {
                    ds.setFireDamage();
                }
                if(in[6].getBoolean(sc))
                {
                    ds.setMagicDamage();
                }
                if(in[7].getBoolean(sc))
                {
                   ds.setProjectile();
                } 
                return ds;
            }

            switch(o.toString())
            {
                case "IN_FIRE": return DamageSource.IN_FIRE;
                case "LIGHTNING_BOLT": return DamageSource.LIGHTNING_BOLT;
                case "ON_FIRE": return DamageSource.ON_FIRE;
                case "LAVA": return DamageSource.LAVA;
                case "HOT_FLOOR": return DamageSource.HOT_FLOOR;
                case "IN_WALL": return DamageSource.IN_WALL;
                case "CRAMMING": return DamageSource.CRAMMING;
                case "DROWN": return DamageSource.DROWN;
                case "STARVE": return DamageSource.STARVE;
                case "CACTUS": return DamageSource.CACTUS;
                case "FALL": return DamageSource.FALL;
                case "FLY_INTO_WALL": return DamageSource.FLY_INTO_WALL;
                case "OUT_OF_WORLD": return DamageSource.OUT_OF_WORLD;
                case "GENERIC": return DamageSource.GENERIC;
                case "MAGIC": return DamageSource.MAGIC;
                case "WITHER": return DamageSource.WITHER;
                case "ANVIL": return DamageSource.ANVIL;
                case "FALLING_BLOCK": return DamageSource.FALLING_BLOCK;
                case "DRAGON_BREATH": return DamageSource.DRAGON_BREATH;
                case "FIREWORKS": return DamageSource.FIREWORKS;
                case "THORNS": return DamageSource.causeThornsDamage((Entity) in[1].get(sc));
            }
            return DamageSource.GENERIC;
        });
        parser.registerFunction("entity.gethealth", (sc, in) -> (double) ((EntityLivingBase) in[0].get(sc)).getHealth());     
        parser.registerFunction("entity.sethealth", (sc, in) -> 
        { 
            ((EntityLivingBase) in[0].get(sc)).setHealth(in[1].getFloat(sc)); 
            return Void.TYPE; 
        });  
        parser.registerFunction("entity.setname", (sc, in) -> 
        { 
            Entity ent = (Entity) in[0].get(sc);
            ent.setCustomNameTag(in[1].getString(sc));
            if(in.length >= 3)
            {
                ent.setAlwaysRenderNameTag(in[2].getBoolean(sc));   
                return Void.TYPE; 
            }
            ent.setAlwaysRenderNameTag(true);  
            return Void.TYPE; 
        }); 
        parser.registerFunction("entity.getname", (sc, in) -> ((Entity) in[0].get(sc)).getDisplayName().getUnformattedText()); 
        parser.registerFunction("entity.throw", (sc, in) -> 
        { 
            Utils.setVelocity((Entity) in[0].get(sc), in[1].getDouble(sc), in[2].getDouble(sc), in[3].getDouble(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("entity.teleport", (sc, in) -> 
        { 
            Utils.teleportEntity((Entity) in[0].get(sc), (Location) in[1].get(sc)); 
            return Void.TYPE; 
        });  
        parser.registerFunction("entity.setequip", (sc, in) -> 
        { 
            EntityLivingBase liv = (EntityLivingBase) in[0].get(sc);  
            ItemStack stack = ((ItemStack) in[2].get(sc)).copy();
            switch(in[1].getString(sc))
            {
                case "hand":
                    liv.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, stack);
                    return Void.TYPE;
                case "head":
                    liv.setItemStackToSlot(EntityEquipmentSlot.HEAD, stack);
                    return Void.TYPE;
                case "chest":
                    liv.setItemStackToSlot(EntityEquipmentSlot.CHEST, stack);
                    return Void.TYPE;
                case "legs":
                    liv.setItemStackToSlot(EntityEquipmentSlot.LEGS, stack);
                    return Void.TYPE;
                case "feet":
                    liv.setItemStackToSlot(EntityEquipmentSlot.FEET, stack);
                    return Void.TYPE;
                case "offhand":
                    liv.setItemStackToSlot(EntityEquipmentSlot.OFFHAND, stack);
            }
            return Void.TYPE; 
        }); 
        parser.registerFunction("entity.getequip", (sc, in) -> 
        { 
            EntityLivingBase liv = (EntityLivingBase) in[0].get(sc);        
            switch(in[1].getString(sc))
            {
                case "hand":
                    return liv.getItemStackFromSlot(EntityEquipmentSlot.MAINHAND);
                case "head":
                    return liv.getItemStackFromSlot(EntityEquipmentSlot.HEAD);
                case "chest":
                    return liv.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
                case "legs":
                    return liv.getItemStackFromSlot(EntityEquipmentSlot.LEGS);
                case "feet":
                    return liv.getItemStackFromSlot(EntityEquipmentSlot.FEET);
                case "offhand":
                    return liv.getItemStackFromSlot(EntityEquipmentSlot.OFFHAND);
            }
            return ItemStack.EMPTY;
        });
        parser.registerFunction("entity.removeall", (sc, in) -> 
        { 
            Class<? extends Entity> c = (Class<? extends Entity>) getClass(in[0].getString(sc));
            if(c == Entity.class)
            {
                return Void.TYPE; 
            }
            Location l = (Location) in[1].get(sc);
            Utils.getEntities(l.getWorld(), l.getX(), l.getY(), l.getZ(), in[2].getDouble(sc), c).stream().forEach(ent -> 
            {
                ent.setDead();
            });
            return Void.TYPE; 
        });
        parser.registerFunction("entity.remove", (sc, in) -> 
        { 
            ((Entity) in[0].get(sc)).setDead(); 
            return Void.TYPE; 
        });
        parser.registerFunction("entity.setinvulnerable", (sc, in) -> 
        { 
            ((Entity) in[0].get(sc)).setEntityInvulnerable(in[1].getBoolean(sc)); 
            return Void.TYPE;
        });
        parser.registerFunction("entity.setsilent", (sc, in) -> 
        { 
            ((Entity) in[0].get(sc)).setSilent(in[1].getBoolean(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("entity.hide", (sc, in) -> 
        { 
            ((Entity) in[0].get(sc)).setInvisible(true); 
            return Void.TYPE; 
        });
        parser.registerFunction("entity.show", (sc, in) -> 
        { 
            ((Entity) in[0].get(sc)).setInvisible(false);
            return Void.TYPE; 
        });
        parser.registerFunction("entity.ride", (sc, in) -> 
        { 
            ((Entity) in[0].get(sc)).startRiding(((Entity) in[1].get(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("entity.addeffect", (sc, in) -> 
        { 
            EntityLivingBase base = (EntityLivingBase) in[0].get(sc);
            Potion potion = Potion.getPotionFromResourceLocation(in[1].getString(sc));
            if(base == null) // doing this only to prevent EffectUtils.addPotionTo doing shit
            {
                throw new NullPointerException("null not allowed for entity");
            }
            else if(potion == null)
            {
                throw new NullPointerException("potion does not exist");
            }
            EffectUtils.addPotionTo(base, potion, in[2].getInt(sc), in[3].getInt(sc));
            return Void.TYPE; 
        });
        parser.registerFunction("entity.haseffect", (sc, in) -> ((EntityLivingBase) in[0].get(sc)).isPotionActive(Potion.getPotionFromResourceLocation(in[1].getString(sc))));
        parser.registerFunction("entity.goto", (sc, in) -> 
        {
            Location l = (Location) in[1].get(sc);
            PathfinderUtils.walkTo((EntityLiving) in[0].get(sc), l.getX(), l.getY(), l.getZ(), in[2].getDouble(sc));
            return Void.TYPE; 
        });
        parser.registerFunction("entity.explode", (sc, in) -> 
        { 
            ((EntityCreeper) in[0].get(sc)).ignite(); 
            return Void.TYPE; 
        });
        parser.registerFunction("entity.spawnitemframe", (sc, in) -> 
        { 
            Location l = ((Location) in[0].get(sc));
            EntityItemFrame frame = new EntityItemFrame(l.getWorld(), l.getBlockPos(), EnumFacing.byName(in[1].getString(sc)));
            frame.setDisplayedItem(((ItemStack) in[2].get(sc))); // cppy happens in internals
            return Void.TYPE; 
        });
        parser.registerFunction("entity.getitemframe", (sc, in) -> ((EntityItemFrame) in[0].get(sc)).getDisplayedItem());
        parser.registerFunction("entity.get", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            return Utils.getEntity(l.getWorld(), l.getX(), l.getY(), l.getZ(), in[1].getDouble(sc), getClass(in[2].getString(sc)));
        });
        parser.registerFunction("entity.getpotiontype", (sc, in) -> PotionUtils.getPotionFromItem(((EntityPotion) in[0].get(sc)).getPotion()).getRegistryName().toString());
        parser.registerFunction("entity.setgravity", (sc, in) -> 
        { 
            ((Entity) in[0].get(sc)).setNoGravity(!in[1].getBoolean(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("entity.iswet", (sc, in) -> ((Entity) in[0].get(sc)).isWet());
        parser.registerFunction("entity.setpickupdelay", (sc, in) -> 
        { 
            ((EntityItem) in[0].get(sc)).setPickupDelay(in[1].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("entity.setage", (sc, in) -> 
        { 
            ReflectionUtils.setAge((EntityItem) in[0].get(sc), in[1].getInt(sc)); 
            return Void.TYPE; 
        });

        // ---------------------------------------------------------------------
        // Status-Bibliothek
        // ---------------------------------------------------------------------  
        parser.registerFunction("status.getmana", (sc, in) -> (double) EnvironmentAPI.getMana(((EntityPlayer) in[0].get(sc))));
        parser.registerFunction("status.getcold", (sc, in) -> (double) EnvironmentAPI.getCold(((EntityPlayer) in[0].get(sc))));
        parser.registerFunction("status.getenergy", (sc, in) -> (double) EnvironmentAPI.getEnergy(((EntityPlayer) in[0].get(sc))));
        parser.registerFunction("status.getthirst", (sc, in) -> (double) EnvironmentAPI.getThirst(((EntityPlayer) in[0].get(sc))));
        parser.registerFunction("status.changemange", (sc, in) -> 
        { 
            EnvironmentAPI.changeMana(((EntityPlayer) in[0].get(sc)), in[1].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("status.changecold", (sc, in) -> 
        { 
            EnvironmentAPI.changeCold(((EntityPlayer) in[0].get(sc)), in[1].getInt(sc)); 
            return Void.TYPE;
        });
        parser.registerFunction("status.changeenergie", (sc, in) -> 
        { 
            EnvironmentAPI.changeEnergy(((EntityPlayer) in[0].get(sc)), in[1].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("status.changethirst", (sc, in) -> 
        { 
            EnvironmentAPI.changeThirst(((EntityPlayer) in[0].get(sc)), in[1].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("status.resetmana", (sc, in) -> 
        { 
            EnvironmentAPI.resetMana(((EntityPlayer) in[0].get(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("status.resetcold", (sc, in) -> 
        { 
            EnvironmentAPI.resetCold(((EntityPlayer) in[0].get(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("status.resetenergy", (sc, in) -> 
        { 
            EnvironmentAPI.resetEnergy(((EntityPlayer) in[0].get(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("status.resetthirst", (sc, in) -> 
        { 
            EnvironmentAPI.resetThirst(((EntityPlayer) in[0].get(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("status.gettemperature", (sc, in) ->
        { 
            Location l = (Location) in[0].get(sc);
            return (double) EnvironmentAPI.getTemperature(l.getWorld(), l.getBlockPos()); 
        });    
        
        // ---------------------------------------------------------------------  
        // GMap-Bibliothek   
        // ---------------------------------------------------------------------  
        parser.registerFunction("gmap.removeall", (sc, in) -> 
        {    
            KajetansMod.scripts.getDataBank(ScriptBank.class).removeMap(in[0].getString(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("gmap.add", (sc, in) -> 
        {    
            KajetansMod.scripts.getDataBank(ScriptBank.class).addMapElement(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("gmap.remove", (sc, in) -> 
        {    
            KajetansMod.scripts.getDataBank(ScriptBank.class).removeMapElement(in[0].getString(sc), in[1].getString(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("gmap.totable", (sc, in) -> 
        {    
            in[0].set(sc, KajetansMod.scripts.getDataBank(ScriptBank.class).getGlobalMapAsTable(in[1].getString(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("gmap.get", (sc, in) -> KajetansMod.scripts.getDataBank(ScriptBank.class).getMapValue(in[0].getString(sc), in[1].getString(sc)));
        parser.registerFunction("gmap.getordefault", (sc, in) -> 
        {
            Object o = KajetansMod.scripts.getDataBank(ScriptBank.class).getMapValue(in[0].getString(sc), in[1].getString(sc));
            if(o == null)
            {
                return in[2].get(sc);
            }
            return o;
        });

        // ---------------------------------------------------------------------  
        // GDMap-Bibliothek   
        // ---------------------------------------------------------------------  
        parser.registerFunction("gdmap.removeall", (sc, in) -> 
        {    
            KajetansMod.scripts.getDataBank(ScriptBank.class).removeDualMap(in[0].getString(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("gdmap.add", (sc, in) -> 
        {    
            KajetansMod.scripts.getDataBank(ScriptBank.class).addDualMapElement(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc), in[3].getString(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("gdmap.remove", (sc, in) -> 
        {    
            KajetansMod.scripts.getDataBank(ScriptBank.class).removeDualMapElement(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("gdmap.totable", (sc, in) -> 
        {    
            in[0].set(sc, KajetansMod.scripts.getDataBank(ScriptBank.class).getGlobalDualMapAsTable(in[1].getString(sc), in[2].getString(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("gdmap.get", (sc, in) -> 
        {    
            return KajetansMod.scripts.getDataBank(ScriptBank.class).getDualMapValue(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc)); 
        });
        parser.registerFunction("gdmap.getordefault", (sc, in) -> 
        {
            Object o = KajetansMod.scripts.getDataBank(ScriptBank.class).getDualMapValue(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc));
            if(o == null)
            {
                return in[3].get(sc);
            }
            return o;
        });

        // ---------------------------------------------------------------------  
        // Table-Bibliothek   
        // ---------------------------------------------------------------------  
        parser.registerFunction("table.print", (sc, in) -> 
        {   
            Table t = (Table) in[1].get(sc);
            if(t.getSize() >= 60)
            {
                throw new IllegalArgumentException("table is too big");
            }
            Object group = in[0].get(sc);
            TableAPI.getTable(t, in[2].getInt(sc), in[3].getString(sc), in.length >= 5 ? in[4].getBoolean(sc) : false)
                    .forEach(s -> sendMessageToGroup(group, sc, new TextComponentString(s)));
            return Void.TYPE; 
        });
        parser.registerFunction("table.new", (sc, in) -> 
        { 
            in[0].set(sc, new Table(in[1].getInt(sc))); 
            return Void.TYPE; 
        });
        parser.registerFunction("table.frommap", (sc, in) -> 
        { 
            in[0].set(sc, new Table((Map<Object, Object>) in[1].get(sc))); 
            return Void.TYPE; 
        });
        parser.registerAlias("table.frommap", "map.totable");
        parser.registerFunction("table.sort", (sc, in) -> 
        { 
            ((Table) in[0].get(sc)).sort(); 
            return Void.TYPE; 
        });
        parser.registerFunction("table.reverse", (sc, in) -> 
        { 
            ((Table) in[0].get(sc)).reverse(); 
            return Void.TYPE; 
        });
        parser.registerFunction("table.shuffle", (sc, in) -> 
        { 
            ((Table) in[0].get(sc)).shuffle(); 
            return Void.TYPE; 
        });
        parser.registerFunction("table.clear", (sc, in) -> 
        { 
            ((Table) in[0].get(sc)).clear(); 
            return Void.TYPE; 
        });
        parser.registerFunction("table.addrow", (sc, in) -> 
        { 
            Object[] o = new Object[in.length - 1];
            for(int i = 1; i < in.length; i++)
            {
                o[i - 1] = in[i].get(sc);
            }
            ((Table) in[0].get(sc)).addRow(o); 
            return Void.TYPE;
        });
        parser.registerFunction("table.removerow", (sc, in) -> 
        { 
            ((Table) in[0].get(sc)).removeRow(in[1].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("table.get", (sc, in) -> ((Table) in[0].get(sc)).getElement(in[1].getInt(sc), in[2].getInt(sc)));
        parser.registerFunction("table.set", (sc, in) -> 
        { 
            ((Table) in[0].get(sc)).setElement(in[1].getInt(sc), in[2].getInt(sc), in[3].get(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("table.getindexof", (sc, in) -> (double) ((Table) in[0].get(sc)).getIndexOf(in[1].get(sc)));
        parser.registerFunction("table.setsortcolumn", (sc, in) -> 
        { 
            ((Table) in[0].get(sc)).setSortColumn(in[1].getInt(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("table.getsize", (sc, in) -> (double) ((Table) in[0].get(sc)).getSize());

        // ---------------------------------------------------------------------  
        // Plot-Bibliothek   
        // ---------------------------------------------------------------------  
        parser.registerFunction("plot.hastag", (sc, in) -> KajetansMod.plots.getDataBank(ProtectionBank.class).hasTag(((Location) in[0].get(sc)).getWorld(), ((Location) in[0].get(sc)).getBlockPos(), in[1].getString(sc))); 
        parser.registerFunction("plot.add", (sc, in) -> 
        {    
            Location l1 = (Location) in[0].get(sc);
            Location l2 = (Location) in[1].get(sc);
            BlockPos pos1 = l1.getBlockPos();
            BlockPos pos2 = l2.getBlockPos();
            KajetansMod.plots.getDataBank(ProtectionBank.class).addPlot(Math.min(pos1.getX(), pos2.getX()),
                        Math.min(pos1.getY(), pos2.getY()),
                        Math.min(pos1.getZ(), pos2.getZ()),
                        Math.max(pos1.getX(), pos2.getX()),
                        Math.max(pos1.getY(), pos2.getY()),
                        Math.max(pos1.getZ(), pos2.getZ()),
                        ModDimensions.getWorldName(l1.getWorld()), null, in[2].getString(sc)); 
            return Void.TYPE;
        });
        parser.registerFunction("plot.getids", (sc, in) -> 
        {  
            Location l = (Location) in[1].get(sc);
            in[0].set(sc, KajetansMod.plots.getDataBank(ProtectionBank.class).getRegionIds(l.getWorld(), 
                l.getBlockPos()).stream().map(o -> ((Number) o).doubleValue()).collect(Collectors.toSet())); 
            return Void.TYPE; 
        });
        parser.registerFunction("plot.canbuild", (sc, in) -> 
        {    
            Location l = (Location) in[0].get(sc);
            return KajetansMod.plots.getDataBank(ProtectionBank.class).canBuild(l.getWorld(), l.getBlockPos(), (EntityPlayer) in[1].get(sc));
        });
        parser.registerFunction("plot.getname", (sc, in) -> 
        {    
            Location l = (Location) in[0].get(sc);
            KajetansMod.plots.getDataBank(ProtectionBank.class).getFirstRegionName(l.getWorld(), l.getBlockPos()); 
            return Void.TYPE; 
        });
        parser.registerFunction("plot.doesintersect", (sc, in) -> 
        {    
            Location l1 = (Location) in[0].get(sc);
            Location l2 = (Location) in[1].get(sc);
            int x1 = (int) Math.min(l1.getX(), l2.getX());
            int x2 = (int) Math.max(l1.getX(), l2.getX());
            int y1 = (int) Math.min(l1.getY(), l2.getY());
            int y2 = (int) Math.max(l1.getY(), l2.getY());
            int z1 = (int) Math.min(l1.getZ(), l2.getZ());
            int z2 = (int) Math.max(l1.getZ(), l2.getZ());
            return KajetansMod.plots.getDataBank(ProtectionBank.class).isPlotOverlapping(x1, y1, z1, x2, y2, z2, l1.getWorld());
        });
        
        // ---------------------------------------------------------------------  
        // Script-Bibliothek   
        // ---------------------------------------------------------------------    
        parser.registerFunction("script.playerstolist", (sc, in) -> 
        {  
            in[0].set(sc, new ArrayList<>(KajetansMod.scripts.getPlayerList(sc.getId()))); 
            return Void.TYPE; 
        }); 
        parser.registerFunction("script.getplayeramount", (sc, in) -> (double) KajetansMod.scripts.getPlayerList(sc.getId()).size()); 
        parser.registerFunction("script.start", (sc, in) -> 
        {  
            Object o = in[0].get(sc);
            if(o instanceof EntityPlayer)
            {
                String[] names = new String[in.length - 1];
                for(int i = 1; i < in.length; i++)
                {
                    names[i - 1] = in[i].getString(sc);
                }
                return KajetansMod.scripts.startPlayerScript((EntityPlayer) in[0].get(sc), names);
            }
            String[] names = new String[in.length];
            names[0] = o.toString();
            for(int i = 1; i < in.length; i++)
            {
                names[i - 1] = in[i].getString(sc);
            }
            KajetansMod.scripts.startScript(names);
            return true;
        });
        parser.registerFunction("script.get", (sc, in) -> KajetansMod.scripts.getScript(in[0].getString(sc)));
        parser.registerFunction("script.join", (sc, in) -> KajetansMod.scripts.registerPlayer((Script) in[0].get(sc), (EntityPlayer) in[1].get(sc)));
        parser.registerFunction("script.kick", (sc, in) -> KajetansMod.scripts.unregisterPlayer((EntityPlayer) in[0].get(sc)));
        parser.registerFunction("script.getleader", (sc, in) -> 
        { 
            List<EntityPlayer> players = KajetansMod.scripts.getPlayerList(sc.getId());
            if(players.isEmpty())
            {
                return null;
            }
            return players.get(0);
        });

        // ---------------------------------------------------------------------  
        // Scoreboard-Bibliothek   
        // ---------------------------------------------------------------------  
        parser.registerFunction("sb.add", (sc, in) -> 
        {  
            int id = in[1].getInt(sc);
            String message = SnuviUtils.connect(sc, in, 2);
            doForGroup(in[0].get(sc), sc, p -> KajetansMod.scoreboard.getScoreboard((EntityPlayerMP) p).addText(id, message));
            return Void.TYPE; 
        });
        parser.registerFunction("sb.remove", (sc, in) -> 
        {  
            int id = in[1].getInt(sc);
            doForGroup(in[0].get(sc), sc, p -> KajetansMod.scoreboard.getScoreboard((EntityPlayerMP) p).removeText(id));
            return Void.TYPE; 
        });
        parser.registerFunction("sb.reset", (sc, in) -> 
        {  
            doForGroup(in[0].get(sc), sc, p -> KajetansMod.scoreboard.resetScoreboard((EntityPlayerMP) p)); 
            return Void.TYPE; 
        });
        
        // ---------------------------------------------------------------------  
        // Display-Bibliothek   
        // ---------------------------------------------------------------------  
        parser.registerFunction("display.add", (sc, in) -> 
        {  
            byte id = in[1].getByte(sc);
            String message = SnuviUtils.connect(sc, in, 2);
            doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToDisplay((EntityPlayerMP) p, (byte) 1, id, message));
            return Void.TYPE; 
        }); 
        parser.registerFunction("display.remove", (sc, in) -> 
        {  
            byte id = in[1].getByte(sc);
            doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToDisplay((EntityPlayerMP) p, (byte) 2, id, ""));
            return Void.TYPE; 
        });
        parser.registerFunction("display.reset", (sc, in) -> 
        {  
            doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToDisplay((EntityPlayerMP) p, (byte) 3, (byte) -1, "")); 
            return Void.TYPE; 
        });
        
        // ---------------------------------------------------------------------  
        // Head-Bibliothek   
        // ---------------------------------------------------------------------  
        parser.registerFunction("head.add", (sc, in) -> 
        {  
            byte id = in[1].getByte(sc);
            String name = in[2].getString(sc);
            int x = in[3].getInt(sc);
            int y = in[4].getInt(sc);
            byte scale = in[5].getByte(sc);
            doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToHead((EntityPlayerMP) p, (byte) 1, id, name, x, y, scale));
            return Void.TYPE; 
        }); 
        parser.registerFunction("head.remove", (sc, in) -> 
        {  
            byte id = in[1].getByte(sc);
            doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToHead((EntityPlayerMP) p, (byte) 2, id, "", -1, -1, (byte) -1));
            return Void.TYPE; 
        });
        parser.registerFunction("head.reset", (sc, in) -> 
        {  
            doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToHead((EntityPlayerMP) p, (byte) 3, (byte) -1, "", -1, -1, (byte) -1));
            return Void.TYPE; 
        });
        
        // ---------------------------------------------------------------------  
        // Effect-Bibliothek   
        // --------------------------------------------------------------------- 
        parser.registerFunction("effect.playsound", (sc, in) -> 
        { 
            Location l = (Location) in[0].get(sc);
            Vec3d v = l.getPos();
            EffectUtils.playSound((WorldServer) l.getWorld(), SoundEvent.REGISTRY.getObject(new ResourceLocation(in[1].getString(sc))), SoundCategory.MASTER, v.x, v.y, v.z);
            return Void.TYPE; 
        });
        parser.registerFunction("effect.play", (sc, in) -> 
        { 
            Location l = ((Location) in[0].get(sc));
            EffectUtils.spawnParticle((WorldServer) l.getWorld(), EnumParticleTypes.getByName(in[1].getString(sc)), l.getX() + 0.5, l.getY() + 0.5, l.getZ() + 0.5, in[2].getInt(sc));
            return Void.TYPE; 
        });

        // ---------------------------------------------------------------------  
        // Inventory-Bibliothek   
        // ---------------------------------------------------------------------
        parser.registerFunction("inv.new", (sc, in) -> 
        { 
            in[0].set(sc, new SnuviInventory(in[2].getString(sc), in[1].getInt(sc), inventoryIds++)); 
            return Void.TYPE; 
        }); 
        parser.registerFunction("inv.newdynamic", (sc, in) -> 
        { 
            in[0].set(sc, new SnuviInventory(in[2].getString(sc), in[1].getString(sc), inventoryIds++)); 
            return Void.TYPE; 
        }); 
        parser.registerFunction("inv.getid", (sc, in) -> 
        { 
            return (double) ((SnuviInventory) in[0].get(sc)).getId(); 
        }); 
        parser.registerFunction("inv.loadblock", (sc, in) -> 
        { 
            Location l = (Location) in[1].get(sc);
            TileEntityChest chest = (TileEntityChest) l.getWorld().getTileEntity(l.getBlockPos());
            int size = chest.getSizeInventory();
            if(size % 9 != 0)
            {
                size /= 9;
                size++;
                size *= 9;
            }
            SnuviInventory inv = new SnuviInventory(in[2].getString(sc), size, inventoryIds++); 
            for(int i = 0; i < chest.getSizeInventory(); i++)
            {
                inv.setInventorySlotContents(i, chest.getStackInSlot(i).copy());
            }
            in[0].set(sc, inv); 
            return Void.TYPE; 
        });
        parser.registerFunction("inv.setitem", (sc, in) -> 
        { 
            ((IInventory) in[0].get(sc)).setInventorySlotContents(in[1].getInt(sc), (ItemStack) in[2].get(sc)); 
            return Void.TYPE; 
        });
        parser.registerFunction("inv.getitem", (sc, in) -> ((IInventory) in[0].get(sc)).getStackInSlot(in[1].getInt(sc)));
        parser.registerFunction("inv.open", (sc, in) -> 
        { 
            new ScriptInventoryHolder((SnuviInventory) in[0].get(sc), (EntityPlayerMP) in[1].get(sc), sc).openForPlayer(); 
            return Void.TYPE; 
        });
        parser.registerFunction("inv.close", (sc, in) -> 
        { 
            EntityPlayer p = (EntityPlayer) in[0].get(sc);
            if(p.openContainer instanceof CustomContainer)
            {
                ((CustomContainer) p.openContainer).closeSafe();
            }
            else
            {
                p.closeScreen();
            }
            return Void.TYPE; 
        });      
        parser.registerFunction("inv.update", (sc, in) ->  
        {
            EntityPlayerMP p = (EntityPlayerMP) in[0].get(sc);
            NonNullList<ItemStack> list = NonNullList.<ItemStack>create();
            int size = p.openContainer.inventorySlots.size();
            for(int j = 0; j < size; j++)
            {
                ItemStack itemstack = p.openContainer.inventorySlots.get(j).getStack();
                list.add(itemstack.isEmpty() ? ItemStack.EMPTY : itemstack);
            }
            p.sendAllContents(p.openContainer, list);
            return Void.TYPE; 
        }); 

        // ---------------------------------------------------------------------  
        // Read-Bibliothek   
        // ---------------------------------------------------------------------
        parser.registerFunction("read.player", (sc, in) -> 
        {
            try
            {
                return Utils.getPlayerByName(in[0].getString(sc));
            }
            catch(PlayerNotFoundException ex)
            {
                return null;
            }
        });
        parser.registerFunction("read.location", (sc, in) -> new Location(in[0].getString(sc)));
        parser.registerFunction("read.item", (sc, in) -> 
        {
            String s = in[0].getString(sc);
            if(s.startsWith("{"))
            {
                String left = SnuviUtils.connect(sc, in, 1);
                return ItemStackUtils.getStackFromNbtString((s + left).replace('\'', '"'));
            }
            if(s.indexOf(':') == -1)
            {
                s = "minecraft:" + s;
            }
            Item item = ItemStackUtils.getItem(s);
            int amount = in.length >= 2 ? in[1].getInt(sc) : 1;
            int meta = in.length >= 3 ? in[2].getInt(sc) : 0;
            ItemStack stack = new ItemStack(item, amount, meta);
            if(in.length >= 4)
            {
                stack.setStackDisplayName(in[3].getString(sc));
            }
            if(in.length >= 5)
            {
                for(int i = 4; i < in.length; i++)
                {
                    ItemStackUtils.addLore(stack, in[i].getString(sc));
                }
            }
            return stack;
        });
        parser.registerFunction("read.spawnmob", (sc, in) -> NBTUtils.fromString(SnuviUtils.connect(sc, in, 1).replace('\'', '"'), (Location) in[0].get(sc)));

        // ---------------------------------------------------------------------  
        // Text-Bibliothek   
        // ---------------------------------------------------------------------
        parser.registerFunction("text.location", (sc, in) -> ((Location) in[0].get(sc)).toString());
        parser.registerFunction("text.locationblock", (sc, in) -> ((Location) in[0].get(sc)).toBlockString());
        parser.registerFunction("text.item", (sc, in) -> ItemStackUtils.getNbtString((ItemStack) in[0].get(sc)));
        parser.registerFunction("text.click", (sc, in) -> NBTUtils.getClickable(in[0].get(sc), in[1].getString(sc)));
        parser.registerFunction("text.hover", (sc, in) -> NBTUtils.getHoverable(in[0].get(sc), in[1].getString(sc)));

        // ---------------------------------------------------------------------    
        // Ohne Bibliothek
        // ---------------------------------------------------------------------   
        parser.registerFunction("getglobalvar", (sc, in) -> 
        {         
            Object o = in[0].get(sc);
            if(in.length == 2)
            {
                if(o instanceof EntityPlayer)
                {
                    return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), ((EntityPlayer) o).getUniqueID().toString());
                }
                else if(o.equals("SERVER"))
                {
                    return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), "-1");
                }
                return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), o.toString());
            }
            if(o instanceof EntityPlayer)
            {
                return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), ((EntityPlayer) o).getUniqueID().toString(), in[2].get(sc));
            }
            else if(o.equals("SERVER"))
            {
                return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), "-1", in[2].get(sc));
            }
            return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), o.toString(), in[2].get(sc));
        });
        parser.registerAlias("getglobalvar", "ggv");
        parser.registerFunction("setglobalvar", (sc, in) -> 
        { 
            Object o = in[0].get(sc);
            if(o instanceof EntityPlayer)
            {
                KajetansMod.scripts.getDataBank(ScriptBank.class).setVar(in[2].getString(sc), in[1].getString(sc), ((EntityPlayer) o).getUniqueID().toString());
            }
            else if(o.equals("SERVER"))
            {
                KajetansMod.scripts.getDataBank(ScriptBank.class).setVar(in[2].getString(sc), in[1].getString(sc), "-1");
            }
            else
            {
                KajetansMod.scripts.getDataBank(ScriptBank.class).setVar(in[2].getString(sc), in[1].getString(sc), o.toString());
            }
            return Void.TYPE; 
        });                          
        parser.registerAlias("setglobalvar", "sgv");
        parser.registerFunction("delglobalvar", (sc, in) -> 
        { 
            Object o = in[0].get(sc);
            if(o instanceof EntityPlayer)
            {
                KajetansMod.scripts.getDataBank(ScriptBank.class).deleteVar(in[1].getString(sc), ((EntityPlayer) o).getUniqueID().toString());
            }
            else if(o.equals("SERVER"))
            {
                KajetansMod.scripts.getDataBank(ScriptBank.class).deleteVar(in[1].getString(sc), "-1");
            }
            else
            {
                KajetansMod.scripts.getDataBank(ScriptBank.class).deleteVar(in[1].getString(sc), o.toString());
            }
            return Void.TYPE; 
        }); 
        parser.registerAlias("delglobalvar", "dgv");
        parser.registerFunction("msg", (sc, in) -> 
        { 
            sendMessageToGroup(in[0].get(sc), sc, NBTUtils.concat(sc, 1, in)); 
            return Void.TYPE; 
        });       
        parser.registerFunction("removeformat", (sc, in) -> SnuviUtils.connect(sc, in, 0).replaceAll("§.", ""));           
        parser.registerFunction("concatspace", (sc, in) -> SnuviUtils.connect(sc, in, " ", 0));     
        parser.registerFunction("onlyletters", (sc, in) -> 
        {             
            for(char c : SnuviUtils.connect(sc, in, 0).toCharArray())
            {
                if(!Character.isLetter(c))
                {
                    return false;
                }
            }
            return true;
        });
        parser.registerFunction("command", (sc, in) -> 
        { 
            KajetansMod.scheduler.scheduleTask(() -> KajetansMod.server.commandManager.executeCommand(KajetansMod.server, SnuviUtils.connect(sc, in, 0))); 
            return Void.TYPE;
        });
    }
    
    private static Class getClass(String s)
    {
        try
        {
            return Class.forName(s);
        }
        catch(ClassNotFoundException ex)
        {
            throw new IllegalStringException(s);
        }
    }
    
    // ---------------------------------------------------------------------------------    
    // Block
    // --------------------------------------------------------------------------------- 

    private static IBlockState getBlockState(Location l)
    {
        return l.getWorld().getBlockState(l.getBlockPos());
    }

    // ---------------------------------------------------------------------------------    
    // Gruppen-Handler
    // --------------------------------------------------------------------------------- 

    public static void doForGroup(Object group, Script sc, Consumer<ICommandSender> c)
    {
        if(group instanceof String)
        {
            switch(group.toString()) 
            {
                case "all":
                    KajetansMod.scripts.getPlayerList(sc.getId()).forEach(p -> c.accept(p));
                    break;
                case "online":
                    KajetansMod.server.getPlayerList().getPlayers().forEach(p -> c.accept(p));
                    break;
                case "dev":
                    ChatChannel.getDevChannel().forEach((p) -> c.accept(p));
                    break;
                case "server":
                    c.accept(KajetansMod.server);
                    break;
                default:
                    c.accept(Utils.getPlayerByName(group.toString()));
                    break;
            }
            return;
        }
        c.accept((EntityPlayer) group);
    } 
    
    private static void sendMessageToGroup(Object group, Script sc, ITextComponent text)
    {
        doForGroup(group, sc, p -> p.sendMessage(text));
    }
}