package me.km.snuviscript;

import com.google.common.collect.HashBiMap;
import me.km.KajetansMod;
import me.km.afk.AfkListener;
import me.km.api.Module;
import me.km.api.Utils;
import me.km.environment.EnvironmentAPI;
import me.km.exception.CodeTooLongException;
import me.km.exception.EntityNotFoundException;
import me.km.exception.GotoLabelNotFoundException;
import me.km.exception.HoldCodeException;
import me.km.exception.IfWithoutStatementException;
import me.km.exception.IllegalItemStackStringException;
import me.km.exception.IllegalStringException;
import me.km.exception.IllegalStringLocationException;
import me.km.exception.NoChildTreeException;
import me.km.exception.PlayerNotFoundException;
import me.km.nms.NmsUtilities;
import me.km.plots.ProtectionBank;
import me.km.table.TableAPI;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.BiConsumer;
import java.util.stream.Collectors;
import me.km.api.Location;
import me.km.api.TitleAPI;
import me.km.dimensions.ModDimensions;
import me.km.effects.EffectUtils;
import me.km.inventory.InventoryUtils;
import me.km.permissions.Permission;
import me.km.permissions.Permissions;
import me.km.table.Table;
import me.km.utils.ItemStackUtils;
import me.km.utils.ReflectionUtils;
import net.minecraft.block.Block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.command.ICommandSender;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityHanging;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityArmorStand;
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.player.InventoryPlayer;
import net.minecraft.entity.projectile.EntityPotion;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.network.play.server.SPacketSpawnPosition;
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.SoundCategory;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.world.World;
import net.minecraft.world.WorldServer;

public class QuestParser 
{
    private final BiFunction<Object[], QuestData, Object>[] methods;
    private final HashBiMap<String, Integer> translator;
    
    private void nothing()
    {
    }
    
    public Integer translateMethod(String s)
    {
        return translator.get(s);
    }
    
    private void registerFunction(List<BiFunction<Object[], QuestData, Object>> list, String s, BiFunction<Object[], QuestData, Object> f)
    {
        translator.put(s, list.size());
        list.add(f);
    }
    
    private void registerConsumer(List<BiFunction<Object[], QuestData, Object>> list, String s, BiConsumer<Object[], QuestData> f)
    {
        translator.put(s, list.size());
        list.add((BiFunction<Object[], QuestData, Object>) (args, qd) -> 
        {
            f.accept(args, qd);
            return 0;
        });
    }
    
    private void registerAlias(List<BiFunction<Object[], QuestData, Object>> list, String s, String original)
    {
        registerFunction(list, s, list.get(translator.get(original))); 
    }
    
