package me.km.snuviscript;
import me.km.KajetansMod;
import me.km.afk.AfkListener;
import me.km.environment.EnvironmentAPI;
import me.km.utils.NBTUtils;
import me.km.plots.ProtectionBank;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import me.hammerle.snuviscript.code.Script;
import me.hammerle.snuviscript.code.SnuviUtils;
import me.hammerle.snuviscript.code.SnuviParser;
import me.hammerle.snuviscript.math.Fraction;
import me.km.api.Location;
import me.km.api.TitleAPI;
import me.km.api.Utils;
import me.km.chatchannel.ChatChannel;
import me.km.commands.CommandSilent;
import me.km.dimensions.ModDimensions;
import me.km.effects.EffectUtils;
import me.km.inventory.InventoryUtils;
import me.km.table.Table;
import me.km.utils.ItemStackUtils;
import me.km.utils.ReflectionUtils;
import me.km.utils.SpecialBlockUtils;
import net.minecraft.block.Block;
import net.minecraft.block.BlockDoor;
import net.minecraft.block.state.IBlockState;
import net.minecraft.command.ICommandSender;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItemFrame;
import net.minecraft.entity.monster.EntityCreeper;
import net.minecraft.entity.passive.EntityVillager;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.entity.projectile.EntityPotion;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.network.ThreadQuickExitException;
import net.minecraft.network.play.client.CPacketChatMessage;
import net.minecraft.network.play.client.CPacketClientStatus;
import net.minecraft.network.play.server.SPacketSpawnPosition;
import net.minecraft.potion.Potion;
import net.minecraft.potion.PotionUtils;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityChest;
import net.minecraft.tileentity.TileEntitySign;
import net.minecraft.util.DamageSource;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.SoundEvent;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.World;
import net.minecraft.world.WorldServer;
import me.km.effects.Effect;
import me.km.events.CustomEventCaller;
import me.km.events.PlayerMoveData;
import me.km.exception.IllegalStringException;
import me.km.exception.PlayerNotFoundException;
import me.km.inventory.CustomContainer;
import me.km.networking.ModPacketHandler;
import me.km.pathfinder.PathfinderUtils;
import me.km.permissions.Permissions;
import me.km.skills.LeveledSkill;
import me.km.skills.Skill;
import me.km.table.TableAPI;
import net.minecraft.block.BlockCrops;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.item.Item;
import net.minecraft.util.NonNullList;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
public class MinecraftFunctions
{
public static int inventoryIds = 0;
@SuppressWarnings("")
public static void registerFunctions(SnuviParser parser)
{
// ---------------------------------------------------------------------
// Command-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("command.add", (sc, in) ->
{
KajetansMod.scripts.registerScriptCommand(in[0].getString(sc));
return Void.TYPE;
});
parser.registerFunction("command.remove", (sc, in) ->
{
KajetansMod.scripts.unregisterScriptCommand(in[0].getString(sc));
return Void.TYPE;
});
parser.registerFunction("command.exists", (sc, in) -> KajetansMod.scripts.isRegisteredScriptCommand(in[0].getString(sc)));
parser.registerFunction("command.clear", (sc, in) ->
{
KajetansMod.scripts.clearScriptCommands();
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Permission-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("perm.clear", (sc, in) ->
{
KajetansMod.perms.clear();
return Void.TYPE;
});
parser.registerFunction("perm.registergroup", (sc, in) ->
{
KajetansMod.perms.registerGroupPermission(in[0].getInt(sc), in[1].getString(sc));
return Void.TYPE;
});
parser.registerFunction("perm.registerplayer", (sc, in) ->
{
KajetansMod.perms.registerPlayerGroup(UUID.fromString(in[0].getString(sc)), in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("perm.has", (sc, in) -> KajetansMod.perms.hasPermission((ICommandSender) in[0].get(sc), in[1].getString(sc)));
// ---------------------------------------------------------------------
// Title-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("title.settime", (sc, in) ->
{
TitleAPI.setTitleTime((EntityPlayerMP) in[0].get(sc), in[1].getInt(sc), in[2].getInt(sc), in[3].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("title.clear", (sc, in) ->
{
TitleAPI.clearTitle((EntityPlayerMP) in[0].get(sc));
return Void.TYPE;
});
parser.registerFunction("title.reset", (sc, in) ->
{
TitleAPI.resetTitle((EntityPlayerMP) in[0].get(sc));
return Void.TYPE;
});
parser.registerFunction("title.send", (sc, in) ->
{
TitleAPI.setTitle((EntityPlayerMP) in[0].get(sc), SnuviUtils.connect(sc, in, 1));
return Void.TYPE;
});
parser.registerFunction("title.setsub", (sc, in) ->
{
TitleAPI.setSubTitle((EntityPlayerMP) in[0].get(sc), SnuviUtils.connect(sc, in, 1));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Villager-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("villager.showtrades", (sc, in) ->
{
((EntityPlayer) in[0].get(sc)).displayVillagerTradeGui(((EntityVillager) in[1].get(sc)));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Player-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("player.getitemamount", (sc, in) -> new Fraction(InventoryUtils.searchInventoryFor(((EntityPlayer) in[0].get(sc)).inventory, (ItemStack) in[2].get(sc), in[1].getBoolean(sc))));
parser.registerFunction("player.removeitem", (sc, in) ->
{
ItemStack stack = ((ItemStack) in[1].get(sc)).copy();
stack.setCount(InventoryUtils.removeFromInventory(((EntityPlayer) in[0].get(sc)).inventory, stack));
return stack;
});
parser.registerFunction("player.giveitem", (sc, in) ->
{
ItemStack stack = ((ItemStack) in[1].get(sc)).copy();
stack.setCount(InventoryUtils.addToInventory(((EntityPlayer) in[0].get(sc)).inventory, stack));
return stack;
});
parser.registerFunction("player.shootprojectile", (sc, in) -> EffectUtils.launchProjectile((EntityPlayer) in[0].get(sc), getClass(in[1].getString(sc)), in[2].getDouble(sc), in[3].get(sc)));
parser.registerFunction("player.respawn", (sc, in) ->
{
KajetansMod.scheduler.scheduleTask(() ->
{
try
{
((EntityPlayerMP) in[0].get(sc)).connection.processClientStatus(new CPacketClientStatus(CPacketClientStatus.State.PERFORM_RESPAWN));
}
catch(ThreadQuickExitException ex)
{
// Minecraft needs this for canceling and queueing into main thread
}
});
return Void.TYPE;
});
parser.registerFunction("player.inventorytolist", (sc, in) ->
{
in[0].set(sc, ((EntityPlayer) in[1].get(sc)).inventory.mainInventory);
return Void.TYPE;
});
parser.registerFunction("player.getnearest", (sc, in) -> Utils.getNearestPlayer(((Location) in[0].get(sc)).getWorld(), ((Location) in[0].get(sc)).getPos()));
parser.registerFunction("player.say", (sc, in) ->
{
try
{
((EntityPlayerMP) in[0].get(sc)).connection.processChatMessage(new CPacketChatMessage(SnuviUtils.connect(sc, in, 1)));
}
catch(ThreadQuickExitException ex)
{
// Minecraft needs this for canceling and queueing into main thread
}
return Void.TYPE;
});
parser.registerFunction("player.isafk", (sc, in) -> KajetansMod.afkManager.getEvent(AfkListener.class).isAfk((EntityPlayer) in[0].get(sc)));
parser.registerFunction("player.speak", (sc, in) ->
{
sendMessageToGroup(in[0].get(sc), sc, NBTUtils.concat(sc, 2, "§7[§r" + in[1].getString(sc) + "§7]§r ", in));
return Void.TYPE;
});
parser.registerFunction("player.setcompass", (sc, in) ->
{
((EntityPlayerMP) in[0].get(sc)).connection.sendPacket(new SPacketSpawnPosition(((Location) in[1].get(sc)).getBlockPos()));
return Void.TYPE;
});
parser.registerFunction("player.gethunger", (sc, in) -> new Fraction(((EntityPlayer) in[0].get(sc)).getFoodStats().getFoodLevel()));
parser.registerFunction("player.sethunger", (sc, in) ->
{
((EntityPlayer) in[0].get(sc)).getFoodStats().setFoodLevel(in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("player.getsaturation", (sc, in) -> Fraction.fromDouble(ReflectionUtils.getSaturation(((EntityPlayer) in[0].get(sc)).getFoodStats())));
parser.registerFunction("player.setsaturation", (sc, in) ->
{
ReflectionUtils.setSaturation(((EntityPlayer) in[0].get(sc)).getFoodStats(), in[1].getFraction(sc).floatValue());
return Void.TYPE;
});
parser.registerFunction("player.getname", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityPlayer)
{
return ((EntityPlayer) o).getName();
}
return KajetansMod.playerbank.getDataBank().getName(o.toString());
});
parser.registerFunction("player.getfullname", (sc, in) -> KajetansMod.chatManager.getFullName((EntityPlayer) in[0].get(sc)));
parser.registerFunction("player.getuuid", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityPlayer)
{
return ((EntityPlayer) o).getUniqueID().toString();
}
return KajetansMod.playerbank.getDataBank().getUUID(o.toString());
});
parser.registerFunction("player.getip", (sc, in) -> ((EntityPlayerMP) in[0].get(sc)).connection.netManager.getRemoteAddress().toString());
parser.registerFunction("player.iscreative", (sc, in) -> ((EntityPlayer) in[0].get(sc)).isCreative());
parser.registerFunction("player.isspectator", (sc, in) -> ((EntityPlayer) in[0].get(sc)).isSpectator());
parser.registerFunction("player.issurvival", (sc, in) ->
{
EntityPlayer p = (EntityPlayer) in[0].get(sc);
return !p.isCreative() && !p.isSpectator();
});
parser.registerFunction("player.isadventure", (sc, in) -> !((EntityPlayer) in[0].get(sc)).capabilities.allowEdit);
parser.registerFunction("player.hasfly", (sc, in) -> ((EntityPlayer) in[0].get(sc)).capabilities.allowFlying);
parser.registerFunction("player.getlastdamager", (sc, in) ->
{
DamageSource ds = ((EntityPlayer) in[0].get(sc)).getLastDamageSource();
if(ds == null)
{
return null;
}
return ds.getImmediateSource();
});
parser.registerFunction("player.settag", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityPlayer)
{
KajetansMod.playerbank.getDataBank().setTag((EntityPlayer) o, in[1].getString(sc), in[2].getInt(sc));
return Void.TYPE;
}
KajetansMod.playerbank.getDataBank().setTag(o.toString(), in[1].getString(sc), in[2].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("player.gettag", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityPlayer)
{
return new Fraction(KajetansMod.playerbank.getDataBank().getTag((EntityPlayer) o, in[1].getString(sc)));
}
return new Fraction(KajetansMod.playerbank.getDataBank().getTag(o.toString(), in[1].getString(sc)));
});
parser.registerFunction("player.setguild", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityPlayer)
{
KajetansMod.playerbank.setGuildId((EntityPlayer) o, in[1].getInt(sc));
return Void.TYPE;
}
KajetansMod.playerbank.setGuildId(o.toString(), in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("player.getguild", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityPlayer)
{
return new Fraction(KajetansMod.playerbank.getGuildId((EntityPlayer) o));
}
return new Fraction(KajetansMod.playerbank.getGuildId(o.toString()));
});
parser.registerFunction("player.dropinventory", (sc, in) ->
{
((EntityPlayer) in[0].get(sc)).inventory.dropAllItems();
return Void.TYPE;
});
parser.registerFunction("player.gettarget", (sc, in) ->
{
if(in.length > 2)
{
return new Location(((EntityPlayer) in[0].get(sc)).world,
Utils.getPlayerTarget((EntityPlayer) in[0].get(sc), in[1].getInt(sc), in[2].getBoolean(sc)));
}
return new Location(((EntityPlayer) in[0].get(sc)).world, Utils.getPlayerTarget((EntityPlayer) in[0].get(sc), in[1].getInt(sc)));
});
parser.registerFunction("player.gettargetentity", (sc, in) -> Utils.getTargetedEntity((EntityPlayer) in[0].get(sc), in[1].getDouble(sc), getClass(in[2].getString(sc))));
parser.registerFunction("player.hasscript", (sc, in) -> KajetansMod.scripts.isRegistered((EntityPlayer) in[0].get(sc)));
parser.registerAlias("player.hasscript", "player.hasquest");
parser.registerFunction("player.action", (sc, in) ->
{
TextComponentString text = new TextComponentString(SnuviUtils.connect(sc, in, 1));
doForGroup(in[0].get(sc), sc, p -> ((EntityPlayerMP) p).sendStatusMessage(text, true));
return Void.TYPE;
});
parser.registerFunction("player.kick", (sc, in) -> KajetansMod.scripts.unregisterPlayer((EntityPlayer) in[0].get(sc)));
parser.registerFunction("player.playsound", (sc, in) ->
{
EffectUtils.playSound((EntityPlayerMP) in[0].get(sc), SoundEvent.REGISTRY.getObject(new ResourceLocation(in[1].getString(sc))), SoundCategory.MASTER);
return Void.TYPE;
});
parser.registerFunction("player.getspawn", (sc, in) ->
{
WorldServer ws = ModDimensions.getWorldFromName(in[1].getString(sc));
return new Location(ws, ((EntityPlayer) in[0].get(sc)).getBedLocation(ws.provider.getDimension()));
});
parser.registerAlias("player.getspawn", "player.getbedspawn");
parser.registerFunction("player.setspawn", (sc, in) ->
{
Location l = (Location) in[1].get(sc);
((EntityPlayerMP) in[0].get(sc)).setSpawnChunk(l.getBlockPos(), true, l.getWorld().provider.getDimension());
return Void.TYPE;
});
parser.registerAlias("player.setspawn", "player.setbedspawn");
parser.registerFunction("player.damageitem", (sc, in) ->
{
((EntityPlayer) in[0].get(sc)).getHeldItemMainhand().damageItem(in[1].getInt(sc), (EntityPlayer) in[0].get(sc));
return Void.TYPE;
});
parser.registerFunction("player.silentjoin", (sc, in) -> KajetansMod.perms.hasPermission((EntityPlayer) in[0].get(sc), Permissions.SILENT) && KajetansMod.generalCommands.getCommand(CommandSilent.class).silentjoin);
// ---------------------------------------------------------------------
// Players-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("players.getamount", (sc, in) -> new Fraction(KajetansMod.server.getCurrentPlayerCount()));
parser.registerFunction("players.tolist", (sc, in) ->
{
in[0].set(sc, new ArrayList(KajetansMod.server.getPlayerList().getPlayers()));
return Void.TYPE;
});
parser.registerFunction("players.toworldlist", (sc, in) ->
{
in[0].set(sc, new ArrayList(ModDimensions.getWorldFromName(in[1].getString(sc)).playerEntities));
return Void.TYPE;
});
parser.registerFunction("players.near", (sc, in) ->
{
Location l = (Location) in[1].get(sc);
in[0].set(sc, Utils.getPlayers(l.getWorld(), l.getX(), l.getY(), l.getZ(), in[2].getDouble(sc)));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Rank-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("rank.get", (sc, in) ->
{
in[0].set(sc, KajetansMod.chatManager.getRanks((EntityPlayer) in[1].get(sc)));
return Void.TYPE;
});
parser.registerFunction("rank.register", (sc, in) ->
{
KajetansMod.chatManager.registerRank(in[0].getString(sc), in[1].getInt(sc), in[2].getString(sc));
return Void.TYPE;
});
parser.registerFunction("rank.player", (sc, in) ->
{
KajetansMod.chatManager.registerPlayerRank(UUID.fromString(in[0].getString(sc)), in[1].getString(sc));
return Void.TYPE;
});
parser.registerFunction("rank.clear", (sc, in) ->
{
KajetansMod.chatManager.clearRanks();
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Custom-Bibliothek
// ---------------------------------------------------------------------
/*parser.registerFunction("custom.registershapelessrecipe", (sc, in) ->
{
ItemStack[] stacks = new ItemStack[in.length - 1];
for(int i = 0; i < stacks.length; i++)
{
stacks[i] = (ItemStack) in[i + 1].get(sc);
}
RecipeUtils.registerShapelessRecipe((ItemStack) in[0].get(sc), stacks);
return Void.TYPE;
});
parser.registerFunction("custom.registershapedrecipe", (sc, in) ->
{
int counter = 0;
while(in[counter + 1].get(sc).getClass() == String.class)
{
counter++;
}
String[] s = new String[counter];
for(int i = 0; i < s.length; i++)
{
s[i] = in[i + 1].toString();
}
ItemStack[] stacks = new ItemStack[in.length - 1 - s.length];
for(int i = 0; i < stacks.length; i++)
{
stacks[i] = (ItemStack) in[i + 1 + counter].get(sc);
}
RecipeUtils.registerShapedRecipe((ItemStack) in[0].get(sc), s, stacks);
return Void.TYPE;
});
parser.registerFunction("custom.registerfurnacerecipe", (sc, in) ->
{
RecipeUtils.registerFurnaceRecipe((ItemStack) in[0].get(sc), (ItemStack) in[1].get(sc));
return Void.TYPE;
});
parser.registerFunction("custom.clearrecipes", (sc, in) ->
{
RecipeUtils.clearRecipes();
return Void.TYPE;
});*/
// ---------------------------------------------------------------------
// World-Bibliothek
// ---------------------------------------------------------------------
parser.registerAlias("players.toworldlist", "world.getplayers");
parser.registerFunction("world.setskills", (sc, in) ->
{
KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(in[0].getString(sc))).skills = in[1].getBoolean(sc);
return Void.TYPE;
});
parser.registerFunction("world.setblockprotections", (sc, in) ->
{
KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(in[0].getString(sc))).blockProtection = in[1].getBoolean(sc);
return Void.TYPE;
});
parser.registerFunction("world.setdefaultenchanting", (sc, in) ->
{
KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(in[0].getString(sc))).defaultEnchanting = in[1].getBoolean(sc);
return Void.TYPE;
});
parser.registerFunction("world.setpvpprotection", (sc, in) ->
{
KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(in[0].getString(sc))).pvpProtection = in[1].getBoolean(sc);
return Void.TYPE;
});
parser.registerFunction("world.setstatuseffects", (sc, in) ->
{
KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(in[0].getString(sc))).statusEffects = in[1].getBoolean(sc);
return Void.TYPE;
});
parser.registerFunction("world.setmanabar", (sc, in) ->
{
KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(in[0].getString(sc))).manabar = in[1].getBoolean(sc);
return Void.TYPE;
});
parser.registerFunction("world.setscrolls", (sc, in) ->
{
KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(in[0].getString(sc))).scrolls = in[1].getBoolean(sc);
return Void.TYPE;
});
parser.registerFunction("world.setdefaultproducing", (sc, in) ->
{
KajetansMod.worldManager.getWorldPreferences(ModDimensions.getWorldFromName(in[0].getString(sc))).defaultProducing = in[1].getBoolean(sc);
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Item-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("item.drop", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
World w = l.getWorld();
BlockPos pos = l.getBlockPos();
ItemStack stack = ((ItemStack) in[1].get(sc)).copy();
int amount = stack.getCount();
while(amount > stack.getMaxStackSize())
{
stack.setCount(stack.getMaxStackSize());
amount -= stack.getMaxStackSize();
ItemStackUtils.drop(w, pos, stack.copy());
}
if(amount > 0)
{
stack.setCount(amount);
ItemStackUtils.drop(w, pos, stack);
}
return Void.TYPE;
});
parser.registerFunction("item.gettype", (sc, in) -> ((ItemStack) in[0].get(sc)).getItem().getRegistryName().toString());
parser.registerFunction("item.getdata", (sc, in) -> new Fraction(((ItemStack) in[0].get(sc)).getMetadata()));
parser.registerFunction("item.setdata", (sc, in) ->
{
((ItemStack) in[0].get(sc)).setItemDamage(in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("item.getamount", (sc, in) -> new Fraction(((ItemStack) in[0].get(sc)).getCount()));
parser.registerFunction("item.setamount", (sc, in) ->
{
((ItemStack) in[0].get(sc)).setCount(in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("item.getname", (sc, in) -> ((ItemStack) in[0].get(sc)).getDisplayName());
parser.registerFunction("item.setname", (sc, in) ->
{
((ItemStack) in[0].get(sc)).setStackDisplayName(SnuviUtils.connect(sc, in, 1));
return Void.TYPE;
});
parser.registerFunction("item.getlore", (sc, in) ->
{
in[0].set(sc, ItemStackUtils.getLore((ItemStack) in[1].get(sc)));
return Void.TYPE;
});
parser.registerFunction("item.setlore", (sc, in) ->
{
ItemStackUtils.setLore((ItemStack) in[0].get(sc), (List<String>) in[1].get(sc));
return Void.TYPE;
});
parser.registerFunction("item.addlore", (sc, in) ->
{
ItemStackUtils.addLore((ItemStack) in[0].get(sc), SnuviUtils.connect(sc, in, 2), in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("item.getenchantlevel", (sc, in) -> new Fraction(EnchantmentHelper.getEnchantmentLevel(Enchantment.getEnchantmentByLocation(in[1].getString(sc)), (ItemStack) in[0].get(sc))));
parser.registerFunction("item.setcooldown", (sc, in) ->
{
((EntityPlayer) in[0].get(sc)).getCooldownTracker().setCooldown(((ItemStack) in[1].get(sc)).getItem(), in[2].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("item.gettooltype", (sc, in) -> Utils.getToolType((ItemStack) in[0].get(sc)));
// ---------------------------------------------------------------------
// Location-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("loc.new", (sc, in) ->
{
if(in.length >= 6)
{
return new Location(ModDimensions.getWorldFromName(in[0].getString(sc)),
in[1].getDouble(sc), in[2].getDouble(sc), in[3].getDouble(sc),
in[4].getFraction(sc).floatValue(), in[5].getFraction(sc).floatValue());
}
return new Location(ModDimensions.getWorldFromName(in[0].getString(sc)), in[1].getDouble(sc), in[2].getDouble(sc), in[3].getDouble(sc), 0, 0);
});
parser.registerFunction("loc.getx", (sc, in) -> Fraction.fromDouble(((Location) in[0].get(sc)).getX()));
parser.registerFunction("loc.gety", (sc, in) -> Fraction.fromDouble(((Location) in[0].get(sc)).getY()));
parser.registerFunction("loc.getz", (sc, in) -> Fraction.fromDouble(((Location) in[0].get(sc)).getZ()));
parser.registerFunction("loc.setx", (sc, in) ->
{
((Location) in[0].get(sc)).setX(in[1].getDouble(sc));
return Void.TYPE;
});
parser.registerFunction("loc.sety", (sc, in) ->
{
((Location) in[0].get(sc)).setY(in[1].getDouble(sc));
return Void.TYPE;
});
parser.registerFunction("loc.setz", (sc, in) ->
{
((Location) in[0].get(sc)).setZ(in[1].getDouble(sc));
return Void.TYPE;
});
parser.registerFunction("loc.addx", (sc, in) ->
{
((Location) in[0].get(sc)).addX(in[1].getDouble(sc));
return Void.TYPE;
});
parser.registerFunction("loc.addy", (sc, in) ->
{
((Location) in[0].get(sc)).addY(in[1].getDouble(sc));
return Void.TYPE;
});
parser.registerFunction("loc.addz", (sc, in) ->
{
((Location) in[0].get(sc)).addZ(in[1].getDouble(sc));
return Void.TYPE;
});
parser.registerFunction("loc.setyaw", (sc, in) ->
{
((Location) in[0].get(sc)).setYaw(in[1].getFraction(sc).floatValue());
return Void.TYPE;
});
parser.registerFunction("loc.setpitch", (sc, in) ->
{
((Location) in[0].get(sc)).setPitch(in[1].getFraction(sc).floatValue());
return Void.TYPE;
});
parser.registerFunction("loc.distance", (sc, in) -> Fraction.fromDouble(((Location) in[0].get(sc)).getPos().distanceTo(((Location) in[1].get(sc)).getPos())));
parser.registerFunction("loc.mod", (sc, in) -> ((Location) in[0].get(sc)).copyAdd(in[1].getDouble(sc), in[2].getDouble(sc), in[3].getDouble(sc)));
parser.registerFunction("loc.getcoord", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
switch(in[1].getString(sc))
{
case "x":
return Fraction.fromDouble(l.getX());
case "y":
return Fraction.fromDouble(l.getY());
case "z":
return Fraction.fromDouble(l.getZ());
case "bx":
return new Fraction(MathHelper.floor(l.getX()));
case "by":
return new Fraction(MathHelper.floor(l.getY()));
case "bz":
return new Fraction(MathHelper.floor(l.getZ()));
case "w":
return ModDimensions.getWorldName(l.getWorld());
default:
return null;
}
});
parser.registerFunction("loc.gettime", (sc, in) -> new Fraction(((Location) in[0].get(sc)).getWorld().getWorldTime()));
parser.registerFunction("loc.hasstorm", (sc, in) -> ((Location) in[0].get(sc)).getWorld().isRaining());
parser.registerFunction("loc.isbetween", (sc, in) ->
{
Location l1 = (Location) in[0].get(sc);
Location l2 = (Location) in[1].get(sc);
Location l3 = (Location) in[2].get(sc);
return l1.getX() >= Math.min(l2.getX(), l3.getX()) && l1.getX() <= Math.max(l2.getX(), l3.getX()) &&
l1.getY() >= Math.min(l2.getY(), l3.getY()) && l1.getY() <= Math.max(l2.getY(), l3.getY()) &&
l1.getZ() >= Math.min(l2.getZ(), l3.getZ()) && l1.getZ() <= Math.max(l2.getZ(), l3.getZ());
});
// ---------------------------------------------------------------------
// Block-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("block.gettype", (sc, in) -> ((Location) in[0].get(sc)).getWorld().getBlockState(((Location) in[0].get(sc)).getBlockPos()).getBlock().getRegistryName().toString());
parser.registerFunction("block.getdata", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
IBlockState state = l.getWorld().getBlockState(l.getBlockPos());
return new Fraction(state.getBlock().getMetaFromState(state));
});
parser.registerFunction("block.clone", (sc, in) ->
{
Location l = (Location) in[1].get(sc);
NBTUtils.cloneBlock(l.getWorld(), ((Location) in[0].get(sc)).getBlockPos(), l.getBlockPos());
return Void.TYPE;
});
parser.registerFunction("block.set", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
ItemStack stack = (ItemStack) in[1].get(sc);
l.getWorld().setBlockState(l.getBlockPos(), Block.getBlockFromItem(stack.getItem()).getStateFromMeta(stack.getMetadata()));
return Void.TYPE;
});
parser.registerFunction("block.set2", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
if(in.length >= 4)
{
NBTUtils.setBlockWithData(l.getWorld(), l.getBlockPos(), in[2].getInt(sc), Block.getBlockFromName(in[1].getString(sc)), SnuviUtils.connect(sc, in, 3));
}
else
{
NBTUtils.setBlockWithData(l.getWorld(), l.getBlockPos(), in[2].getInt(sc), Block.getBlockFromName(in[1].getString(sc)), null);
}
return Void.TYPE;
});
parser.registerFunction("block.setsign", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
TileEntitySign sign = (TileEntitySign) l.getWorld().getTileEntity(l.getBlockPos());
SpecialBlockUtils.setSignLine(sign, in[1].getInt(sc), SnuviUtils.connect(sc, in, 2));
return Void.TYPE;
});
parser.registerFunction("block.getsign", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
TileEntitySign sign = (TileEntitySign) l.getWorld().getTileEntity(l.getBlockPos());
return sign.signText[in[1].getInt(sc)].getUnformattedText();
});
parser.registerFunction("block.setdoorstatus", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
BlockPos pos = l.getBlockPos();
((BlockDoor) l.getWorld().getBlockState(pos).getBlock()).toggleDoor(l.getWorld(), pos, in[1].getBoolean(sc));
return Void.TYPE;
});
parser.registerFunction("block.getdoorstatus", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
return BlockDoor.isOpen(l.getWorld(), l.getBlockPos());
});
parser.registerFunction("block.isdoor", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
return l.getWorld().getBlockState(l.getBlockPos()).getBlock() instanceof BlockDoor;
});
parser.registerFunction("block.issolid", (sc, in) ->
{
IBlockState state = getBlockState((Location) in[0].get(sc));
return state.isFullBlock() && state.isOpaqueCube();
});
parser.registerFunction("block.tostack", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
World w = l.getWorld();
BlockPos pos = l.getBlockPos();
IBlockState state = w.getBlockState(pos);
return state.getBlock().getItem(w, pos, state);
});
parser.registerFunction("block.getitemamount", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
TileEntity te = l.getWorld().getTileEntity(l.getBlockPos());
if(te == null || !(te instanceof TileEntityChest))
{
return new Fraction(0);
}
return new Fraction(InventoryUtils.searchInventoryFor((TileEntityChest) te, (ItemStack) in[2].get(sc), in[1].getBoolean(sc)));
});
parser.registerFunction("block.additem", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
ItemStack stack = ((ItemStack) in[1].get(sc));
TileEntity te = l.getWorld().getTileEntity(l.getBlockPos());
if(te == null || !(te instanceof TileEntityChest))
{
return stack;
}
stack.setCount(InventoryUtils.addToInventory((TileEntityChest) te, stack));
return stack;
});
parser.registerFunction("block.subitem", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
ItemStack stack = ((ItemStack) in[1].get(sc));
TileEntity te = l.getWorld().getTileEntity(l.getBlockPos());
if(te == null || !(te instanceof TileEntityChest))
{
return stack;
}
stack.setCount(InventoryUtils.removeFromInventory((TileEntityChest) te, stack));
return stack;
});
parser.registerFunction("block.grow", (sc, in) ->
{
Location l1 = (Location) in[0].get(sc);
World w = l1.getWorld();
BlockPos pos1 = l1.getBlockPos();
BlockPos pos2 = ((Location) in[1].get(sc)).getBlockPos();
int x = Math.min(pos1.getX(), pos2.getX());
int endX = Math.max(pos1.getX(), pos2.getX());
int y = Math.min(pos1.getY(), pos2.getY());
int endY = Math.max(pos1.getY(), pos2.getY());
int z = Math.min(pos1.getZ(), pos2.getZ());
int endZ = Math.max(pos1.getZ(), pos2.getZ());
if(endX - x > 50 || endY - y > 50 || endZ - z > 50)
{
throw new IllegalArgumentException("uhh, that area seems way to big for growing plants");
}
BlockPos relative;
IBlockState state;
for(; x <= endX; x++)
{
for(; y <= endY; y++)
{
for(; z <= endZ; z++)
{
relative = new BlockPos(x, y, z);
state = w.getBlockState(relative);
if(state.getBlock() instanceof BlockCrops)
{
w.setBlockState(relative, state.withProperty(BlockCrops.AGE, 7));
}
}
}
}
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Event-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("event.addmovedata", (sc, in) -> CustomEventCaller.registerMoveData(new PlayerMoveData(
sc, (Location) in[0].get(sc), (Location) in[1].get(sc), in[2].getInt(sc), in[3].getInt(sc))));
parser.registerFunction("event.removemovedata", (sc, in) ->
{
CustomEventCaller.removeMoveData(in[0].getInt(sc));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Skill-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("skill.register", (sc, in) ->
{
KajetansMod.skills.registerSkill(in[0].getInt(sc), (ItemStack) in[1].get(sc), Effect.valueOf(in[2].getString(sc)),
in[3].getString(sc), in[4].getString(sc), in[5].getInt(sc), in[6].getInt(sc), in[7].getInt(sc), in[8].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("skill.clear", (sc, in) -> {
KajetansMod.skills.clearSkills(); return Void.TYPE; });
parser.registerFunction("skill.getactive", (sc, in) ->
{
in[0].set(sc, KajetansMod.jobs.getActiveSkills((EntityPlayer) in[1].get(sc)));
return Void.TYPE;
});
parser.registerFunction("skill.getid", (sc, in) -> ((LeveledSkill) in[0].get(sc)).getId());
parser.registerFunction("skill.fromid", (sc, in) ->
{
Skill skill = KajetansMod.skills.getSkill(in[0].getInt(sc));
if(skill == null)
{
return null;
}
byte level = (byte) EffectUtils.getEffectLevel((EntityPlayer) in[1].get(sc), skill.getEffect());
if(level <= 0)
{
return null;
}
return new LeveledSkill(skill, level);
});
parser.registerFunction("skill.getstack", (sc, in) -> ((LeveledSkill) in[0].get(sc)).getItemStack());
parser.registerFunction("skill.use", (sc, in) ->
{
((LeveledSkill) in[0].get(sc)).useEffect((EntityPlayerMP) in[1].get(sc));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Job-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("job.getlevel", (sc, in) -> new Fraction(KajetansMod.jobs.getLevel((EntityPlayer) in[0].get(sc), in[1].getFraction(sc).byteValue())));
parser.registerFunction("job.addlevel", (sc, in) ->
{
KajetansMod.jobs.addLevel((EntityPlayer) in[0].get(sc), in[1].getFraction(sc).byteValue(), in[2].getFraction(sc).byteValue());
return Void.TYPE;
});
parser.registerFunction("job.setlevel", (sc, in) ->
{
KajetansMod.jobs.setLevel((EntityPlayer) in[0].get(sc), in[1].getFraction(sc).byteValue(), in[2].getFraction(sc).byteValue());
return Void.TYPE;
});
parser.registerFunction("job.getxp", (sc, in) -> new Fraction(KajetansMod.jobs.getXP((EntityPlayer) in[0].get(sc), in[1].getFraction(sc).byteValue())));
parser.registerFunction("job.addxp", (sc, in) ->
{
KajetansMod.jobs.addXP((EntityPlayer) in[0].get(sc), in[1].getFraction(sc).byteValue(), in[2].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("job.setxp", (sc, in) ->
{
KajetansMod.jobs.setXP((EntityPlayer) in[0].get(sc), in[1].getFraction(sc).byteValue(), in[2].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("job.registerjob", (sc, in) ->
{
KajetansMod.jobs.registerJob(in[0].getFraction(sc).byteValue(), SnuviUtils.connect(sc, in, 1));
return Void.TYPE;
});
parser.registerFunction("job.registerrecipe", (sc, in) ->
{
KajetansMod.jobs.registerRecipe(in[0].getFraction(sc).byteValue(), ItemStackUtils.getItem(in[1].getString(sc)), in[2].getFraction(sc).byteValue());
return Void.TYPE;
});
parser.registerFunction("job.registermaterial", (sc, in) ->
{
KajetansMod.jobs.registerPreferedBlock(in[0].getFraction(sc).byteValue(), Block.getBlockFromName(in[1].getString(sc)));
return Void.TYPE;
});
parser.registerFunction("job.registerskill", (sc, in) ->
{
KajetansMod.jobs.registerSkill(in[0].getFraction(sc).byteValue(), KajetansMod.skills.getSkill(in[1].getInt(sc)), in[2].getFraction(sc).byteValue(), in[3].getFraction(sc).byteValue());
return Void.TYPE;
});
parser.registerFunction("job.getamount", (sc, in) -> new Fraction(KajetansMod.jobs.getNumberOfJobs()));
parser.registerFunction("job.getname", (sc, in) -> KajetansMod.jobs.getJobName(in[0].getFraction(sc).byteValue()));
parser.registerFunction("job.geteffectlevel", (sc, in) -> new Fraction(EffectUtils.getEffectLevel((EntityPlayer) in[0].get(sc), me.km.effects.Effect.valueOf(in[1].getString(sc)))));
parser.registerFunction("job.hasjob", (sc, in) -> KajetansMod.jobs.hasJob((EntityPlayer) in[0].get(sc), in[1].getFraction(sc).byteValue()));
parser.registerFunction("job.hasrecipe", (sc, in) -> KajetansMod.jobs.hasRecipe((EntityPlayer) in[0].get(sc), ItemStackUtils.getItem(in[1].getString(sc))));
parser.registerFunction("job.getjobs", (sc, in) ->
{
in[0].set(sc, KajetansMod.jobs.getJobs((EntityPlayer) in[1].get(sc)).stream().map(b -> new Fraction(b)).collect(Collectors.toList()));
return Void.TYPE;
});
parser.registerFunction("job.isregmaterial", (sc, in) -> KajetansMod.jobs.isPreferedMaterial((EntityPlayer) in[0].get(sc),Block.getBlockFromName(in[1].getString(sc))));
parser.registerFunction("job.setjob", (sc, in) ->
{
KajetansMod.jobs.setJob((EntityPlayer) in[0].get(sc), in[1].getFraction(sc).byteValue(), in[2].getBoolean(sc));
return Void.TYPE;
});
parser.registerFunction("job.reset", (sc, in) ->
{
KajetansMod.jobs.resetAll();
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Entity - Befehle
// ---------------------------------------------------------------------
parser.registerFunction("entity.getlocation", (sc, in) -> new Location((Entity) in[0].get(sc)));
parser.registerFunction("entity.damage", (sc, in) ->
{
// entity.damage(entity, damagefloat, DamageSource);
if(in.length >= 3)
{
((EntityLivingBase) in[0].get(sc)).attackEntityFrom((DamageSource) in[2].get(sc), in[1].getFraction(sc).floatValue());
return Void.TYPE;
}
((EntityLivingBase) in[0].get(sc)).attackEntityFrom(DamageSource.GENERIC, in[1].getFraction(sc).floatValue());
return Void.TYPE;
});
parser.registerFunction("entity.getdamagesource", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityLivingBase)
{
EntityLivingBase ent = (EntityLivingBase) o;
DamageSource ds;
if(ent instanceof EntityPlayer)
{
ds = DamageSource.causePlayerDamage((EntityPlayer) ent);
}
else
{
ds = DamageSource.causeMobDamage(ent);
}
if(in[1].getBoolean(sc))
{
ds.setDamageAllowedInCreativeMode();
}
if(in[2].getBoolean(sc))
{
ds.setDamageBypassesArmor();
}
if(in[3].getBoolean(sc))
{
ds.setDamageIsAbsolute();
}
if(in[4].getBoolean(sc))
{
ds.setExplosion();
}
if(in[5].getBoolean(sc))
{
ds.setFireDamage();
}
if(in[6].getBoolean(sc))
{
ds.setMagicDamage();
}
if(in[7].getBoolean(sc))
{
ds.setProjectile();
}
return ds;
}
switch(o.toString())
{
case "IN_FIRE": return DamageSource.IN_FIRE;
case "LIGHTNING_BOLT": return DamageSource.LIGHTNING_BOLT;
case "ON_FIRE": return DamageSource.ON_FIRE;
case "LAVA": return DamageSource.LAVA;
case "HOT_FLOOR": return DamageSource.HOT_FLOOR;
case "IN_WALL": return DamageSource.IN_WALL;
case "CRAMMING": return DamageSource.CRAMMING;
case "DROWN": return DamageSource.DROWN;
case "STARVE": return DamageSource.STARVE;
case "CACTUS": return DamageSource.CACTUS;
case "FALL": return DamageSource.FALL;
case "FLY_INTO_WALL": return DamageSource.FLY_INTO_WALL;
case "OUT_OF_WORLD": return DamageSource.OUT_OF_WORLD;
case "GENERIC": return DamageSource.GENERIC;
case "MAGIC": return DamageSource.MAGIC;
case "WITHER": return DamageSource.WITHER;
case "ANVIL": return DamageSource.ANVIL;
case "FALLING_BLOCK": return DamageSource.FALLING_BLOCK;
case "DRAGON_BREATH": return DamageSource.DRAGON_BREATH;
case "FIREWORKS": return DamageSource.FIREWORKS;
case "THORNS": return DamageSource.causeThornsDamage((Entity) in[1].get(sc));
}
return DamageSource.GENERIC;
});
parser.registerFunction("entity.gethealth", (sc, in) -> Fraction.fromDouble(((EntityLivingBase) in[0].get(sc)).getHealth()));
parser.registerFunction("entity.sethealth", (sc, in) ->
{
((EntityLivingBase) in[0].get(sc)).setHealth(in[1].getFraction(sc).floatValue());
return Void.TYPE;
});
parser.registerFunction("entity.setname", (sc, in) ->
{
Entity ent = (Entity) in[0].get(sc);
ent.setCustomNameTag(in[1].getString(sc));
if(in.length >= 3)
{
ent.setAlwaysRenderNameTag(in[2].getBoolean(sc));
return Void.TYPE;
}
ent.setAlwaysRenderNameTag(true);
return Void.TYPE;
});
parser.registerFunction("entity.getname", (sc, in) -> ((Entity) in[0].get(sc)).getDisplayName().getUnformattedText());
parser.registerFunction("entity.throw", (sc, in) ->
{
Utils.setVelocity((Entity) in[0].get(sc), in[1].getDouble(sc), in[2].getDouble(sc), in[3].getDouble(sc));
return Void.TYPE;
});
parser.registerFunction("entity.teleport", (sc, in) ->
{
Utils.teleportEntity((Entity) in[0].get(sc), (Location) in[1].get(sc));
return Void.TYPE;
});
parser.registerFunction("entity.setequip", (sc, in) ->
{
EntityLivingBase liv = (EntityLivingBase) in[0].get(sc);
ItemStack stack = ((ItemStack) in[2].get(sc)).copy();
switch(in[1].getString(sc))
{
case "hand":
liv.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, stack);
return Void.TYPE;
case "head":
liv.setItemStackToSlot(EntityEquipmentSlot.HEAD, stack);
return Void.TYPE;
case "chest":
liv.setItemStackToSlot(EntityEquipmentSlot.CHEST, stack);
return Void.TYPE;
case "legs":
liv.setItemStackToSlot(EntityEquipmentSlot.LEGS, stack);
return Void.TYPE;
case "feet":
liv.setItemStackToSlot(EntityEquipmentSlot.FEET, stack);
return Void.TYPE;
case "offhand":
liv.setItemStackToSlot(EntityEquipmentSlot.OFFHAND, stack);
}
return Void.TYPE;
});
parser.registerFunction("entity.getequip", (sc, in) ->
{
EntityLivingBase liv = (EntityLivingBase) in[0].get(sc);
switch(in[1].getString(sc))
{
case "hand":
return liv.getItemStackFromSlot(EntityEquipmentSlot.MAINHAND);
case "head":
return liv.getItemStackFromSlot(EntityEquipmentSlot.HEAD);
case "chest":
return liv.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
case "legs":
return liv.getItemStackFromSlot(EntityEquipmentSlot.LEGS);
case "feet":
return liv.getItemStackFromSlot(EntityEquipmentSlot.FEET);
case "offhand":
return liv.getItemStackFromSlot(EntityEquipmentSlot.OFFHAND);
}
return ItemStack.EMPTY;
});
parser.registerFunction("entity.removeall", (sc, in) ->
{
Class<? extends Entity> c = (Class<? extends Entity>) getClass(in[0].getString(sc));
if(c == Entity.class)
{
return Void.TYPE;
}
Location l = (Location) in[1].get(sc);
Utils.getEntities(l.getWorld(), l.getX(), l.getY(), l.getZ(), in[2].getDouble(sc), c).stream().forEach(ent ->
{
ent.setDead();
});
return Void.TYPE;
});
parser.registerFunction("entity.remove", (sc, in) ->
{
((Entity) in[0].get(sc)).setDead();
return Void.TYPE;
});
parser.registerFunction("entity.setinvulnerable", (sc, in) ->
{
((Entity) in[0].get(sc)).setEntityInvulnerable(in[1].getBoolean(sc));
return Void.TYPE;
});
parser.registerFunction("entity.setsilent", (sc, in) ->
{
((Entity) in[0].get(sc)).setSilent(in[1].getBoolean(sc));
return Void.TYPE;
});
parser.registerFunction("entity.hide", (sc, in) ->
{
((Entity) in[0].get(sc)).setInvisible(true);
return Void.TYPE;
});
parser.registerFunction("entity.show", (sc, in) ->
{
((Entity) in[0].get(sc)).setInvisible(false);
return Void.TYPE;
});
parser.registerFunction("entity.ride", (sc, in) ->
{
((Entity) in[0].get(sc)).startRiding(((Entity) in[1].get(sc)));
return Void.TYPE;
});
parser.registerFunction("entity.addeffect", (sc, in) ->
{
EntityLivingBase base = (EntityLivingBase) in[0].get(sc);
Potion potion = Potion.getPotionFromResourceLocation(in[1].getString(sc));
if(base == null) // doing this only to prevent EffectUtils.addPotionTo doing shit
{
throw new NullPointerException("null not allowed for entity");
}
else if(potion == null)
{
throw new NullPointerException("potion does not exist");
}
EffectUtils.addPotionTo(base, potion, in[2].getInt(sc), in[3].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("entity.haseffect", (sc, in) -> ((EntityLivingBase) in[0].get(sc)).isPotionActive(Potion.getPotionFromResourceLocation(in[1].getString(sc))));
parser.registerFunction("entity.goto", (sc, in) ->
{
Location l = (Location) in[1].get(sc);
PathfinderUtils.walkTo((EntityLiving) in[0].get(sc), l.getX(), l.getY(), l.getZ(), in[2].getDouble(sc));
return Void.TYPE;
});
parser.registerFunction("entity.explode", (sc, in) ->
{
((EntityCreeper) in[0].get(sc)).ignite();
return Void.TYPE;
});
parser.registerFunction("entity.spawnitemframe", (sc, in) ->
{
Location l = ((Location) in[0].get(sc));
EntityItemFrame frame = new EntityItemFrame(l.getWorld(), l.getBlockPos(), EnumFacing.byName(in[1].getString(sc)));
frame.setDisplayedItem(((ItemStack) in[2].get(sc))); // cppy happens in internals
return Void.TYPE;
});
parser.registerFunction("entity.getitemframe", (sc, in) -> ((EntityItemFrame) in[0].get(sc)).getDisplayedItem());
parser.registerFunction("entity.get", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
return Utils.getEntity(l.getWorld(), l.getX(), l.getY(), l.getZ(), in[1].getDouble(sc), getClass(in[2].getString(sc)));
});
parser.registerFunction("entity.getpotiontype", (sc, in) -> PotionUtils.getPotionFromItem(((EntityPotion) in[0].get(sc)).getPotion()).getRegistryName().toString());
parser.registerFunction("entity.setgravity", (sc, in) ->
{
((Entity) in[0].get(sc)).setNoGravity(!in[1].getBoolean(sc));
return Void.TYPE;
});
parser.registerFunction("entity.iswet", (sc, in) -> ((Entity) in[0].get(sc)).isWet());
parser.registerFunction("entity.setpickupdelay", (sc, in) ->
{
((EntityItem) in[0].get(sc)).setPickupDelay(in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("entity.setage", (sc, in) ->
{
ReflectionUtils.setAge((EntityItem) in[0].get(sc), in[1].getInt(sc));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Status-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("status.getmana", (sc, in) -> new Fraction(EnvironmentAPI.getMana(((EntityPlayer) in[0].get(sc)))));
parser.registerFunction("status.getcold", (sc, in) -> new Fraction(EnvironmentAPI.getCold(((EntityPlayer) in[0].get(sc)))));
parser.registerFunction("status.getenergy", (sc, in) -> new Fraction(EnvironmentAPI.getEnergy(((EntityPlayer) in[0].get(sc)))));
parser.registerFunction("status.getthirst", (sc, in) -> new Fraction(EnvironmentAPI.getThirst(((EntityPlayer) in[0].get(sc)))));
parser.registerFunction("status.changemange", (sc, in) ->
{
EnvironmentAPI.changeMana(((EntityPlayer) in[0].get(sc)), in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("status.changecold", (sc, in) ->
{
EnvironmentAPI.changeCold(((EntityPlayer) in[0].get(sc)), in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("status.changeenergie", (sc, in) ->
{
EnvironmentAPI.changeEnergy(((EntityPlayer) in[0].get(sc)), in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("status.changethirst", (sc, in) ->
{
EnvironmentAPI.changeThirst(((EntityPlayer) in[0].get(sc)), in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("status.resetmana", (sc, in) ->
{
EnvironmentAPI.resetMana(((EntityPlayer) in[0].get(sc)));
return Void.TYPE;
});
parser.registerFunction("status.resetcold", (sc, in) ->
{
EnvironmentAPI.resetCold(((EntityPlayer) in[0].get(sc)));
return Void.TYPE;
});
parser.registerFunction("status.resetenergy", (sc, in) ->
{
EnvironmentAPI.resetEnergy(((EntityPlayer) in[0].get(sc)));
return Void.TYPE;
});
parser.registerFunction("status.resetthirst", (sc, in) ->
{
EnvironmentAPI.resetThirst(((EntityPlayer) in[0].get(sc)));
return Void.TYPE;
});
parser.registerFunction("status.gettemperature", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
return new Fraction(EnvironmentAPI.getTemperature(l.getWorld(), l.getBlockPos()));
});
// ---------------------------------------------------------------------
// GMap-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("gmap.removeall", (sc, in) ->
{
KajetansMod.scripts.getDataBank(ScriptBank.class).removeMap(in[0].getString(sc));
return Void.TYPE;
});
parser.registerFunction("gmap.add", (sc, in) ->
{
KajetansMod.scripts.getDataBank(ScriptBank.class).addMapElement(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc));
return Void.TYPE;
});
parser.registerFunction("gmap.remove", (sc, in) ->
{
KajetansMod.scripts.getDataBank(ScriptBank.class).removeMapElement(in[0].getString(sc), in[1].getString(sc));
return Void.TYPE;
});
parser.registerFunction("gmap.totable", (sc, in) ->
{
in[0].set(sc, KajetansMod.scripts.getDataBank(ScriptBank.class).getGlobalMapAsTable(in[1].getString(sc)));
return Void.TYPE;
});
parser.registerFunction("gmap.get", (sc, in) -> KajetansMod.scripts.getDataBank(ScriptBank.class).getMapValue(in[0].getString(sc), in[1].getString(sc)));
parser.registerFunction("gmap.getordefault", (sc, in) ->
{
Object o = KajetansMod.scripts.getDataBank(ScriptBank.class).getMapValue(in[0].getString(sc), in[1].getString(sc));
if(o == null)
{
return in[2].get(sc);
}
return o;
});
// ---------------------------------------------------------------------
// GDMap-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("gdmap.removeall", (sc, in) ->
{
KajetansMod.scripts.getDataBank(ScriptBank.class).removeDualMap(in[0].getString(sc));
return Void.TYPE;
});
parser.registerFunction("gdmap.add", (sc, in) ->
{
KajetansMod.scripts.getDataBank(ScriptBank.class).addDualMapElement(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc), in[3].getString(sc));
return Void.TYPE;
});
parser.registerFunction("gdmap.remove", (sc, in) ->
{
KajetansMod.scripts.getDataBank(ScriptBank.class).removeDualMapElement(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc));
return Void.TYPE;
});
parser.registerFunction("gdmap.totable", (sc, in) ->
{
in[0].set(sc, KajetansMod.scripts.getDataBank(ScriptBank.class).getGlobalDualMapAsTable(in[1].getString(sc), in[2].getString(sc)));
return Void.TYPE;
});
parser.registerFunction("gdmap.get", (sc, in) ->
{
return KajetansMod.scripts.getDataBank(ScriptBank.class).getDualMapValue(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc));
});
parser.registerFunction("gdmap.getordefault", (sc, in) ->
{
Object o = KajetansMod.scripts.getDataBank(ScriptBank.class).getDualMapValue(in[0].getString(sc), in[1].getString(sc), in[2].getString(sc));
if(o == null)
{
return in[3].get(sc);
}
return o;
});
// ---------------------------------------------------------------------
// Table-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("table.print", (sc, in) ->
{
Table t = (Table) in[1].get(sc);
if(t.getSize() >= 60)
{
throw new IllegalArgumentException("table is too big");
}
Object group = in[0].get(sc);
TableAPI.getTable(t, in[2].getInt(sc), in[3].getString(sc), in.length >= 5 ? in[4].getBoolean(sc) : false)
.forEach(s -> sendMessageToGroup(group, sc, new TextComponentString(s)));
return Void.TYPE;
});
parser.registerFunction("table.new", (sc, in) ->
{
in[0].set(sc, new Table(in[1].getInt(sc)));
return Void.TYPE;
});
parser.registerFunction("table.frommap", (sc, in) ->
{
in[0].set(sc, new Table((Map<Object, Object>) in[1].get(sc)));
return Void.TYPE;
});
parser.registerAlias("table.frommap", "map.totable");
parser.registerFunction("table.sort", (sc, in) ->
{
((Table) in[0].get(sc)).sort();
return Void.TYPE;
});
parser.registerFunction("table.reverse", (sc, in) ->
{
((Table) in[0].get(sc)).reverse();
return Void.TYPE;
});
parser.registerFunction("table.shuffle", (sc, in) ->
{
((Table) in[0].get(sc)).shuffle();
return Void.TYPE;
});
parser.registerFunction("table.clear", (sc, in) ->
{
((Table) in[0].get(sc)).clear();
return Void.TYPE;
});
parser.registerFunction("table.addrow", (sc, in) ->
{
Object[] o = new Object[in.length - 1];
for(int i = 1; i < in.length; i++)
{
o[i - 1] = in[i].get(sc);
}
((Table) in[0].get(sc)).addRow(o);
return Void.TYPE;
});
parser.registerFunction("table.removerow", (sc, in) ->
{
((Table) in[0].get(sc)).removeRow(in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("table.get", (sc, in) -> ((Table) in[0].get(sc)).getElement(in[1].getInt(sc), in[2].getInt(sc)));
parser.registerFunction("table.set", (sc, in) ->
{
((Table) in[0].get(sc)).setElement(in[1].getInt(sc), in[2].getInt(sc), in[3].get(sc));
return Void.TYPE;
});
parser.registerFunction("table.getindexof", (sc, in) -> new Fraction(((Table) in[0].get(sc)).getIndexOf(in[1].get(sc))));
parser.registerFunction("table.setsortcolumn", (sc, in) ->
{
((Table) in[0].get(sc)).setSortColumn(in[1].getInt(sc));
return Void.TYPE;
});
parser.registerFunction("table.getsize", (sc, in) -> new Fraction(((Table) in[0].get(sc)).getSize()));
// ---------------------------------------------------------------------
// Plot-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("plot.hastag", (sc, in) -> KajetansMod.plots.getDataBank(ProtectionBank.class).hasTag(((Location) in[0].get(sc)).getWorld(), ((Location) in[0].get(sc)).getBlockPos(), in[1].getString(sc)));
parser.registerFunction("plot.add", (sc, in) ->
{
Location l1 = (Location) in[0].get(sc);
Location l2 = (Location) in[1].get(sc);
BlockPos pos1 = l1.getBlockPos();
BlockPos pos2 = l2.getBlockPos();
KajetansMod.plots.getDataBank(ProtectionBank.class).addPlot(Math.min(pos1.getX(), pos2.getX()),
Math.min(pos1.getY(), pos2.getY()),
Math.min(pos1.getZ(), pos2.getZ()),
Math.max(pos1.getX(), pos2.getX()),
Math.max(pos1.getY(), pos2.getY()),
Math.max(pos1.getZ(), pos2.getZ()),
ModDimensions.getWorldName(l1.getWorld()), null, in[2].getString(sc));
return Void.TYPE;
});
parser.registerFunction("plot.getids", (sc, in) ->
{
Location l = (Location) in[1].get(sc);
in[0].set(sc, KajetansMod.plots.getDataBank(ProtectionBank.class).getRegionIds(l.getWorld(),
l.getBlockPos()).stream().map(o -> new Fraction(Integer.parseInt(o.toString()))).collect(Collectors.toSet()));
return Void.TYPE;
});
parser.registerFunction("plot.canbuild", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
return KajetansMod.plots.getDataBank(ProtectionBank.class).canBuild(l.getWorld(), l.getBlockPos(), (EntityPlayer) in[1].get(sc));
});
parser.registerFunction("plot.getname", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
KajetansMod.plots.getDataBank(ProtectionBank.class).getFirstRegionName(l.getWorld(), l.getBlockPos());
return Void.TYPE;
});
parser.registerFunction("plot.doesintersect", (sc, in) ->
{
Location l1 = (Location) in[0].get(sc);
Location l2 = (Location) in[1].get(sc);
int x1 = (int) Math.min(l1.getX(), l2.getX());
int x2 = (int) Math.max(l1.getX(), l2.getX());
int y1 = (int) Math.min(l1.getY(), l2.getY());
int y2 = (int) Math.max(l1.getY(), l2.getY());
int z1 = (int) Math.min(l1.getZ(), l2.getZ());
int z2 = (int) Math.max(l1.getZ(), l2.getZ());
return KajetansMod.plots.getDataBank(ProtectionBank.class).isPlotOverlapping(x1, y1, z1, x2, y2, z2, l1.getWorld());
});
// ---------------------------------------------------------------------
// Script-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("script.playerstolist", (sc, in) ->
{
in[0].set(sc, new ArrayList<>(KajetansMod.scripts.getPlayerList(sc.getId())));
return Void.TYPE;
});
parser.registerFunction("script.getplayeramount", (sc, in) -> new Fraction(KajetansMod.scripts.getPlayerList(sc.getId()).size()));
parser.registerFunction("script.start", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityPlayer)
{
String[] names = new String[in.length - 1];
for(int i = 1; i < in.length; i++)
{
names[i - 1] = in[i].getString(sc);
}
return KajetansMod.scripts.startPlayerScript((EntityPlayer) in[0].get(sc), names);
}
String[] names = new String[in.length];
names[0] = o.toString();
for(int i = 1; i < in.length; i++)
{
names[i - 1] = in[i].getString(sc);
}
KajetansMod.scripts.startScript(names);
return true;
});
parser.registerFunction("script.get", (sc, in) -> KajetansMod.scripts.getScript(in[0].getString(sc)));
parser.registerFunction("script.join", (sc, in) -> KajetansMod.scripts.registerPlayer((Script) in[0].get(sc), (EntityPlayer) in[1].get(sc)));
parser.registerFunction("script.kick", (sc, in) -> KajetansMod.scripts.unregisterPlayer((EntityPlayer) in[0].get(sc)));
parser.registerFunction("script.getleader", (sc, in) ->
{
List<EntityPlayer> players = KajetansMod.scripts.getPlayerList(sc.getId());
if(players.isEmpty())
{
return null;
}
return players.get(0);
});
// ---------------------------------------------------------------------
// Scoreboard-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("sb.add", (sc, in) ->
{
int id = in[1].getInt(sc);
String message = SnuviUtils.connect(sc, in, 2);
doForGroup(in[0].get(sc), sc, p -> KajetansMod.scoreboard.getScoreboard((EntityPlayerMP) p).addText(id, message));
return Void.TYPE;
});
parser.registerFunction("sb.remove", (sc, in) ->
{
int id = in[1].getInt(sc);
doForGroup(in[0].get(sc), sc, p -> KajetansMod.scoreboard.getScoreboard((EntityPlayerMP) p).removeText(id));
return Void.TYPE;
});
parser.registerFunction("sb.reset", (sc, in) ->
{
doForGroup(in[0].get(sc), sc, p -> KajetansMod.scoreboard.resetScoreboard((EntityPlayerMP) p));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Display-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("display.add", (sc, in) ->
{
byte id = in[1].getFraction(sc).byteValue();
String message = SnuviUtils.connect(sc, in, 2);
doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToDisplay((EntityPlayerMP) p, (byte) 1, id, message));
return Void.TYPE;
});
parser.registerFunction("display.remove", (sc, in) ->
{
byte id = in[1].getFraction(sc).byteValue();
doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToDisplay((EntityPlayerMP) p, (byte) 2, id, ""));
return Void.TYPE;
});
parser.registerFunction("display.reset", (sc, in) ->
{
doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToDisplay((EntityPlayerMP) p, (byte) 3, (byte) -1, ""));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Head-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("head.add", (sc, in) ->
{
byte id = in[1].getFraction(sc).byteValue();
String name = in[2].getString(sc);
int x = in[3].getInt(sc);
int y = in[4].getInt(sc);
byte scale = in[5].getFraction(sc).byteValue();
doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToHead((EntityPlayerMP) p, (byte) 1, id, name, x, y, scale));
return Void.TYPE;
});
parser.registerFunction("head.remove", (sc, in) ->
{
byte id = in[1].getFraction(sc).byteValue();
doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToHead((EntityPlayerMP) p, (byte) 2, id, "", -1, -1, (byte) -1));
return Void.TYPE;
});
parser.registerFunction("head.reset", (sc, in) ->
{
doForGroup(in[0].get(sc), sc, p -> ModPacketHandler.sendToHead((EntityPlayerMP) p, (byte) 3, (byte) -1, "", -1, -1, (byte) -1));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Effect-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("effect.playsound", (sc, in) ->
{
Location l = (Location) in[0].get(sc);
Vec3d v = l.getPos();
EffectUtils.playSound((WorldServer) l.getWorld(), SoundEvent.REGISTRY.getObject(new ResourceLocation(in[1].getString(sc))), SoundCategory.MASTER, v.x, v.y, v.z);
return Void.TYPE;
});
parser.registerFunction("effect.play", (sc, in) ->
{
Location l = ((Location) in[0].get(sc));
EffectUtils.spawnParticle((WorldServer) l.getWorld(), EnumParticleTypes.getByName(in[1].getString(sc)), l.getX() + 0.5, l.getY() + 0.5, l.getZ() + 0.5, in[2].getInt(sc));
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Inventory-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("inv.new", (sc, in) ->
{
in[0].set(sc, new SnuviInventory(in[2].getString(sc), in[1].getInt(sc), inventoryIds++));
return Void.TYPE;
});
parser.registerFunction("inv.newdynamic", (sc, in) ->
{
in[0].set(sc, new SnuviInventory(in[2].getString(sc), in[1].getString(sc), inventoryIds++));
return Void.TYPE;
});
parser.registerFunction("inv.getid", (sc, in) ->
{
return new Fraction(((SnuviInventory) in[0].get(sc)).getId());
});
parser.registerFunction("inv.loadblock", (sc, in) ->
{
Location l = (Location) in[1].get(sc);
TileEntityChest chest = (TileEntityChest) l.getWorld().getTileEntity(l.getBlockPos());
int size = chest.getSizeInventory();
if(size % 9 != 0)
{
size /= 9;
size++;
size *= 9;
}
SnuviInventory inv = new SnuviInventory(in[2].getString(sc), size, inventoryIds++);
for(int i = 0; i < chest.getSizeInventory(); i++)
{
inv.setInventorySlotContents(i, chest.getStackInSlot(i).copy());
}
in[0].set(sc, inv);
return Void.TYPE;
});
parser.registerFunction("inv.setitem", (sc, in) ->
{
((IInventory) in[0].get(sc)).setInventorySlotContents(in[1].getInt(sc), (ItemStack) in[2].get(sc));
return Void.TYPE;
});
parser.registerFunction("inv.getitem", (sc, in) -> ((IInventory) in[0].get(sc)).getStackInSlot(in[1].getInt(sc)));
parser.registerFunction("inv.open", (sc, in) ->
{
new ScriptInventoryHolder((SnuviInventory) in[0].get(sc), (EntityPlayerMP) in[1].get(sc), sc).openForPlayer();
return Void.TYPE;
});
parser.registerFunction("inv.close", (sc, in) ->
{
EntityPlayer p = (EntityPlayer) in[0].get(sc);
if(p.openContainer instanceof CustomContainer)
{
((CustomContainer) p.openContainer).closeSafe();
}
else
{
p.closeScreen();
}
return Void.TYPE;
});
parser.registerFunction("inv.update", (sc, in) ->
{
EntityPlayerMP p = (EntityPlayerMP) in[0].get(sc);
NonNullList<ItemStack> list = NonNullList.<ItemStack>create();
int size = p.openContainer.inventorySlots.size();
for(int j = 0; j < size; j++)
{
ItemStack itemstack = p.openContainer.inventorySlots.get(j).getStack();
list.add(itemstack.isEmpty() ? ItemStack.EMPTY : itemstack);
}
p.sendAllContents(p.openContainer, list);
return Void.TYPE;
});
// ---------------------------------------------------------------------
// Read-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("read.player", (sc, in) ->
{
try
{
return Utils.getPlayerByName(in[0].getString(sc));
}
catch(PlayerNotFoundException ex)
{
return null;
}
});
parser.registerFunction("read.location", (sc, in) -> new Location(in[0].getString(sc)));
parser.registerFunction("read.item", (sc, in) ->
{
String s = in[0].getString(sc);
if(s.startsWith("{"))
{
String left = SnuviUtils.connect(sc, in, 1);
return ItemStackUtils.getStackFromNbtString((s + left).replace('\'', '"'));
}
if(s.indexOf(':') == -1)
{
s = "minecraft:" + s;
}
Item item = ItemStackUtils.getItem(s);
int amount = in.length >= 2 ? in[1].getInt(sc) : 1;
int meta = in.length >= 3 ? in[2].getInt(sc) : 0;
ItemStack stack = new ItemStack(item, amount, meta);
if(in.length >= 4)
{
stack.setStackDisplayName(in[3].getString(sc));
}
if(in.length >= 5)
{
for(int i = 4; i < in.length; i++)
{
ItemStackUtils.addLore(stack, in[i].getString(sc));
}
}
return stack;
});
parser.registerFunction("read.spawnmob", (sc, in) -> NBTUtils.fromString(SnuviUtils.connect(sc, in, 1).replace('\'', '"'), (Location) in[0].get(sc)));
// ---------------------------------------------------------------------
// Text-Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("text.location", (sc, in) -> ((Location) in[0].get(sc)).toString());
parser.registerFunction("text.locationblock", (sc, in) -> ((Location) in[0].get(sc)).toBlockString());
parser.registerFunction("text.item", (sc, in) -> ItemStackUtils.getNbtString((ItemStack) in[0].get(sc)));
parser.registerFunction("text.click", (sc, in) -> NBTUtils.getClickable(in[0].get(sc), in[1].getString(sc)));
parser.registerFunction("text.hover", (sc, in) -> NBTUtils.getHoverable(in[0].get(sc), in[1].getString(sc)));
// ---------------------------------------------------------------------
// Ohne Bibliothek
// ---------------------------------------------------------------------
parser.registerFunction("getglobalvar", (sc, in) ->
{
Object o = in[0].get(sc);
if(in.length == 2)
{
if(o instanceof EntityPlayer)
{
return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), ((EntityPlayer) o).getUniqueID().toString());
}
else if(o.equals("SERVER"))
{
return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), "-1");
}
return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), o.toString());
}
if(o instanceof EntityPlayer)
{
return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), ((EntityPlayer) o).getUniqueID().toString(), in[2].get(sc));
}
else if(o.equals("SERVER"))
{
return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), "-1", in[2].get(sc));
}
return KajetansMod.scripts.getDataBank(ScriptBank.class).getVar(in[1].getString(sc), o.toString(), in[2].get(sc));
});
parser.registerAlias("getglobalvar", "ggv");
parser.registerFunction("setglobalvar", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityPlayer)
{
KajetansMod.scripts.getDataBank(ScriptBank.class).setVar(in[2].getString(sc), in[1].getString(sc), ((EntityPlayer) o).getUniqueID().toString());
}
else if(o.equals("SERVER"))
{
KajetansMod.scripts.getDataBank(ScriptBank.class).setVar(in[2].getString(sc), in[1].getString(sc), "-1");
}
else
{
KajetansMod.scripts.getDataBank(ScriptBank.class).setVar(in[2].getString(sc), in[1].getString(sc), o.toString());
}
return Void.TYPE;
});
parser.registerAlias("setglobalvar", "sgv");
parser.registerFunction("delglobalvar", (sc, in) ->
{
Object o = in[0].get(sc);
if(o instanceof EntityPlayer)
{
KajetansMod.scripts.getDataBank(ScriptBank.class).deleteVar(in[1].getString(sc), ((EntityPlayer) o).getUniqueID().toString());
}
else if(o.equals("SERVER"))
{
KajetansMod.scripts.getDataBank(ScriptBank.class).deleteVar(in[1].getString(sc), "-1");
}
else
{
KajetansMod.scripts.getDataBank(ScriptBank.class).deleteVar(in[1].getString(sc), o.toString());
}
return Void.TYPE;
});
parser.registerFunction("msg", (sc, in) ->
{
sendMessageToGroup(in[0].get(sc), sc, NBTUtils.concat(sc, 1, in));
return Void.TYPE;
});
parser.registerFunction("removeformat", (sc, in) -> SnuviUtils.connect(sc, in, 0).replaceAll("§.", ""));
parser.registerFunction("concatspace", (sc, in) -> SnuviUtils.connect(sc, in, " ", 0));
parser.registerFunction("onlyletters", (sc, in) ->
{
for(char c : SnuviUtils.connect(sc, in, 0).toCharArray())
{
if(!Character.isLetter(c))
{
return false;
}
}
return true;
});
parser.registerFunction("command", (sc, in) ->
{
KajetansMod.scheduler.scheduleTask(() -> KajetansMod.server.commandManager.executeCommand(KajetansMod.server, SnuviUtils.connect(sc, in, 0)));
return Void.TYPE;
});
}
private static Class getClass(String s)
{
try
{
return Class.forName(s);
}
catch(ClassNotFoundException ex)
{
throw new IllegalStringException(s);
}
}
// ---------------------------------------------------------------------------------
// Block
// ---------------------------------------------------------------------------------
private static IBlockState getBlockState(Location l)
{
return l.getWorld().getBlockState(l.getBlockPos());
}
// ---------------------------------------------------------------------------------
// Gruppen-Handler
// ---------------------------------------------------------------------------------
public static void doForGroup(Object group, Script sc, Consumer<ICommandSender> c)
{
if(group instanceof String)
{
switch(group.toString())
{
case "all":
KajetansMod.scripts.getPlayerList(sc.getId()).forEach(p -> c.accept(p));
break;
case "online":
KajetansMod.server.getPlayerList().getPlayers().forEach(p -> c.accept(p));
break;
case "dev":
ChatChannel.getDevChannel().forEach((p) -> c.accept(p));
break;
case "server":
c.accept(KajetansMod.server);
break;
default:
c.accept(Utils.getPlayerByName(group.toString()));
break;
}
return;
}
c.accept((EntityPlayer) group);
}
private static void sendMessageToGroup(Object group, Script sc, ITextComponent text)
{
doForGroup(group, sc, p -> p.sendMessage(text));
}
}