    @SuppressWarnings("unchecked")
    public QuestParser()
    {
        ArrayList<BiFunction<Object[], QuestData, Object>> list = new ArrayList<>();
        translator = HashBiMap.create(300);
        
        registerFunction(list, "nothing", (args, qd) -> 
                0);
        registerConsumer(list, "godeeper", (args, qd) -> 
                qd.goDeeper(false));
        registerConsumer(list, "benchmark", (args, qd) -> 
                qd.printBenchmarks((ICommandSender) args[0]));
        registerConsumer(list, "togglebenchmark", (args, qd) -> 
                qd.toggleBenchmark());
        registerConsumer(list, "clearbenchmark", (args, qd) -> 
                qd.clearBenchmark());

        // -------------------------------------------------------------
        // Title-Bibliothek  
        // -------------------------------------------------------------
        registerConsumer(list, "title.settime", (args, qd) -> 
                TitleAPI.setTitleTime((EntityPlayerMP) args[0], QuestUtils.getInt(args[1]), QuestUtils.getInt(args[2]), QuestUtils.getInt(args[3])));
        registerConsumer(list, "title.clear", (args, qd) -> 
                TitleAPI.clearTitle((EntityPlayerMP) args[0]));
        registerConsumer(list, "title.reset", (args, qd) -> 
                TitleAPI.resetTitle((EntityPlayerMP) args[0]));
        registerConsumer(list, "title.send", (args, qd) -> 
                TitleAPI.setTitle((EntityPlayerMP) args[0], QuestUtils.connect(args, 1)));
        registerConsumer(list, "title.setsub", (args, qd) -> 
                TitleAPI.setSubTitle((EntityPlayerMP) args[0], QuestUtils.connect(args, 1)));
        
        // -------------------------------------------------------------
        // Villager-Bibliothek  
        // -------------------------------------------------------------
        registerConsumer(list, "villager.showtrades", (args, qd) -> 
                ((EntityPlayer) args[0]).displayVillagerTradeGui(((EntityVillager) args[1])));
        
        // -------------------------------------------------------------    
        // Player-Bibliothek
        // -------------------------------------------------------------  
        registerFunction(list, "player.getitemamount", (args, qd) ->       
                InventoryUtils.searchInventoryFor(((EntityPlayer) args[0]).inventory, (ItemStack) args[2], (boolean) args[1]));                
        registerFunction(list, "player.removeitem", (args, qd) -> 
                removeItem(args));                 
        registerFunction(list, "player.giveitem", (args, qd) ->       
                giveItem(args));
        registerConsumer(list, "player.shootitem", (args, qd) -> nothing());
                // TODO Utils.shootItemWithEvent((EntityPlayer) args[0], ((ItemStack) args[5]).clone(), QuestUtils.getDouble(args[1]), QuestUtils.getDouble(args[2]), QuestUtils.getDouble(args[3]), QuestUtils.getDouble(args[4])));
        registerConsumer(list, "player.shootprojectile", (args, qd) -> nothing());
                // TODO Utils.shootProjectile(((EntityPlayer) args[0]), (Class<? extends Projectile>) getClass("org.bukkit.entity." + args[1]), QuestUtils.getDouble(args[2])));
        registerConsumer(list, "player.respawn", (args, qd) -> nothing()
                /* TODO ((EntityPlayerMP) args[0]).respawnPlayer()*/);
        registerConsumer(list, "player.inventorytolist", (args, qd) -> 
                qd.setVar(args[0], ((EntityPlayer) args[1]).inventory.mainInventory));    
        registerFunction(list, "player.getamount", (args, qd) ->                            
                KajetansMod.server.getCurrentPlayerCount());
        registerFunction(list, "player.getnearest", (args, qd) ->                            
                Utils.getNearestPlayer(((Location) args[0]).getWorld(), ((Location) args[0]).getPos())); 
        registerConsumer(list, "player.say", (args, qd) -> nothing());
                // TODO ((EntityPlayerMP) args[0]).connection.chat(QuestUtils.connect(args, 1)));
        registerFunction(list, "player.isafk", (args, qd) -> 
                KajetansMod.afkManager.getEvent(AfkListener.class).isAfk(((EntityPlayer) args[0])));
        registerConsumer(list, "player.speak", (args, qd) -> 
                sendMessageToGroup(args[0], qd, "§7[§r" + args[1] + "§7] " + QuestUtils.connect(args, 2)));
        registerFunction(list, "player.getquestleader", (args, qd) -> 
                getQuestLeader(qd));
        registerConsumer(list, "player.setcompass", (args, qd) -> 
                ((EntityPlayerMP) args[0]).connection.sendPacket(new SPacketSpawnPosition(((Location) args[1]).getBlockPos()))); 
        registerFunction(list, "player.gethunger", (args, qd) -> 
                ((EntityPlayer) args[0]).getFoodStats().getFoodLevel());
        registerConsumer(list, "player.sethunger", (args, qd) -> 
                ((EntityPlayer) args[0]).getFoodStats().setFoodLevel(QuestUtils.getInt(args[1])));
        registerFunction(list, "player.getsaturation", (args, qd) -> 
                ReflectionUtils.getSaturation(((EntityPlayer) args[0]).getFoodStats()));
        registerConsumer(list, "player.setsaturation", (args, qd) -> 
                ReflectionUtils.setSaturation(((EntityPlayer) args[0]).getFoodStats(), QuestUtils.getFloat(args[1])));
        registerFunction(list, "player.getname", (args, qd) -> 
                getName(args));
        registerFunction(list, "player.getfullname", (args, qd) -> 
                KajetansMod.chatManager.getFullName((EntityPlayer) args[0]));
        registerFunction(list, "player.getuuid", (args, qd) -> 
                getUuid(args));
        registerFunction(list, "player.getip", (args, qd) -> 
                ((EntityPlayerMP) args[0]).connection.netManager.getRemoteAddress().toString());
        registerFunction(list, "player.iscreative", (args, qd) -> 
                ((EntityPlayer) args[0]).isCreative());
        registerFunction(list, "player.isspectator", (args, qd) -> 
                ((EntityPlayer) args[0]).isSpectator());
        registerFunction(list, "player.hasfly", (args, qd) -> 
                ((EntityPlayer) args[0]).capabilities.allowFlying);
        registerFunction(list, "player.getlastdamager", (args, qd) -> 
                ((EntityPlayer) args[0]).getLastAttacker());
        registerConsumer(list, "player.settag", (args, qd) -> 
                setTag(args));
        registerFunction(list, "player.gettag", (args, qd) -> 
                getTag(args));
        registerConsumer(list, "player.dropinventory", (args, qd) -> 
                dropInventory(args));
        registerFunction(list, "player.gettarget", (args, qd) -> 
                Utils.getPlayerTarget((EntityPlayer) args[0], QuestUtils.getInt(args[1])));
        registerFunction(list, "player.hasquest", (args, qd) ->     
                KajetansMod.quest.hasQuest((EntityPlayer) args[0]));
        registerConsumer(list, "player.action", (args, qd) ->     
                sendToActionBar(args, qd)); 
        registerConsumer(list, "player.kick", (args, qd) -> 
                kickPlayerFromQuest(args, qd));  
        registerConsumer(list, "player.playsound", (args, qd) -> 
                playSoundPlayer(args));
        registerFunction(list, "player.getbedspawn", (args, qd) ->     
                ((EntityPlayer) args[0]).getBedLocation(QuestUtils.getInt(args[1])));
        registerConsumer(list, "player.setbedspawn", (args, qd) ->     
                ((EntityPlayer) args[0]).bedLocation = ((Location) args[1]).getBlockPos());
        registerConsumer(list, "player.damageitem", (args, qd) ->   
                ((EntityPlayer) args[0]).getHeldItemMainhand().damageItem(QuestUtils.getInt(args[1]), (EntityPlayer) args[0]));

        // -------------------------------------------------------------    
        // Players-Bibliothek
        // -------------------------------------------------------------   
        registerConsumer(list, "players.tolist", (args, qd) ->     
                qd.setVar(args[0].toString(), Arrays.asList(KajetansMod.server.getOnlinePlayerNames())));    
        registerConsumer(list, "players.toworldlist", (args, qd) ->     
                qd.setVar(args[0].toString(), new ArrayList(ModDimensions.getWorldFromName(args[1].toString()).playerEntities)));
        registerConsumer(list, "players.near", (args, qd) ->     
                qd.setVar(args[0].toString(), Utils.getNearbyEntities(((Location) args[1]).getWorld(), ((Location) args[1]).getPos(), QuestUtils.getDouble(args[2]), EntityPlayer.class).stream().map(p -> p.getName()).collect(Collectors.toList()))); 

        // -------------------------------------------------------------    
        // Rank-Bibliothek
        // -------------------------------------------------------------  
        registerConsumer(list, "rank.get", (args, qd) -> 
                qd.setVar(args[0], KajetansMod.chatManager.getRanks((EntityPlayer) args[1])));
        registerConsumer(list, "rank.register", (args, qd) -> 
                KajetansMod.chatManager.registerRank(args[0].toString(), QuestUtils.getInt(args[1]), args[2].toString()));
        registerConsumer(list, "rank.clear", (args, qd) -> 
                KajetansMod.chatManager.clearRanks());
        
        // -------------------------------------------------------------    
        // Custom-Bibliothek
        // -------------------------------------------------------------
        registerConsumer(list, "custom.registerenchantmentrecipe", (args, qd) -> 
                registerEnchantmentRecipe(args));
        registerConsumer(list, "custom.registershapelessrecipe", (args, qd) -> 
                registerShapelessRecipe(args));
        registerConsumer(list, "custom.registershapedrecipe", (args, qd) -> 
                registerShapedRecipe(args));
        registerConsumer(list, "custom.registerfurnacerecipe", (args, qd) -> nothing()
                /*KajetansMod.customs.registerFurnaceRecipe((ItemStack) args[0], (ItemStack) args[1])*/);
        registerConsumer(list, "custom.clearrecipes", (args, qd) -> nothing()
                /*KajetansMod.customs.clearRecipes()*/);
        registerConsumer(list, "custom.clearenchantments", (args, qd) -> nothing()
                /*KajetansMod.customs.clearEnchantments()*/);
        
        
        // -------------------------------------------------------------    
        // World-Bibliothek
        // -------------------------------------------------------------
        
        registerAlias(list, "world.getplayers", "players.toworldlist");
        registerConsumer(list, "world.setskills", (args, qd) ->     
                KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(args[0].toString())).skills = (boolean) args[1]);
        registerConsumer(list, "world.setblockprotections", (args, qd) ->     
                KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(args[0].toString())).blockProtection = (boolean) args[1]);
        registerConsumer(list, "world.setdefaultenchanting", (args, qd) ->     
                KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(args[0].toString())).defaultEnchanting = (boolean) args[1]);
        registerConsumer(list, "world.setpvpprotection", (args, qd) ->     
                KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(args[0].toString())).pvpProtection = (boolean) args[1]);
        registerConsumer(list, "world.setstatuseffects", (args, qd) ->     
                KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(args[0].toString())).statusEffects = (boolean) args[1]);
        registerConsumer(list, "world.setmanabar", (args, qd) ->     
                KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(args[0].toString())).manabar = (boolean) args[1]);
        registerConsumer(list, "world.setscrolls", (args, qd) ->     
                KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(args[0].toString())).scrolls = (boolean) args[1]);
        registerConsumer(list, "world.setdefaultproducing", (args, qd) ->     
                KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(args[0].toString())).defaultProducing = (boolean) args[1]);
      
        // -------------------------------------------------------------    
        // Item-Bibliothek   
        // -------------------------------------------------------------   
        registerConsumer(list, "item.drop", (args, qd) ->       
                dropItem(args));                              
        registerFunction(list, "item.gettype", (args, qd) ->    
                ((ItemStack) args[0]).getItem().getRegistryName());
        registerFunction(list, "item.getdata", (args, qd) ->    
                ((ItemStack) args[0]).getMetadata());           
        registerConsumer(list, "item.setdata", (args, qd) ->    
                ((ItemStack) args[0]).setItemDamage((short) QuestUtils.getInt(args[1])));
        registerFunction(list, "item.getamount", (args, qd) ->    
                ((ItemStack) args[0]).getCount()); 
        registerConsumer(list, "item.setamount", (args, qd) ->   
                ((ItemStack) args[0]).setCount(QuestUtils.getInt(args[1])));   
        registerFunction(list, "item.getname", (args, qd) ->    
                ((ItemStack) args[0]).getDisplayName());
        registerConsumer(list, "item.setname", (args, qd) ->   
                ((ItemStack) args[0]).setStackDisplayName(QuestUtils.connect(args, 1)));
        registerConsumer(list, "item.getlore", (args, qd) ->    
                qd.setVar(args[0], Utils.getLore((ItemStack) args[1])));
        registerConsumer(list, "item.setlore", (args, qd) ->   
                Utils.setLore((ItemStack) args[0], QuestUtils.connect(args, 2), QuestUtils.getInt(args[1])));
        registerFunction(list, "item.getenchantlevel", (args, qd) ->   
                EnchantmentHelper.getEnchantmentLevel(ReflectionUtils.getEnchantment(args[1].toString()), (ItemStack) args[0]));
        registerConsumer(list, "item.setcooldown", (args, qd) ->   
                ((EntityPlayer) args[0]).getCooldownTracker().setCooldown(((ItemStack) args[1]).getItem(), QuestUtils.getInt(args[2])));
        registerFunction(list, "item.gettooltype", (args, qd) ->   
                Utils.getToolType((ItemStack) args[0]));

        // -------------------------------------------------------------    
        // Location-Bibliothek
        // -------------------------------------------------------------  
        registerFunction(list, "loc.distance", (args, qd) -> 
                ((Location) args[0]).getPos().distanceTo(((Location) args[1]).getPos()));   
        registerFunction(list, "loc.mod", (args, qd) -> 
                ((Location) args[0]).add(QuestUtils.getDouble(args[1]), QuestUtils.getDouble(args[2]), QuestUtils.getDouble(args[3])));
        registerFunction(list, "loc.getcoord", (args, qd) -> 
                getCoordOfLocation(args));
        registerFunction(list, "loc.gettime", (args, qd) -> 
                ((Long) ((Location) args[0]).getWorld().getWorldTime()).intValue());
        registerFunction(list, "loc.hasstorm", (args, qd) -> 
                ((Location) args[0]).getWorld().isRaining());
        registerFunction(list, "loc.isbetween", (args, qd) -> 
                isBetween(args));

        // -------------------------------------------------------------    
        // Block-Bibliothek
        // -------------------------------------------------------------    
        registerFunction(list, "block.gettype", (args, qd) -> 
                ((Location) args[0]).getWorld().getBlockState(((Location) args[0]).getBlockPos()).getBlock().getRegistryName());
        registerFunction(list, "block.getdata", (args, qd) -> 
                getBlockData((Location) args[0]));
        registerConsumer(list, "block.clone", (args, qd) -> 
                cloneBlock(args));
        registerConsumer(list, "block.set", (args, qd) -> 
                setBlock(args, qd));
        registerConsumer(list, "block.set2", (args, qd) -> 
                setBlockWithData(args, qd));
        registerConsumer(list, "block.setsign", (args, qd) -> 
                setSign(args));
        registerFunction(list, "block.getsign", (args, qd) -> 
                getSign(args));
        registerFunction(list, "block.issolid", (args, qd) -> 
                getBlockState((Location) args[0]).isFullCube());
        registerFunction(list, "block.tostack", (args, qd) -> 
                getStackFromBlock((Location) args[0]));
        registerFunction(list, "block.getitemamount", (args, qd) -> 
                getItemAmountChest(args));
        registerFunction(list, "block.additem", (args, qd) -> 
                addItemAmountChest(args));
        registerFunction(list, "block.subitem", (args, qd) -> 
                removeItemAmountChest(args));  

        // -------------------------------------------------------------    
        // Event-Bibliothek 
        // -------------------------------------------------------------  
        registerConsumer(list, "event.addloc", (args, qd) -> 
                qd.addLocation(QuestUtils.roundLocation((Location) args[0])));
        registerConsumer(list, "event.removeloc", (args, qd) -> 
                qd.removeLocation(QuestUtils.roundLocation((Location) args[0])));
        registerConsumer(list, "event.clearlocs", (args, qd) -> 
                qd.clearLocations());
        registerConsumer(list, "event.load", (args, qd) -> 
                qd.loadEvent(args[0].toString())); 
        registerConsumer(list, "event.unload", (args, qd) -> 
                qd.unloadEvent(args[0].toString())); 

        // -------------------------------------------------------------    
        // Skill-Bibliothek 
        // ------------------------------------------------------------- 
        registerConsumer(list, "skill.register", (args, qd) -> 
                KajetansMod.skills.registerSkill(QuestUtils.getInt(args[0]), (ItemStack) args[1], me.km.effects.Effect.valueOf(args[2].toString()), args[3].toString(), args[4].toString()));
        registerConsumer(list, "skill.clear", (args, qd) -> 
                KajetansMod.skills.clearSkills());
        
        // -------------------------------------------------------------    
        // Job-Bibliothek 
        // -------------------------------------------------------------  
        registerFunction(list, "job.getlevel", (args, qd) -> 
                KajetansMod.jobs.getLevel((EntityPlayer) args[0], QuestUtils.getByte(args[1])));
        registerConsumer(list, "job.addlevel", (args, qd) -> 
                KajetansMod.jobs.addLevel((EntityPlayer) args[0], QuestUtils.getByte(args[1]), QuestUtils.getByte(args[2])));
        registerConsumer(list, "job.setlevel", (args, qd) -> 
                KajetansMod.jobs.setLevel((EntityPlayer) args[0], QuestUtils.getByte(args[1]), QuestUtils.getByte(args[2])));
        registerFunction(list, "job.getxp", (args, qd) -> 
                KajetansMod.jobs.getXP((EntityPlayer) args[0], QuestUtils.getByte(args[1])));
        registerConsumer(list, "job.addxp", (args, qd) -> 
                KajetansMod.jobs.addXP((EntityPlayer) args[0], QuestUtils.getByte(args[1]), QuestUtils.getByte(args[2])));
        registerConsumer(list, "job.setxp", (args, qd) -> 
                KajetansMod.jobs.setXP((EntityPlayer) args[0], QuestUtils.getByte(args[1]), QuestUtils.getByte(args[2])));
        registerConsumer(list, "job.registerjob", (args, qd) -> 
                KajetansMod.jobs.registerJob(QuestUtils.getByte(args[0]), QuestUtils.connect(args, 1)));
        registerConsumer(list, "job.registerrecipe", (args, qd) -> 
                KajetansMod.jobs.registerRecipe(QuestUtils.getByte(args[0]), Item.getByNameOrId(args[1].toString()), QuestUtils.getByte(args[2])));
        registerConsumer(list, "job.registermaterial", (args, qd) -> 
                KajetansMod.jobs.registerPreferedBlock(QuestUtils.getByte(args[0]), Block.getBlockFromName(args[1].toString())));
        registerConsumer(list, "job.registerskill", (args, qd) -> 
                KajetansMod.jobs.registerSkill(QuestUtils.getByte(args[0]), KajetansMod.skills.getSkill(QuestUtils.getInt(args[1])), QuestUtils.getByte(args[2]), QuestUtils.getByte(args[3])));
        registerFunction(list, "job.getamount", (args, qd) -> 
                KajetansMod.jobs.getNumberOfJobs());
        registerFunction(list, "job.getname", (args, qd) -> 
                KajetansMod.jobs.getJobName(QuestUtils.getByte(args[0])));
        registerFunction(list, "job.geteffectlevel", (args, qd) -> 
                EffectUtils.getEffectLevel((EntityPlayer) args[0], me.km.effects.Effect.valueOf(args[1].toString())));
        registerFunction(list, "job.hasjob", (args, qd) -> 
                KajetansMod.jobs.hasJob((EntityPlayer) args[0], QuestUtils.getByte(args[1])));
        registerFunction(list, "job.hasrecipe", (args, qd) -> 
                KajetansMod.jobs.hasRecipe((EntityPlayer) args[0], Item.getByNameOrId(args[1].toString())));
        registerConsumer(list, "job.getjobs", (args, qd) -> 
                qd.setVar(args[0], KajetansMod.jobs.getJobs((EntityPlayer) args[1])));
        registerFunction(list, "job.isregmaterial", (args, qd) -> 
                KajetansMod.jobs.isPreferedMaterial((EntityPlayer) args[0],Block.getBlockFromName(args[1].toString())));
        registerConsumer(list, "job.setjob", (args, qd) -> 
                KajetansMod.jobs.setJob((EntityPlayer) args[0], QuestUtils.getByte(args[1]), (boolean) args[2])); 
        registerConsumer(list, "job.reset", (args, qd) -> 
                KajetansMod.jobs.resetAll());  

        // -------------------------------------------------------------    
        // Bit-Bibliothek 
        // -------------------------------------------------------------   
        registerFunction(list, "bit.rightshift", (args, qd) -> 
                QuestUtils.getInt(args[0]) >> QuestUtils.getInt(args[1]));
        registerFunction(list, "bit.leftshift", (args, qd) -> 
                QuestUtils.getInt(args[0]) << QuestUtils.getInt(args[1]));
        registerFunction(list, "bit.and", (args, qd) -> 
                QuestUtils.getInt(args[0]) & QuestUtils.getInt(args[1]));
        registerFunction(list, "bit.or", (args, qd) -> 
                QuestUtils.getInt(args[0]) | QuestUtils.getInt(args[1]));
        registerFunction(list, "bit.xor", (args, qd) -> 
                QuestUtils.getInt(args[0]) ^ QuestUtils.getInt(args[1]));
        registerFunction(list, "bit.invert", (args, qd) -> 
                ~QuestUtils.getInt(args[0]));
        registerFunction(list, "bit.set", (args, qd) -> 
                QuestUtils.getInt(args[0]) | (1 << QuestUtils.getInt(args[1])));
        registerFunction(list, "bit.get", (args, qd) -> 
                (QuestUtils.getInt(args[0]) & (1 << QuestUtils.getInt(args[1]))) != 0);

        // -------------------------------------------------------------    
        // Mathe-Bibliothek 
        // -------------------------------------------------------------    
        registerFunction(list, "math.mod", (args, qd) -> 
                numberHandler(args[0], args[1], (a, b) -> a % b, (a, b) -> a % b, (a, b) -> a % b));
        registerFunction(list, "math.abs", (args, qd) -> 
                numberHandler(args[0], (a) -> Math.abs(a), (a) -> Math.abs(a), (a) -> Math.abs(a)));
        registerFunction(list, "math.pow", (args, qd) -> 
                Math.pow(QuestUtils.getDouble(args[0]), QuestUtils.getDouble(args[1])));
        registerFunction(list, "math.root", (args, qd) -> 
                Math.pow(QuestUtils.getDouble(args[0]), 1d / QuestUtils.getDouble(args[1])));
        registerFunction(list, "math.sin", (args, qd) -> 
                Math.sin(QuestUtils.getDouble(args[0])));
        registerFunction(list, "math.cos", (args, qd) -> 
                Math.cos(QuestUtils.getDouble(args[0])));
        registerFunction(list, "math.e", (args, qd) -> 
                Math.E);
        registerFunction(list, "math.pi", (args, qd) -> 
                Math.PI);
        registerFunction(list, "math.ln", (args, qd) -> 
                Math.log(QuestUtils.getDouble(args[0])));
        registerFunction(list, "math.log", (args, qd) -> 
                Math.log10(QuestUtils.getDouble(args[0])));
        registerFunction(list, "math.random", (args, qd) -> 
                Utils.randomInt(QuestUtils.getInt(args[0]), QuestUtils.getInt(args[1])));
        registerFunction(list, "math.round", (args, qd) -> 
                round(args[0]));
        registerFunction(list, "math.rounddown", (args, qd) -> 
                roundDown(args[0]));
        registerFunction(list, "math.roundup", (args, qd) -> 
                roundUp(args[0]));
        registerFunction(list, "math.roundcomma", (args, qd) -> 
                new BigDecimal(QuestUtils.getDouble(args[0])).setScale(QuestUtils.getInt(args[1]), RoundingMode.HALF_UP).doubleValue());

        // -------------------------------------------------------------    
        // Entity - Befehle
        // -------------------------------------------------------------    
        registerFunction(list, "entity.getlocation", (args, qd) -> 
                new Location(((Entity) args[0])));   
        registerConsumer(list, "entity.damage", (args, qd) -> 
                damageEntity(args));  
        registerFunction(list, "entity.gethealth", (args, qd) -> 
                ((EntityLivingBase) args[0]).getHealth());     
        registerConsumer(list, "entity.sethealth", (args, qd) -> 
                ((EntityLivingBase) args[0]).setHealth(QuestUtils.getFloat(args[1])));  
        registerConsumer(list, "entity.setname", (args, qd) -> 
                nameEntity(args)); 
        registerConsumer(list, "entity.throw", (args, qd) -> 
                throwEntity(args));
        registerConsumer(list, "entity.teleport", (args, qd) -> 
                Utils.teleportEntity((Entity) args[0], (Location) args[1]));  
        registerConsumer(list, "entity.setequip", (args, qd) -> 
                setEntityEquip(args)); 
        registerFunction(list, "entity.getequip", (args, qd) -> 
                getEntityEquip(args));
        registerConsumer(list, "entity.removeall", (args, qd) -> 
                removeEntities(args));
        registerConsumer(list, "entity.remove", (args, qd) -> 
                ((Entity) args[0]).setDead());
        registerConsumer(list, "entity.setinvulnerable", (args, qd) -> 
                ((Entity) args[0]).setEntityInvulnerable((boolean) args[1]));
        registerConsumer(list, "entity.setsilent", (args, qd) -> 
                ((Entity) args[0]).setSilent((boolean) args[1]));
        registerConsumer(list, "entity.hide", (args, qd) -> 
                ((Entity) args[0]).setInvisible(true));
        registerConsumer(list, "entity.show", (args, qd) -> 
                ((Entity) args[0]).setInvisible(false));
        registerConsumer(list, "entity.ride", (args, qd) -> 
                ((Entity) args[0]).startRiding(((Entity) args[1])));
        registerConsumer(list, "entity.setvars", (args, qd) -> 
                QuestVars.setEntityVars(qd, Utils.getNearestEntity(((Location) args[0]).getWorld(), ((Location) args[0]).getPos(), 3, (Class<? extends Entity>) getClass("net.minecraft.entity." + args[1]))));
        registerConsumer(list, "entity.addeffect", (args, qd) -> 
                EffectUtils.addPotionTo((EntityLivingBase) args[0], Utils.getPotion(args[1].toString()), QuestUtils.getInt(args[2]), QuestUtils.getInt(args[3])));
        registerFunction(list, "entity.haseffect", (args, qd) -> 
                ((EntityLivingBase) args[0]).isPotionActive(Utils.getPotion(args[1].toString())));
        registerConsumer(list, "entity.goto", (args, qd) -> nothing()
                /*TODO NmsUtilities.walkTo((Entity) args[0], (Location) args[1], QuestUtils.getDouble(args[2]), QuestUtils.getDouble(args[3]))*/);
        registerConsumer(list, "entity.explode", (args, qd) -> 
                ((EntityCreeper) args[0]).ignite());
        registerConsumer(list, "entity.spawnitemframe", (args, qd) -> 
                spawnItemFrame(args));
        registerFunction(list, "entity.getitemframe", (args, qd) -> 
                Utils.getNearestEntity(((Location) args[0]).getWorld(), ((Location) args[0]).getPos().addVector(0.5, 0, 0.5), 1, EntityItemFrame.class).getDisplayedItem());
        registerFunction(list, "entity.getpotiontype", (args, qd) -> 
                getPotionType(args));
        registerConsumer(list, "entity.setgravity", (args, qd) -> 
                ((Entity) args[0]).setNoGravity(!(boolean) args[1]));

        // -------------------------------------------------------------
        // Status-Bibliothek
        // -------------------------------------------------------------  
        registerFunction(list, "status.getmana", (args, qd) -> 
                EnvironmentAPI.getMana(((EntityPlayer) args[0])));
        registerFunction(list, "status.getcold", (args, qd) -> 
                EnvironmentAPI.getCold(((EntityPlayer) args[0])));
        registerFunction(list, "status.getenergy", (args, qd) -> 
                EnvironmentAPI.getEnergy(((EntityPlayer) args[0])));
        registerFunction(list, "status.getthirst", (args, qd) -> 
                EnvironmentAPI.getThirst(((EntityPlayer) args[0])));
        registerConsumer(list, "status.changemange", (args, qd) -> 
                EnvironmentAPI.changeMana(((EntityPlayer) args[0]), QuestUtils.getInt(args[1])));
        registerConsumer(list, "status.changecold", (args, qd) -> 
                EnvironmentAPI.changeCold(((EntityPlayer) args[0]), QuestUtils.getInt(args[1])));
        registerConsumer(list, "status.changeenergie", (args, qd) -> 
                EnvironmentAPI.changeEnergy(((EntityPlayer) args[0]), QuestUtils.getInt(args[1])));
        registerConsumer(list, "status.changethirst", (args, qd) -> 
                EnvironmentAPI.changeThirst(((EntityPlayer) args[0]), QuestUtils.getInt(args[1])));
        registerConsumer(list, "status.resetmana", (args, qd) -> 
                EnvironmentAPI.resetMana(((EntityPlayer) args[0])));
        registerConsumer(list, "status.resetcold", (args, qd) -> 
                EnvironmentAPI.resetCold(((EntityPlayer) args[0])));
        registerConsumer(list, "status.resetenergy", (args, qd) -> 
                EnvironmentAPI.resetEnergy(((EntityPlayer) args[0])));
        registerConsumer(list, "status.resetthirst", (args, qd) -> 
                EnvironmentAPI.resetThirst(((EntityPlayer) args[0])));
        registerConsumer(list, "status.gettemperature", (args, qd) -> 
                EnvironmentAPI.getTemperature(((Location) args[0]).getWorld(), ((Location) args[0]).getBlockPos()));    

        // -------------------------------------------------------------  
        // Listen-Bibliothek   
        // -------------------------------------------------------------    
        registerConsumer(list, "list.new", (args, qd) ->                                                
                qd.setVar(args[0], new ArrayList<>()));
        registerFunction(list, "list.exists", (args, qd) ->                                                
                args[0] instanceof List); 
        registerConsumer(list, "list.add", (args, qd) ->                            
                ((List) args[0]).add(args[1]));
        registerConsumer(list, "list.remove", (args, qd) ->                            
                ((List) args[0]).remove(args[1]));
        registerConsumer(list, "list.removeindex", (args, qd) ->                            
                ((List) args[0]).remove(QuestUtils.getInt(args[1])));                
        registerFunction(list, "list.contains", (args, qd) ->                            
                ((List) args[0]).contains(args[1]));
        registerFunction(list, "list.getsize", (args, qd) ->                            
                ((List) args[0]).size());
        registerFunction(list, "list.getindex", (args, qd) ->                            
                ((List) args[0]).get(QuestUtils.getInt(args[1])));
        registerConsumer(list, "list.setindex", (args, qd) ->                            
                ((List) args[0]).set(QuestUtils.getInt(args[1]), args[2]));
        registerConsumer(list, "list.clear", (args, qd) ->                            
                ((List) args[0]).clear());
        registerFunction(list, "list.getindexof", (args, qd) ->                            
                ((List) args[0]).indexOf(args[1]));  
        registerConsumer(list, "list.sort", (args, qd) ->  
                sortList((List<Object>) args[0], qd));
        registerConsumer(list, "list.reverse", (args, qd) ->                            
                Collections.reverse((List<Object>) args[0])); 
        registerConsumer(list, "list.shuffle", (args, qd) ->                            
                Collections.shuffle((List<Object>) args[0]));

        // -------------------------------------------------------------  
        // Map-Bibliothek   
        // ------------------------------------------------------------- 
        registerConsumer(list, "map.new", (args, qd) ->                                                
                qd.setVar(args[0], new HashMap<>())); 
        registerFunction(list, "map.exists", (args, qd) ->                                                
                args[0] instanceof HashMap);  
        registerConsumer(list, "map.add", (args, qd) ->                            
                ((HashMap) args[0]).put(args[1], args[2]));
        registerConsumer(list, "map.remove", (args, qd) ->                            
                ((HashMap) args[0]).remove(args[1]));
        registerFunction(list, "map.contains", (args, qd) ->                            
                ((HashMap) args[0]).containsKey(args[1]));
        registerFunction(list, "map.getsize", (args, qd) ->                            
                ((HashMap) args[0]).size());
        registerFunction(list, "map.get", (args, qd) ->                            
                ((HashMap) args[0]).get(args[1]));
        registerConsumer(list, "map.clear", (args, qd) ->                            
                ((HashMap) args[0]).clear());
        
        // -------------------------------------------------------------  
        // Set-Bibliothek   
        // ------------------------------------------------------------- 
        registerConsumer(list, "set.new", (args, qd) ->                                                
                qd.setVar(args[0], new HashSet<>())); 
        registerFunction(list, "set.exists", (args, qd) ->                                                
                args[0] instanceof HashSet);  
        registerConsumer(list, "set.add", (args, qd) ->                            
                ((HashSet) args[0]).add(args[1]));
        registerConsumer(list, "set.remove", (args, qd) ->                            
                ((HashSet) args[0]).remove(args[1]));
        registerFunction(list, "set.contains", (args, qd) ->                            
                ((HashSet) args[0]).contains(args[1]));
        registerFunction(list, "set.getsize", (args, qd) ->                            
                ((HashSet) args[0]).size());

        // -------------------------------------------------------------  
        // GMap-Bibliothek   
        // -------------------------------------------------------------  
        registerConsumer(list, "gmap.removeall", (args, qd) ->    
                KajetansMod.quest.getDataBank(QuestBank.class).removeMap(args[0].toString()));
        registerConsumer(list, "gmap.add", (args, qd) ->    
                KajetansMod.quest.getDataBank(QuestBank.class).addMapElement(args[0].toString(), args[1].toString(), args[2].toString()));
        registerConsumer(list, "gmap.remove", (args, qd) ->    
                KajetansMod.quest.getDataBank(QuestBank.class).removeMapElement(args[0].toString(), args[1].toString()));
        registerConsumer(list, "gmap.totable", (args, qd) ->    
                qd.setVar(args[0], KajetansMod.quest.getDataBank(QuestBank.class).getGlobalMapAsTable(args[1].toString())));
        registerFunction(list, "gmap.get", (args, qd) ->    
                KajetansMod.quest.getDataBank(QuestBank.class).getMapValue(args[0].toString(), args[1].toString()));
        
        // -------------------------------------------------------------  
        // GDMap-Bibliothek   
        // -------------------------------------------------------------  
        registerConsumer(list, "gdmap.removeall", (args, qd) ->    
                KajetansMod.quest.getDataBank(QuestBank.class).removeDualMap(args[0].toString()));
        registerConsumer(list, "gdmap.add", (args, qd) ->    
                KajetansMod.quest.getDataBank(QuestBank.class).addDualMapElement(args[0].toString(), args[1].toString(), args[2].toString(), args[3].toString()));
        registerConsumer(list, "gdmap.remove", (args, qd) ->    
                KajetansMod.quest.getDataBank(QuestBank.class).removeDualMapElement(args[0].toString(), args[1].toString(), args[2].toString()));
        registerConsumer(list, "gdmap.totable", (args, qd) ->    
                qd.setVar(args[0], KajetansMod.quest.getDataBank(QuestBank.class).getGlobalDualMapAsTable(args[1].toString(), args[2].toString())));
        registerFunction(list, "gdmap.get", (args, qd) ->    
                KajetansMod.quest.getDataBank(QuestBank.class).getDualMapValue(args[0].toString(), args[1].toString(), args[2].toString()));

        // -------------------------------------------------------------  
        // Table-Bibliothek   
        // -------------------------------------------------------------  
        registerConsumer(list, "table.printstart", (args, qd) ->   
                sendMessageToGroup(args[0], qd, TableAPI.getTableStart(QuestUtils.getInt(args[1]), QuestUtils.getInt(args[2]), args[3].toString())));
        registerConsumer(list, "table.printmiddle", (args, qd) ->   
                sendMessageToGroup(args[0], qd, TableAPI.getTableMiddle(QuestUtils.getInt(args[1]), QuestUtils.getInt(args[2]), args[3].toString())));  
        registerConsumer(list, "table.print", (args, qd) ->     
                sendMessageToGroup(args[0], qd, TableAPI.getTable(QuestUtils.getInt(args[1]), args[2].toString(), Arrays.stream(args, 3, args.length).map(o -> o.toString()).collect(Collectors.toList()))));  
        registerConsumer(list, "table.printend", (args, qd) ->    
                sendMessageToGroup(args[0], qd, TableAPI.getTableEnd(QuestUtils.getInt(args[1]), QuestUtils.getInt(args[2]), args[3].toString())));  
        registerConsumer(list, "table.new", (args, qd) -> 
                qd.setVar(args[0], new Table(QuestUtils.getInt(args[1]))));
        registerConsumer(list, "table.frommap", (args, qd) -> 
                qd.setVar(args[0], new Table((Map<Object, Object>) args[1])));
        registerConsumer(list, "table.sort", (args, qd) -> 
                ((Table) args[0]).sort());
        registerConsumer(list, "table.reverse", (args, qd) -> 
                ((Table) args[0]).reverse());
        registerConsumer(list, "table.shuffle", (args, qd) -> 
                ((Table) args[0]).shuffle());
        registerConsumer(list, "table.clear", (args, qd) -> 
                ((Table) args[0]).clear());
        registerConsumer(list, "table.addrow", (args, qd) -> 
                ((Table) args[0]).addRow(Arrays.copyOfRange(args, 1, args.length)));
        registerConsumer(list, "table.removerow", (args, qd) -> 
                ((Table) args[0]).removeRow(QuestUtils.getInt(args[1])));
        registerFunction(list, "table.get", (args, qd) -> 
                ((Table) args[0]).getElement(QuestUtils.getInt(args[1]), QuestUtils.getInt(args[2])));
        registerFunction(list, "table.getindexof", (args, qd) -> 
                ((Table) args[0]).getIndexOf(args[1]));
        registerConsumer(list, "table.setsortcolumn", (args, qd) -> 
                ((Table) args[0]).setSortColumn(QuestUtils.getInt(args[1])));
        registerFunction(list, "table.getsize", (args, qd) -> 
                ((Table) args[0]).getSize());

        // -------------------------------------------------------------  
        // Plot-Bibliothek   
        // -------------------------------------------------------------  
        registerFunction(list, "plot.hastag", (args, qd) ->    
                KajetansMod.plots.getDataBank(ProtectionBank.class).hasTag(((Location) args[0]).getWorld(), ((Location) args[0]).getBlockPos(), args[1].toString())); 
        registerConsumer(list, "plot.add", (args, qd) ->    
                addPlot(args));
        registerFunction(list, "plot.getid", (args, qd) ->    
                KajetansMod.plots.getDataBank(ProtectionBank.class).getFirstRegionId(((Location) args[0]).getWorld(), ((Location) args[0]).getBlockPos()));
        registerFunction(list, "plot.canbuild", (args, qd) ->    
                KajetansMod.plots.getDataBank(ProtectionBank.class).canBuild(((Location) args[0]).getWorld(), ((Location) args[0]).getBlockPos(), (EntityPlayer) args[1]));
        registerFunction(list, "plot.getname", (args, qd) ->    
                KajetansMod.plots.getDataBank(ProtectionBank.class).getFirstRegionName(((Location) args[0]).getWorld(), ((Location) args[0]).getBlockPos()));

        // -------------------------------------------------------------  
        // Quest-Bibliothek   
        // -------------------------------------------------------------    
        registerConsumer(list, "quest.setinfo", (args, qd) -> 
                qd.setInfo(QuestUtils.connect(args, 0)));
        registerConsumer(list, "quest.end", (args, qd) -> 
                endQuest(args, qd));
        registerConsumer(list, "quest.playerstolist", (args, qd) ->  
                questersToList(args, qd)); 
        registerFunction(list, "quest.getplayeramount", (args, qd) ->      
                getNumberOfQuesters(qd));
        registerConsumer(list, "quest.give", (args, qd) ->  
                giveQuest(args, qd));
        registerConsumer(list, "quest.force", (args, qd) ->  
                forceQuest(qd)); 
        registerFunction(list, "quest.isactive", (args, qd) ->  
                KajetansMod.quest.getQuests().stream().anyMatch(q -> q.getName().equals(args[0])));

        // -------------------------------------------------------------  
        // Scoreboard-Bibliothek   
        // -------------------------------------------------------------  
        registerConsumer(list, "sb.add", (args, qd) ->  
                addToScoreBoard(args, qd));
        registerConsumer(list, "sb.remove", (args, qd) ->  
                removeFromScoreBoard(args, qd));
        registerConsumer(list, "sb.reset", (args, qd) ->  
                doForGroup(args[0], qd, p -> KajetansMod.scoreboard.resetScoreboard((EntityPlayer) p)));

        // -------------------------------------------------------------  
        // Effect-Bibliothek   
        // ------------------------------------------------------------- 
        registerConsumer(list, "effect.playsound", (args, qd) -> 
                playSound(args));
        registerConsumer(list, "effect.play", (args, qd) -> 
                playParticle(args));

        // -------------------------------------------------------------  
        // Inventory-Bibliothek   
        // -------------------------------------------------------------
        registerConsumer(list, "inv.new", (args, qd) -> 
                qd.setVar(args[0], new SnuviInventory(args[2].toString(), QuestUtils.getInt(args[1]), qd.getNewId())));   
        registerConsumer(list, "inv.loadblock", (args, qd) -> 
                qd.setVar(args[0], newInventory((Location) args[1], qd, args[2].toString())));
        registerConsumer(list, "inv.setitem", (args, qd) -> 
                ((IInventory) args[0]).setInventorySlotContents(QuestUtils.getInt(args[1]), ((ItemStack) args[2]).copy()));
        registerFunction(list, "inv.getitem", (args, qd) -> 
                ((IInventory) args[0]).getStackInSlot(QuestUtils.getInt(args[1])));
        registerConsumer(list, "inv.open", (args, qd) -> 
                new QuestInventoryHolder((SnuviInventory) args[0], (EntityPlayer) args[1], qd).openForPlayer((EntityPlayerMP) args[1]));
        registerConsumer(list, "inv.close", (args, qd) -> 
                ((EntityPlayer) args[0]).closeScreen()); 

        // -------------------------------------------------------------  
        // Time-Bibliothek   
        // -------------------------------------------------------------
        registerFunction(list, "time.get", (args, qd) ->                            
                System.currentTimeMillis());
        registerFunction(list, "time.nextday", (args, qd) ->         
                getNextDay(args));   
        registerFunction(list, "time.getyear", (args, qd) ->         
                getYear(args));   
        registerFunction(list, "time.getmonth", (args, qd) ->         
                getMonth(args));   
        registerFunction(list, "time.getday", (args, qd) ->         
                getDay(args));   
        registerFunction(list, "time.gethour", (args, qd) ->         
                getHour(args));   
        registerFunction(list, "time.getminute", (args, qd) ->         
                getMinute(args));   
        registerFunction(list, "time.getsecond", (args, qd) ->         
                getSecond(args));                   

        // -------------------------------------------------------------  
        // Read-Bibliothek   
        // -------------------------------------------------------------
        registerFunction(list, "read.player", (args, qd) -> 
                Utils.getPlayerByName(args[0].toString()));
        registerFunction(list, "read.location", (args, qd) -> 
                QuestUtils.getLocation(args[0].toString()));
        registerFunction(list, "read.item", (args, qd) -> 
                QuestUtils.getItemStack(args, 0));
        registerFunction(list, "read.spawnmob", (args, qd) -> 
                NmsUtilities.getEntityFromNbtString(QuestUtils.connect(args," ", 1).replace("'", "\""), (Location) args[0]));

        // -------------------------------------------------------------  
        // Text-Bibliothek   
        // -------------------------------------------------------------
        registerFunction(list, "text.location", (args, qd) -> 
                QuestUtils.getLocationString((Location) args[0]));
        registerFunction(list, "text.item", (args, qd) -> 
                QuestUtils.getItemStackString((ItemStack) args[0]));

        // -------------------------------------------------------------    
        // Ohne Bibliothek
        // -------------------------------------------------------------    
        registerFunction(list, "add", (args, qd) -> 
                convertDouble(Arrays.stream(args).mapToDouble(s -> QuestUtils.getDouble(s)).sum()));
        registerFunction(list, "sub", (args, qd) -> 
                numberHandler(args[0], args[1], (a, b) -> a - b, (a, b) -> a - b, (a, b) -> a - b));
        registerFunction(list, "inc", (args, qd) -> 
                increaseVar(args[0], qd, 1)); 
        registerFunction(list, "dec", (args, qd) -> 
                increaseVar(args[0], qd, -1));
        registerFunction(list, "mul", (args, qd) -> 
                numberHandler(args[0], args[1], (a, b) -> a * b, (a, b) -> a * b, (a, b) -> a * b));
        registerFunction(list, "div", (args, qd) -> 
                QuestUtils.getDouble(args[0]) / QuestUtils.getDouble(args[1]));
        registerFunction(list, "getvar", (args, qd) -> 
                qd.getVar(args[0].toString()));
        registerConsumer(list, "setvar", (args, qd) -> 
                qd.setVar(args[0].toString(), args[1]));
        registerConsumer(list, "removevar", (args, qd) -> 
                qd.removeVar(args[0].toString()));
        registerFunction(list, "getglobalvar", (args, qd) ->                    
                getGlobalVar(args));
        registerAlias(list, "ggv", "getglobalvar");
        registerConsumer(list, "setglobalvar", (args, qd) -> 
                setGlobalVar(args));                          
        registerAlias(list, "sgv", "setglobalvar");
        registerConsumer(list, "msg", (args, qd) -> 
                sendMessageToGroup(args[0], qd, QuestUtils.connect(args, 1)));
        registerConsumer(list, "reset", (args, qd) -> 
                qd.resetOverflowProtection());
        registerConsumer(list, "wait", (args, qd) -> 
                { qd.resetOverflowProtection(); throw new HoldCodeException(); });
        registerConsumer(list, "term", (args, qd) -> 
                { KajetansMod.quest.term(qd); throw new HoldCodeException(); });
        registerConsumer(list, "goto", (args, qd) -> 
                qd.gotoLabel(args[0].toString()));
        registerConsumer(list, "sgoto", (args, qd) -> 
                scheduleGoto(args, qd));
        registerConsumer(list, "gosub", (args, qd) -> 
                qd.gotoLabelWithReturn(args[0].toString()));
        registerConsumer(list, "return", (args, qd) -> 
                qd.doReturn());
        registerConsumer(list, "try", (args, qd) -> 
                tryFunction(args, qd));                   
        registerConsumer(list, "catch", (args, qd) -> 
                catchFunction(qd));
        registerConsumer(list, "if", (args, qd) -> 
                ifFunction(args, qd));   
        registerConsumer(list, "else", (args, qd) -> 
                elseFunction(args, qd));   
        registerConsumer(list, "while", (args, qd) -> 
                whileFunction(args, qd)); 
        registerFunction(list, "equal", (args, qd) -> 
                isEqual(args));
        registerAlias(list, "equals", "equal");
        registerFunction(list, "less", (args, qd) -> 
                QuestUtils.getDouble(args[0]) < QuestUtils.getDouble(args[1]));
        registerFunction(list, "greater", (args, qd) -> 
                QuestUtils.getDouble(args[0]) > QuestUtils.getDouble(args[1]));
        registerFunction(list, "notequal", (args, qd) -> 
                !isEqual(args));
        registerFunction(list, "lessequal", (args, qd) -> 
                QuestUtils.getDouble(args[0]) <= QuestUtils.getDouble(args[1]));
        registerFunction(list, "greaterequal", (args, qd) -> 
                QuestUtils.getDouble(args[0]) >= QuestUtils.getDouble(args[1]));
        registerFunction(list, "invert", (args, qd) -> 
                !((boolean) args[0]));
        registerFunction(list, "and", (args, qd) -> 
                Arrays.stream(args).allMatch(s -> s.equals(true)));
        registerFunction(list, "or", (args, qd) -> 
                Arrays.stream(args).anyMatch(s -> s.equals(true)));
        registerFunction(list, "removeformat", (args, qd) -> 
                QuestUtils.connect(args, 0).replaceAll("§.", ""));
        registerFunction(list, "concatlist", (args, qd) ->      
                ((List<Object>) args[0]).stream().limit(QuestUtils.getInt(args[3]) + 1).skip(QuestUtils.getInt(args[2])).map(o -> o.toString()).collect(Collectors.joining(args[1].toString())));
        registerConsumer(list, "split", (args, qd) ->      
                split(args, qd));             
        registerFunction(list, "concat", (args, qd) ->                            
                QuestUtils.connect(args, 0));
        registerFunction(list, "tolowercase", (args, qd) ->                            
                QuestUtils.connect(args, 0).toLowerCase());
        registerFunction(list, "touppercase", (args, qd) ->                            
                QuestUtils.connect(args, 0).toUpperCase());
        registerFunction(list, "concatspace", (args, qd) ->                            
                QuestUtils.connect(args, " ", 0));     
        registerFunction(list, "onlyletters", (args, qd) ->                            
                onlyLetters(QuestUtils.connect(args, 0)));
        registerConsumer(list, "command", (args, qd) -> 
                KajetansMod.server.commandManager.executeCommand(KajetansMod.server, QuestUtils.connect(args, "", 0)));
        registerConsumer(list, "waitfor", (args, qd) ->     
                waitFor(args, qd));  
        
        methods = list.toArray(new BiFunction[list.size()]);
    }
    
    public boolean printStack = false;

    @SuppressWarnings("unchecked")
    public Object parseFunction(QuestData qd, int function, Object[] args)
    {
        try
        {
            qd.exeClock.pushTime(qd.isBenchmarking());
            Object o = methods[function].apply(args, qd);
            qd.exeClock.pushTime(qd.isBenchmarking());
            return o;
        }
        catch(Exception ex)
        {
            if(ex instanceof HoldCodeException)
            {
                throw new HoldCodeException();
            }
            if(printStack)
            {
                ex.printStackTrace();
            }
            if(qd.getTryMode())
            {
                qd.setTryMode(false);
                qd.setTryFail(true);
                qd.setVar("error", ex.getClass().getSimpleName());
                qd.goHigher();
                return 0;
            }
            printQuestException(qd, ex, translator.inverse().get(function) + "(" + Arrays.stream(args).map(o -> String.valueOf(o)).collect(Collectors.joining(", ")) + ")");     
            throw new HoldCodeException();
        }
    }
    
    public void printQuestException(QuestData qd, Exception ex, String line)
    {
        qd.resetOverflowProtection();
        sendToDevsWithSuffix(qd, "§cError in");
        if(qd.isScript())
        {
            sendToDevsWithHelpList(qd, "§cScript", qd.getName());
        }
        else
        {
            sendToDevsWithHelpList(qd, "§cQuest", qd.getName());
        }
        sendToDevsWithHelpList(qd, "§cZeile", line);
        sendToDevsWithHelpList(qd, "§cZeilennummer", String.valueOf(qd.getActualCodeLine() + 1));
        sendToDevsWithHelpList(qd, "§cZeilenpfad", qd.getTreePath());
        if(ex.getLocalizedMessage() == null)
        {
            sendToDevsWithHelpList(qd, "§cException", ex.getClass().getSimpleName());
        }
        else
        {
            sendToDevsWithHelpList(qd, "§cException", ex.getClass().getSimpleName() + " - " + ex.getLocalizedMessage());
        }
        if(ex instanceof IllegalStringException)
        {
            sendToDevsWithHelpList(qd, "§cUngültiger Wert", ((IllegalStringException) ex).getBadString());
        }
    }
    
    // -----------------------
    // Quest Befehle
    // -----------------------
    
    private Class getClass(String s)
    {
        try
        {
            return Class.forName(s);
        }
        catch(ClassNotFoundException ex)
        {
            throw new IllegalStringException(s);
        }
    }
    
    private int getItemAmountChest(Object[] args) throws IllegalStringLocationException, IllegalItemStackStringException
    {       
        Location l = (Location) args[0];
        TileEntity te = l.getWorld().getTileEntity(l.getBlockPos());
        if(te == null || !(te instanceof TileEntityChest))
        {
            return 0;
        }        
        return InventoryUtils.searchInventoryFor(((TileEntityChest) te), (ItemStack) args[2], (boolean) args[1]);
    }
    
    private ItemStack addItemAmountChest(Object[] args) throws IllegalStringLocationException, IllegalItemStackStringException
    {       
        Location l = (Location) args[0];
        ItemStack stack = ((ItemStack) args[1]).copy();
        TileEntity te = l.getWorld().getTileEntity(l.getBlockPos());
        if(te == null || !(te instanceof TileEntityChest))
        {
            return stack;
        }        
        stack.setCount(InventoryUtils.addToInventory((TileEntityChest) te, stack));  
        return stack;
    }
    
    private ItemStack removeItemAmountChest(Object[] args) throws IllegalStringLocationException, IllegalItemStackStringException
    {       
        Location l = (Location) args[0];
        ItemStack stack = ((ItemStack) args[1]).copy();
        TileEntity te = l.getWorld().getTileEntity(l.getBlockPos());
        if(te == null || !(te instanceof TileEntityChest))
        {
            return stack;
        }        
        stack.setCount(InventoryUtils.removeFromInventory((TileEntityChest) te, stack));  
        return stack;
    }
    
    private Object getCoordOfLocation(Object[] args) throws IllegalStringLocationException
    {
        Location l = (Location) args[0];
        switch(args[1].toString())
        {
            case "x":
                return l.getPos().xCoord;
            case "y":
                return l.getPos().yCoord;
            case "z":
                return l.getPos().zCoord;
            case "bx":
                return (int) l.getPos().xCoord;
            case "by":
                return (int) l.getPos().yCoord;
            case "bz":
                return (int) l.getPos().zCoord;
            case "w":
                return ModDimensions.getWorldName(l.getWorld());
            default:
                return null;
        }
    }
    
    private void cloneBlock(Object[] args) throws IllegalStringLocationException
    {
        Location l = (Location) args[1];
        IBlockState state = getBlockState((Location) args[0]);
        l.getWorld().setBlockState(l.getBlockPos(), state);
    }
    
    private ItemStack removeItem(Object[] args) throws PlayerNotFoundException, IllegalItemStackStringException
    {       
        ItemStack stack = ((ItemStack) args[1]).copy();
        stack.setCount(InventoryUtils.removeFromInventory(((EntityPlayer) args[0]).inventory, stack));
        return stack;
    }
    
    private void dropItem(Object[] args) throws IllegalStringLocationException, IllegalItemStackStringException
    {
        Location l = (Location) args[0];
        World w = l.getWorld();
        BlockPos pos = l.getBlockPos();
        ItemStack stack = ((ItemStack) args[1]).copy();
        int amount = stack.getCount();
        while(amount > 64)
        {            
            stack.setCount(64);
            amount -= 64;
            ItemStackUtils.drop(w, pos, stack);
        }
        if(amount > 0)
        {
            stack.setCount(amount);
            ItemStackUtils.drop(w, pos, stack);
        }
    }
    
    private ItemStack giveItem(Object[] args) throws PlayerNotFoundException, IllegalItemStackStringException
    {
        EntityPlayer affectedPlayer = ((EntityPlayer) args[0]);                   
        ItemStack stack = ((ItemStack) args[1]).copy();
        int amount = stack.getCount();
        InventoryPlayer inv = affectedPlayer.inventory;
        int left = 0;
        while(amount > 64)
        {            
            stack.setCount(64);
            amount -= 64;
            left += InventoryUtils.addToInventory(inv, stack);
        }
        stack.setCount(amount);
        left += InventoryUtils.addToInventory(inv, stack);
        stack.setCount(left);
        return stack;
    }
    
    private void endQuest(Object[] args, QuestData qd) throws NumberFormatException, UnsupportedOperationException
    {           
        if(qd.isScript())
        {
            throw new UnsupportedOperationException();
        }
        qd.getPlayers().stream().forEach((p) -> 
        {
            KajetansMod.quest.send(p, "Du hast die Quest geschafft!");
        });
        KajetansMod.quest.term(qd);
        throw new HoldCodeException();
    }
    
    private void setBlock(Object[] args, QuestData qd) throws IllegalStringLocationException, IllegalItemStackStringException
    {           
        Location l = (Location) args[0];
        ItemStack stack = (ItemStack) args[1];
        l.getWorld().setBlockState(l.getBlockPos(), Block.getBlockFromItem(stack.getItem()).getStateFromMeta(stack.getMetadata()));
        qd.increaseOverflowProtection();
    }
    
    private void setBlockWithData(Object[] args, QuestData qd) throws IllegalStringLocationException
    {           
        Location l = (Location) args[0];
        if(args.length >= 4)
        {
            NmsUtilities.setBlockWithData(l.getWorld(), l.getBlockPos(), QuestUtils.getInt(args[2]), Block.getBlockFromName(args[1].toString()), QuestUtils.connect(args, 3));
        }
        else
        {
            NmsUtilities.setBlockWithData(l.getWorld(), l.getBlockPos(), QuestUtils.getInt(args[2]), Block.getBlockFromName(args[1].toString()), null);
        }
        qd.increaseOverflowProtection();
    }
    
    private void dropInventory(Object[] args)
    {
        ((EntityPlayer) args[0]).inventory.dropAllItems();
    }
    
    private void playSound(Object[] args) throws IllegalStringLocationException
    {
        Location l = ((Location) args[0]);
        Vec3d v = l.getPos();
        EffectUtils.playSound((WorldServer) l.getWorld(), ReflectionUtils.getSoundEvent(args[1].toString()), SoundCategory.valueOf(args[2].toString()), v.xCoord, v.yCoord, v.zCoord);
    }
    
    private void playSoundPlayer(Object[] args) throws IllegalStringLocationException
    {
        EffectUtils.playSound((EntityPlayerMP) args[0], ReflectionUtils.getSoundEvent(args[1].toString()), SoundCategory.valueOf(args[2].toString()));
    }
    
    private void playParticle(Object[] args) throws IllegalStringLocationException
    {
        Location l = ((Location) args[0]).add(0.5, 0.5, 0.5);
        EffectUtils.spawnParticle((WorldServer) l.getWorld(), EnumParticleTypes.getByName(args[1].toString()), l.getPos(), QuestUtils.getInt(args[2]));
    }
    
    private void setEntityEquip(Object[] args) throws IllegalStringLocationException, EntityNotFoundException, IllegalItemStackStringException
    {
        EntityLivingBase liv = (EntityLivingBase) args[0];  
        ItemStack stack = ((ItemStack) args[2]).copy();
        switch(args[1].toString())
        {
            case "hand":
                liv.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, stack);
                return;
            case "head":
                liv.setItemStackToSlot(EntityEquipmentSlot.HEAD, stack);
                return;
            case "chest":
                liv.setItemStackToSlot(EntityEquipmentSlot.CHEST, stack);
                return;
            case "legs":
                liv.setItemStackToSlot(EntityEquipmentSlot.LEGS, stack);
                return;
            case "feet":
                liv.setItemStackToSlot(EntityEquipmentSlot.FEET, stack);
                return;
            case "offhand":
                liv.setItemStackToSlot(EntityEquipmentSlot.OFFHAND, stack);
        }
    }  
    
    private ItemStack getEntityEquip(Object[] args) throws IllegalStringLocationException, EntityNotFoundException
    {
        EntityLivingBase liv = (EntityLivingBase) args[0];        
        switch(args[1].toString())
        {
            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;
    } 
    
    @SuppressWarnings("unchecked")
    private void removeEntities(Object[] args) throws IllegalStringLocationException
    {
        Class<? extends Entity> c = (Class<? extends Entity>) getClass("org.bukkit.entity." + args[0]);
        if(c == Entity.class || c == EntityVillager.class || c == EntityArmorStand.class || c == EntityItemFrame.class || c == EntityHanging.class)
        {
            return;
        }
        Location l = (Location) args[1];
        Utils.getNearbyEntities(l.getWorld(), l.getPos(), QuestUtils.getDouble(args[2]), c).stream().forEach(ent -> 
        {
            ent.setDead();
        });
    }
    
    private void ifFunction(Object[] args, QuestData qd) throws IfWithoutStatementException, NoChildTreeException
    {
        if(Arrays.stream(args).allMatch(s -> s.equals(true)))
        {
            qd.goDeeper(false);
            qd.setElseMode(false);
            return;
        }
        //System.out.println("ELSE MODE AN .... ZEILE: " + qd.getActualCodeLine());
        qd.setElseMode(true);
    }  
    
    private void elseFunction(Object[] args, QuestData qd) throws IfWithoutStatementException, NoChildTreeException
    {
        //System.out.println("ZEILE ... vll tiefer ..." + qd.getActualCodeLine());
        if(qd.getElseMode())
        {
            //System.out.println("TIEFER");
            qd.setElseMode(false);
            qd.goDeeper(false);
        }
    } 
    
    private void whileFunction(Object[] args, QuestData qd) throws IfWithoutStatementException, NoChildTreeException
    {
        if(Arrays.stream(args).allMatch(s -> s.equals(true)))
        {
            qd.goDeeper(true);
        }
    } 
    
    private void setSign(Object[] args) throws IllegalStringLocationException
    {
        Location l = (Location) args[0];
        TileEntitySign sign = (TileEntitySign) l.getWorld().getTileEntity(l.getBlockPos());
        sign.signText[QuestUtils.getInt(args[1])] = new TextComponentString(QuestUtils.connect(args, 2));
    }
    
    private String getSign(Object[] args) throws IllegalStringLocationException
    {
        Location l = (Location) args[0];
        TileEntitySign sign = (TileEntitySign) l.getWorld().getTileEntity(l.getBlockPos());
        return sign.signText[QuestUtils.getInt(args[1])].getUnformattedText();
    }

    private void spawnItemFrame(Object[] args) throws IllegalStringLocationException, IllegalItemStackStringException
    {
        Location l = ((Location) args[0]);
        EntityItemFrame frame = new EntityItemFrame(l.getWorld(), l.getBlockPos(), EnumFacing.byName(args[1].toString()));
        frame.setDisplayedItem(((ItemStack) args[2]).copy());
    }
                   
    private void nameEntity(Object[] args) throws EntityNotFoundException
    {
        Entity ent = (Entity) args[0];
        ent.setCustomNameTag(QuestUtils.connect(args, 1));
        if(args.length >= 3)
        {
            ent.setAlwaysRenderNameTag((boolean) args[2]);   
            return;
        }
        ent.setAlwaysRenderNameTag(true);  
    }
    
    private EntityPlayer getQuestLeader(QuestData qd) throws PlayerNotFoundException
    {
        if(qd.isScript())
        {
            throw new UnsupportedOperationException();
        }
        return qd.getPlayers().get(0);
    }
                  
    @SuppressWarnings(value = "unchecked")
    private void sortList(List<Object> args, QuestData qd) 
    {
        Collections.sort(args, (Object o1, Object o2) -> ((Comparable) o1).compareTo(o2));
    }
    
    private void questersToList(Object[] args, QuestData qd) throws UnsupportedOperationException 
    {
        if(qd.isScript())
        {
            throw new UnsupportedOperationException();
        }
        qd.setVar(args[0], qd.getPlayers());
    }
    
    private int getNumberOfQuesters(QuestData qd) throws UnsupportedOperationException
    {
        if(qd.isScript())
        {
            throw new UnsupportedOperationException();
        }
        return qd.getPlayers().size();
    }
                   
    private void giveQuest(Object[] args, QuestData qd) throws PlayerNotFoundException
    {
        if(qd.isScript())
        {
            EntityPlayer p = ((EntityPlayer) args[0]);
            if(!KajetansMod.quest.hasQuest(p))
            {
                KajetansMod.quest.startQuest(KajetansMod.server, args[1].toString(), p, null, null);
            }
            return;
        }
        EntityPlayer p = qd.getPlayers().get(0);
        if(Permission.has(p, Permissions.SCRIPT_ERROR))
        {
            qd.loadNewCode(args[0].toString(), p);
            return;
        }
        qd.loadNewCode(args[0].toString(), KajetansMod.server);
    }
    
    private void forceQuest(QuestData qd) throws UnsupportedOperationException
    {
        if(qd.isScript())
        {
            throw new UnsupportedOperationException();
        }
        Object name = qd.getVar("force");
        if(name != null)
        {
            qd.loadNewCode(name.toString(), KajetansMod.server);
        }
    }
               
    private void addToScoreBoard(Object[] args, QuestData qd) throws PlayerNotFoundException
    {
        int id = QuestUtils.getInt(args[1]);
        String message = QuestUtils.connect(args, 2);
        doForGroup(args[0], qd, p -> KajetansMod.scoreboard.getScoreboard((EntityPlayer) p).addText(id, message));
    }
    
    private void removeFromScoreBoard(Object[] args, QuestData qd) throws PlayerNotFoundException
    {
        int id = QuestUtils.getInt(args[1]);
        doForGroup(args[0], qd, p -> KajetansMod.scoreboard.getScoreboard((EntityPlayer) p).removeText(id));
    }

    private void sendToActionBar(Object[] args, QuestData qd) throws PlayerNotFoundException
    {
        String text = QuestUtils.connect(args, 1);
        doForGroup(args[0], qd, p -> NmsUtilities.sendActionBar((EntityPlayerMP) p, text));
    }

    private void kickPlayerFromQuest(Object[] args, QuestData qd) throws PlayerNotFoundException, UnsupportedOperationException
    {
        if(qd.isScript())
        {
            throw new UnsupportedOperationException();
        }
        KajetansMod.quest.removePlayerFromQuest((EntityPlayer) args[0], qd);
    }
                   
    private void scheduleGoto(Object[] args, QuestData qd)
    {
        KajetansMod.scheduler.scheduleTask(() -> 
        {
            if(!qd.isValid())
            {
                return;
            }
            try
            {
                qd.gotoLabel(args[1].toString());
                qd.setIsWaiting(false);
                qd.runCode();
            }
            catch(NoChildTreeException | CodeTooLongException | GotoLabelNotFoundException ex)
            {
                printQuestException(qd, ex, "(Scheduled Goto)");
            }
        }, QuestUtils.getInt(args[0]));
    }
    
    private void waitFor(Object[] args, QuestData qd) throws UnsupportedOperationException
    {           
        qd.resetOverflowProtection();
        int i = QuestUtils.getInt(args[0]);
        if(i < 1)
        {
            throw new UnsupportedOperationException();
        }
        qd.setIsWaiting(true);
        KajetansMod.scheduler.scheduleTask(() -> 
        {                   
            if(qd == null || !qd.isValid())
            {
                return;
            }
            qd.setIsWaiting(false);
            qd.runCode();
        }, i); 
        throw new HoldCodeException();
    }   
    
    private void throwEntity(Object[] args)
    {
        Entity ent = (Entity) args[0];
        ent.motionX = QuestUtils.getDouble(args[1]);
        ent.motionY = QuestUtils.getDouble(args[2]);
        ent.motionZ = QuestUtils.getDouble(args[3]);
    }
    
    private void damageEntity(Object[] args)
    {
        if(args.length >= 4)
        {
            ((EntityLivingBase) args[0]).attackEntityFrom(DamageSource.causeMobDamage((EntityLivingBase) args[2]), QuestUtils.getFloat(args[1]));
            return;
        }
        ((EntityLivingBase) args[0]).attackEntityFrom(DamageSource.GENERIC, QuestUtils.getFloat(args[1]));
    }
    
    private boolean isBetween(Object[] args)
    {
        Vec3d l1 = ((Location) args[0]).getPos();
        Vec3d l2 = ((Location) args[1]).getPos();
        Vec3d l3 = ((Location) args[2]).getPos();
        return l1.xCoord >= Math.min(l2.xCoord, l3.xCoord) &&
                l1.xCoord <= Math.max(l2.xCoord, l3.xCoord) &&
                l1.yCoord >= Math.min(l2.yCoord, l3.yCoord) &&
                l1.yCoord <= Math.max(l2.yCoord, l3.yCoord) &&
                l1.zCoord >= Math.min(l2.zCoord, l3.zCoord) &&
                l1.zCoord <= Math.max(l2.zCoord, l3.zCoord);
    }
    
    private Number increaseVar(Object var, QuestData qd, int value)
    {
        Number n = numberHandler(qd.getVar(var.toString()), (a) -> a + value, (a) -> a + value, (a) -> a + value);
        qd.setVar(var.toString(), n);
        return n;
    }
    
    private void addPlot(Object[] args)
    {
        Location l1 = (Location) args[0];
        Location l2 = (Location) args[1];
        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, args[2].toString()); 
    }
    
    private boolean isEqual(Object[] args)
    {
        if(args[0] == null)
        {
            return args[1] == null;
        }
        else if(args[1] == null)
        {
            return args[0] == null;
        }
        else if(args[1] instanceof ItemStack && args[0] instanceof ItemStack)
        {
            return InventoryUtils.doItemStacksMatch((ItemStack) args[0], (ItemStack) args[1]);
        }
        else if(args[1] instanceof Number && args[0] instanceof Number)
        {
            return ((Number) args[0]).doubleValue() == ((Number) args[1]).doubleValue();
        }
        else if(args[0] instanceof Location && args[1] instanceof Location)
        {
            Location l = (Location) args[0];
            Location l2 = (Location) args[1];
            BlockPos pos1 = l.getBlockPos();
            BlockPos pos2 = l2.getBlockPos();
            return pos1.getX() == pos2.getX() &&
                    pos1.getY() == pos2.getY() &&
                    pos1.getZ() == pos2.getZ() && l.getWorld().equals(l2.getWorld());
        }
        return args[0].equals(args[1]);
    }
    
    private void tryFunction(Object[] args, QuestData qd) throws NoChildTreeException
    {
        qd.goDeeper(false); 
        qd.setTryMode(true);
    }
    
    private void catchFunction(QuestData qd) throws NoChildTreeException
    {
        if(qd.getTryFail())
        {
            qd.setTryFail(false);
            qd.goDeeper(false);
        }
    }
    
    private SnuviInventory newInventory(Location l, QuestData qd, String s)
    {
        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(s, size, qd.getNewId()); 
        for(int i = 0; i < chest.getSizeInventory(); i++)
        {
            inv.setInventorySlotContents(i, chest.getStackInSlot(i).copy());
        }
        return inv;
    }
    
    private void split(Object[] args, QuestData qd)
    {
        String[] parts = QuestUtils.connect(args, 2).split(args[1].toString());
        ArrayList<Object> list = new ArrayList<>();
        for(String s : parts)
        {
            list.add(QuestUtils.convertInput(s));
        }
        qd.setVar(args[0], list);
    }
    
    private boolean onlyLetters(String s)
    {
        for(char c : s.toCharArray())
        {
            if(!Character.isLetter(c))
            {
                return false;
            }
        }
        return true;
    }
    
    private String getName(Object[] args)
    {
        Object o = args[0];
        if(o instanceof EntityPlayer)
        {
            return ((EntityPlayer) o).getName();
        }
        return KajetansMod.playerbank.getDataBank().getName(o.toString());
    }
    
    private String getUuid(Object[] args)
    {
        Object o = args[0];
        if(o instanceof EntityPlayer)
        {
            return ((EntityPlayer) o).getUniqueID().toString();
        }
        return KajetansMod.playerbank.getDataBank().getUUID(o.toString());
    }
    
    private String getPotionType(Object[] args)
    {
        return PotionUtils.getPotionFromItem(((EntityPotion) args[0]).getPotion()).toString();
    }
    
    private void setTag(Object[] args)
    {
        if(args[0] instanceof EntityPlayer)
        {
            KajetansMod.playerbank.getDataBank().setTag((EntityPlayer) args[0], args[1].toString(), QuestUtils.getInt(args[2]));
            return;
        }
        KajetansMod.playerbank.getDataBank().setTag(KajetansMod.playerbank.getDataBank().getUUID(args[0].toString()), args[1].toString(), QuestUtils.getInt(args[2]));
    }
    
    private int getTag(Object[] args)
    {
        if(args[0] instanceof EntityPlayer)
        {
            return KajetansMod.playerbank.getDataBank().getTag((EntityPlayer) args[0], args[1].toString());
        }
        return KajetansMod.playerbank.getDataBank().getTag(KajetansMod.playerbank.getDataBank().getUUID(args[0].toString()), args[1].toString());
    }
    
    private void setGlobalVar(Object[] args)
    {
        if(args[0] instanceof EntityPlayer)
        {
            KajetansMod.quest.getDataBank(QuestBank.class).setVar(args[2].toString(), args[1].toString(), ((EntityPlayer) args[0]).getUniqueID().toString());
            return;
        }
        KajetansMod.quest.getDataBank(QuestBank.class).setVar(args[2].toString(), args[1].toString(), KajetansMod.playerbank.getDataBank().getUUID(args[0].toString()));
    }
    
    private Object getGlobalVar(Object[] args)
    {
        if(args[0] instanceof EntityPlayer)
        {
            return KajetansMod.quest.getDataBank(QuestBank.class).getVar(args[1].toString(), ((EntityPlayer) args[0]).getUniqueID().toString());
        }
        return KajetansMod.quest.getDataBank(QuestBank.class).getVar(args[1].toString(), KajetansMod.playerbank.getDataBank().getUUID(args[0].toString()));
    }

    // -------------------------------------------------------------------------    
    // Block
    // ------------------------------------------------------------------------- 
    
    private int getBlockData(Location l)
    {
        IBlockState state = l.getWorld().getBlockState(l.getBlockPos());
        return state.getBlock().getMetaFromState(state);
    }
    
    private IBlockState getBlockState(Location l)
    {
        return l.getWorld().getBlockState(l.getBlockPos());
    }
    
    private ItemStack getStackFromBlock(Location l)
    {
        World w = l.getWorld();
        BlockPos pos = l.getBlockPos();
        IBlockState state = w.getBlockState(pos);
        return state.getBlock().getItem(w, pos, state);
    }
    
    // -------------------------------------------------------------------------    
    // Custom-Handler
    // ------------------------------------------------------------------------- 
    
    private void registerEnchantmentRecipe(Object[] args)
    {
        // TODO
        /*Enchantment e = Enchantment.getByName(args[0].toString());
        if(e == null)
        {
            throw new IllegalStringException(args[0].toString());
        }
        ItemStack[] stacks = new ItemStack[args.length - 3];
        for(int i = 0; i < stacks.length; i++)
        {
            stacks[i] = (ItemStack) args[i + 3];
        }
        KajetansMod.customs.registerEnchantmentRecipe(e, QuestUtils.getInt(args[1]), QuestUtils.getInt(args[2]), stacks);*/
    }
    
    private void registerShapelessRecipe(Object[] args)
    {
        // TODO
        /*ItemStack[] stacks = new ItemStack[args.length - 1];
        for(int i = 0; i < stacks.length; i++)
        {
            stacks[i] = (ItemStack) args[i + 1];
        }
        KajetansMod.customs.registerShapelessRecipe((ItemStack) args[0], stacks);*/
    }
    
    private void registerShapedRecipe(Object[] args)
    {
        // TODO
        /*int counter = 0;
        while(args[counter + 1].getClass() == String.class)
        {
            counter++;
        }
        String[] s = new String[counter];
        for(int i = 0; i < s.length; i++)
        {
            s[i] = args[i + 1].toString();
        }
        
        ItemStack[] stacks = new ItemStack[args.length - 1 - s.length];
        for(int i = 0; i < stacks.length; i++)
        {
            stacks[i] = (ItemStack) args[i + 1 + counter];
        }
        KajetansMod.customs.registerShapedRecipe((ItemStack) args[0], s, stacks);*/
    }
    
    // -------------------------------------------------------------------------    
    // Zeit-Handler
    // ------------------------------------------------------------------------- 
    
    private long getNextDay(Object[] args)       
    {
        GregorianCalendar cal = GregorianCalendar.from(ZonedDateTime.now());
        cal.setTimeInMillis((long) args[0]);
        cal.add(Calendar.DAY_OF_YEAR, 1);
        cal.set(Calendar.HOUR, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTimeInMillis();   
    } 
    
    private int getYear(Object[] args)       
    {
        GregorianCalendar cal = GregorianCalendar.from(ZonedDateTime.now());
        cal.setTimeInMillis((long) args[0]);
        return cal.get(Calendar.YEAR);   
    }
    
    private int getMonth(Object[] args)       
    {
        GregorianCalendar cal = GregorianCalendar.from(ZonedDateTime.now());
        cal.setTimeInMillis((long) args[0]);
        return cal.get(Calendar.MONTH) + 1;   
    }
    
    private int getDay(Object[] args)       
    {
        GregorianCalendar cal = GregorianCalendar.from(ZonedDateTime.now());
        cal.setTimeInMillis((long) args[0]);
        return cal.get(Calendar.DAY_OF_MONTH);   
    }
    
    private int getHour(Object[] args)       
    {
        GregorianCalendar cal = GregorianCalendar.from(ZonedDateTime.now());
        cal.setTimeInMillis((long) args[0]);
        return cal.get(Calendar.HOUR_OF_DAY);   
    }
    
    private int getMinute(Object[] args)       
    {
        GregorianCalendar cal = GregorianCalendar.from(ZonedDateTime.now());
        cal.setTimeInMillis((long) args[0]);
        return cal.get(Calendar.MINUTE);   
    }
    
    private int getSecond(Object[] args)       
    {
        GregorianCalendar cal = GregorianCalendar.from(ZonedDateTime.now());
        cal.setTimeInMillis((long) args[0]);
        return cal.get(Calendar.SECOND);   
    }
    
    // -------------------------------------------------------------------------    
    // Gruppen-Handler
    // ------------------------------------------------------------------------- 
    
    private void doForGroup(Object group, QuestData qd, Consumer<ICommandSender> c) throws UnsupportedOperationException, PlayerNotFoundException
    {
        if(group instanceof String)
        {
            switch(group.toString()) 
            {
                case "all":
                    if(qd.isScript())
                    {
                        throw new UnsupportedOperationException();
                    }
                    qd.getPlayers().forEach(p -> c.accept(p));
                    break;
                case "online":
                    KajetansMod.server.getPlayerList().getPlayers().forEach(p -> c.accept(p));
                    break;
                case "dev":
                    if(qd.isScript())
                    {
                        KajetansMod.server.getPlayerList().getPlayers().stream().filter(p -> Permission.has(p, Permissions.SCRIPT_ERROR)).forEach(p -> c.accept(p));
                        return;
                    }
                    qd.getPlayers().stream().filter(p ->  Permission.has(p, Permissions.SCRIPT_ERROR)).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 void sendMessageToGroup(Object group, QuestData qd, String message)
    {
        TextComponentString comp = new TextComponentString(message);
        doForGroup(group, qd, p -> p.sendMessage(comp));
    }
    
    public void sendMessageWithSuffix(QuestData qd, String message)
    {
        Module m = KajetansMod.quest;
        int id = qd.isScript() ? 1 : 0;
        doForGroup("all", qd, p -> m.send(p, message, id));
    }
    
    private void sendToDevsWithSuffix(QuestData qd, String message)
    {
        Module m = KajetansMod.quest;
        int id = qd.isScript() ? 1 : 0;
        doForGroup("dev", qd, p -> m.send(p, message, id));
    }
    
    public void sendWarningToAllDevs(String message)
    {
        Module m = KajetansMod.quest;
        String warnMessage = "§4" + message;
        KajetansMod.server.getPlayerList().getPlayers().stream().filter(p -> Permission.has(p, Permissions.SCRIPT_ERROR)).forEach(p -> m.send(p, warnMessage));
    }
    
    private void sendToDevsWithList(QuestData qd, String message)
    {
        Module m = KajetansMod.quest;
        int id = qd.isScript() ? 1 : 0;
        doForGroup("dev", qd, p -> m.sendListElement(p, message, id));
    }
    
    private void sendToDevsWithHelpList(QuestData qd, String message, String message2)
    {
        Module m = KajetansMod.quest;
        int id = qd.isScript() ? 1 : 0;
        doForGroup("dev", qd, p -> m.sendHelpListElement(p, message, message2, id));
    }   
        
    // -------------------------------------------------------------------------    
    // Integer-Double-Long-Handler
    // ------------------------------------------------------------------------- 
    
    private Number numberHandler(Number a,
            Function<Integer, Integer> f,
            Function<Long, Long> f2,
            Function<Double, Double> f3)
    {
        if(a instanceof Integer)
        {
            return f.apply(a.intValue());
        }
        else if(a instanceof Long)
        {
            return f2.apply(a.longValue());
        }
        return f3.apply(a.doubleValue());
    }
    
    private Number numberHandler(Object a,
            Function<Integer, Integer> f,
            Function<Long, Long> f2,
            Function<Double, Double> f3)
    {
        return numberHandler((Number) a, f, f2, f3);
    }
    
    private Number numberHandler(Number a, Number b, 
            BiFunction<Integer, Integer, Integer> f,
            BiFunction<Long, Long, Long> f2,
            BiFunction<Double, Double, Double> f3)
    {
        if(a instanceof Integer && b instanceof Integer)
        {
            return f.apply(a.intValue(), b.intValue());
        }
        else if((a instanceof Long || a instanceof Integer) && (b instanceof Long || b instanceof Integer))
        {
            return f2.apply(a.longValue(), b.longValue());
        }
        return f3.apply(a.doubleValue(), b.doubleValue());
    }
    
    private Number numberHandler(Object a, Object b, 
            BiFunction<Integer, Integer, Integer> f,
            BiFunction<Long, Long, Long> f2,
            BiFunction<Double, Double, Double> f3)
    {
        return numberHandler((Number) a, (Number) b, f, f2, f3);
    }
    
    private Number convertDouble(Double d)
    {
        if(d == d.intValue())
        {
            return d.intValue();
        }
        else if(d == d.longValue())
        {
            return d.longValue();
        }
        return d;
    }
    
    // -------------------------------------------------------------------------    
    // Rundungs-Handler
    // ------------------------------------------------------------------------- 
    
    private Number round(Object o)
    {
        Long l = Math.round(QuestUtils.getDouble(o));
        if(l == l.intValue())
        {
            return l.intValue();
        }
        return l;
    }
    
    private Number roundDown(Object o)
    {
        Double d = Math.floor(QuestUtils.getDouble(o));
        if(d == d.intValue())
        {
            return d.intValue();
        }
        return d.longValue();
    }
    
    private Number roundUp(Object o)
    {
        Double d = Math.ceil(QuestUtils.getDouble(o));
        if(d == d.intValue())
        {
            return d.intValue();
        }
        return d.longValue();
    }
}