refactor terrascript into API, loader, and function addons

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/BinaryNumberFunctionBuilder.java

@@ -0,0 +1,53 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+
+public class BinaryNumberFunctionBuilder implements FunctionBuilder<Function<Number>> {
+
+    private final BiFunction<Number, Number, Number> function;
+
+    public BinaryNumberFunctionBuilder(BiFunction<Number, Number, Number> function) {
+        this.function = function;
+    }
+
+    @Override
+    public Function<Number> build(List<Returnable<?>> argumentList, Position position) {
+        return new Function<Number>() {
+            @Override
+            public ReturnType returnType() {
+                return ReturnType.NUMBER;
+            }
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Number apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+                return function.apply(((Returnable<Number>) argumentList.get(0)).apply(implementationArguments, variableMap), ((Returnable<Number>) argumentList.get(1)).apply(implementationArguments, variableMap));
+            }
+
+            @Override
+            public Position getPosition() {
+                return position;
+            }
+        };
+    }
+
+    @Override
+    public int argNumber() {
+        return 2;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        if(position == 0 || position == 1) return Returnable.ReturnType.NUMBER;
+        return null;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/BiomeFunctionBuilder.java

@@ -0,0 +1,40 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.BiomeFunction;
+import com.dfsek.terra.api.TerraPlugin;
+
+import java.util.List;
+
+public class BiomeFunctionBuilder implements FunctionBuilder<BiomeFunction> {
+    private final TerraPlugin main;
+
+    public BiomeFunctionBuilder(TerraPlugin main) {
+        this.main = main;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public BiomeFunction build(List<Returnable<?>> argumentList, Position position) {
+        return new BiomeFunction(main, (Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 3;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/BlockFunctionBuilder.java

@@ -0,0 +1,70 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.ConstantExpression;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.functions.BlockFunction;
+import com.dfsek.terra.api.TerraPlugin;
+
+import java.util.List;
+import java.util.Map;
+
+public class BlockFunctionBuilder implements FunctionBuilder<BlockFunction> {
+    private final TerraPlugin main;
+
+    public BlockFunctionBuilder(TerraPlugin main) {
+        this.main = main;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public BlockFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+        if(argumentList.size() < 4) throw new ParseException("Expected data", position);
+        Returnable<Boolean> booleanReturnable = new Returnable<Boolean>() {
+            @Override
+            public ReturnType returnType() {
+                return ReturnType.BOOLEAN;
+            }
+
+            @Override
+            public Boolean apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+                return true;
+            }
+
+            @Override
+            public Position getPosition() {
+                return position;
+            }
+        };
+        if(argumentList.size() == 5) booleanReturnable = (Returnable<Boolean>) argumentList.get(4);
+        if(argumentList.get(3).returnType() == Returnable.ReturnType.STRING && argumentList.get(3) instanceof ConstantExpression) {
+            return new BlockFunction.Constant((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (ConstantExpression<String>) argumentList.get(3), booleanReturnable, main, position);
+        }
+        return new BlockFunction((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), booleanReturnable, main, position);
+    }
+
+    @Override
+    public int argNumber() {
+        return -1;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            case 3:
+                return Returnable.ReturnType.STRING;
+            case 4:
+                return Returnable.ReturnType.BOOLEAN;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/CheckBlockFunctionBuilder.java

@@ -0,0 +1,33 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.CheckBlockFunction;
+
+import java.util.List;
+
+public class CheckBlockFunctionBuilder implements FunctionBuilder<CheckBlockFunction> {
+    @SuppressWarnings("unchecked")
+    @Override
+    public CheckBlockFunction build(List<Returnable<?>> argumentList, Position position) {
+        return new CheckBlockFunction((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 3;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/CheckFunctionBuilder.java

@@ -0,0 +1,41 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.CheckFunction;
+import com.dfsek.terra.api.TerraPlugin;
+
+import java.util.List;
+
+public class CheckFunctionBuilder implements FunctionBuilder<CheckFunction> {
+    private final TerraPlugin main;
+
+    public CheckFunctionBuilder(TerraPlugin main) {
+        this.main = main;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public CheckFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+        return new CheckFunction(main, (Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 3;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/EntityFunctionBuilder.java

@@ -0,0 +1,43 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.EntityFunction;
+import com.dfsek.terra.api.TerraPlugin;
+
+import java.util.List;
+
+public class EntityFunctionBuilder implements FunctionBuilder<EntityFunction> {
+    private final TerraPlugin main;
+
+    public EntityFunctionBuilder(TerraPlugin main) {
+        this.main = main;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public EntityFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+        return new EntityFunction((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), main, position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 4;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            case 3:
+                return Returnable.ReturnType.STRING;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/GetMarkFunctionBuilder.java

@@ -0,0 +1,37 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.GetMarkFunction;
+
+import java.util.List;
+
+public class GetMarkFunctionBuilder implements FunctionBuilder<GetMarkFunction> {
+
+    public GetMarkFunctionBuilder() {
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public GetMarkFunction build(List<Returnable<?>> argumentList, Position position) {
+        return new GetMarkFunction((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 3;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/LootFunctionBuilder.java

@@ -0,0 +1,49 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.StructureScript;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.LootFunction;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.registry.Registry;
+import com.dfsek.terra.api.structure.LootTable;
+
+import java.util.List;
+
+public class LootFunctionBuilder implements FunctionBuilder<LootFunction> {
+    private final TerraPlugin main;
+    private final Registry<LootTable> registry;
+    private final StructureScript script;
+
+    public LootFunctionBuilder(TerraPlugin main, Registry<LootTable> registry, StructureScript script) {
+        this.main = main;
+        this.registry = registry;
+        this.script = script;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public LootFunction build(List<Returnable<?>> argumentList, Position position) {
+        return new LootFunction(registry, (Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), main, position, script);
+    }
+
+    @Override
+    public int argNumber() {
+        return 4;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            case 3:
+                return Returnable.ReturnType.STRING;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/PullFunctionBuilder.java

@@ -0,0 +1,43 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.PullFunction;
+import com.dfsek.terra.api.TerraPlugin;
+
+import java.util.List;
+
+public class PullFunctionBuilder implements FunctionBuilder<PullFunction> {
+    private final TerraPlugin main;
+
+    public PullFunctionBuilder(TerraPlugin main) {
+        this.main = main;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public PullFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+        return new PullFunction((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), main, position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 4;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            case 3:
+                return Returnable.ReturnType.STRING;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/RandomFunctionBuilder.java

@@ -0,0 +1,28 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.RandomFunction;
+
+import java.util.List;
+
+public class RandomFunctionBuilder implements FunctionBuilder<RandomFunction> {
+    @SuppressWarnings("unchecked")
+    @Override
+    public RandomFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+        return new RandomFunction((Returnable<Number>) argumentList.get(0), position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 1;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        if(position == 0) return Returnable.ReturnType.NUMBER;
+        return null;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/RecursionsFunctionBuilder.java

@@ -0,0 +1,26 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.RecursionsFunction;
+
+import java.util.List;
+
+public class RecursionsFunctionBuilder implements FunctionBuilder<RecursionsFunction> {
+    @Override
+    public RecursionsFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+        return new RecursionsFunction(position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 0;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        return null;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/SetMarkFunctionBuilder.java

@@ -0,0 +1,40 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.SetMarkFunction;
+
+import java.util.List;
+
+public class SetMarkFunctionBuilder implements FunctionBuilder<SetMarkFunction> {
+
+    public SetMarkFunctionBuilder() {
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public SetMarkFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+        return new SetMarkFunction((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 4;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            case 3:
+                return Returnable.ReturnType.STRING;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/StateFunctionBuilder.java

@@ -0,0 +1,44 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.StateFunction;
+import com.dfsek.terra.api.TerraPlugin;
+
+import java.util.List;
+
+public class StateFunctionBuilder implements FunctionBuilder<StateFunction> {
+    private final TerraPlugin main;
+
+    public StateFunctionBuilder(TerraPlugin main) {
+        this.main = main;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public StateFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+        if(argumentList.size() < 4) throw new ParseException("Expected data", position);
+        return new StateFunction((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), main, position);
+    }
+
+    @Override
+    public int argNumber() {
+        return 4;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            case 3:
+                return Returnable.ReturnType.STRING;
+            default:
+                return null;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/StructureFunctionBuilder.java

@@ -0,0 +1,49 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.functions.StructureFunction;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.registry.Registry;
+import com.dfsek.terra.api.structure.Structure;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class StructureFunctionBuilder implements FunctionBuilder<StructureFunction> {
+    private final Registry<Structure> registry;
+    private final TerraPlugin main;
+
+    public StructureFunctionBuilder(Registry<Structure> registry, TerraPlugin main) {
+        this.registry = registry;
+        this.main = main;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public StructureFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+        if(argumentList.size() < 5) throw new ParseException("Expected rotations", position);
+
+        return new StructureFunction((Returnable<Number>) argumentList.remove(0), (Returnable<Number>) argumentList.remove(0), (Returnable<Number>) argumentList.remove(0), (Returnable<String>) argumentList.remove(0),
+                argumentList.stream().map(item -> ((Returnable<String>) item)).collect(Collectors.toList()), registry, position, main);
+    }
+
+    @Override
+    public int argNumber() {
+        return -1;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        switch(position) {
+            case 0:
+            case 1:
+            case 2:
+                return Returnable.ReturnType.NUMBER;
+            default:
+                return Returnable.ReturnType.STRING;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/UnaryBooleanFunctionBuilder.java

@@ -0,0 +1,55 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+
+public class UnaryBooleanFunctionBuilder implements FunctionBuilder<Function<Void>> {
+
+    private final BiConsumer<Boolean, TerraImplementationArguments> function;
+
+    public UnaryBooleanFunctionBuilder(BiConsumer<Boolean, TerraImplementationArguments> function) {
+        this.function = function;
+    }
+
+    @Override
+    public Function<Void> build(List<Returnable<?>> argumentList, Position position) {
+        return new Function<Void>() {
+            @Override
+            public ReturnType returnType() {
+                return ReturnType.VOID;
+            }
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+                function.accept(((Returnable<Boolean>) argumentList.get(0)).apply(implementationArguments, variableMap), (TerraImplementationArguments) implementationArguments);
+                return null;
+            }
+
+            @Override
+            public Position getPosition() {
+                return position;
+            }
+        };
+    }
+
+    @Override
+    public int argNumber() {
+        return 1;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        if(position == 0) return Returnable.ReturnType.BOOLEAN;
+        return null;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/UnaryNumberFunctionBuilder.java

@@ -0,0 +1,52 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+
+import java.util.List;
+import java.util.Map;
+
+public class UnaryNumberFunctionBuilder implements FunctionBuilder<Function<Number>> {
+
+    private final java.util.function.Function<Number, Number> function;
+
+    public UnaryNumberFunctionBuilder(java.util.function.Function<Number, Number> function) {
+        this.function = function;
+    }
+
+    @Override
+    public Function<Number> build(List<Returnable<?>> argumentList, Position position) {
+        return new Function<Number>() {
+            @Override
+            public ReturnType returnType() {
+                return ReturnType.NUMBER;
+            }
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Number apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+                return function.apply(((Returnable<Number>) argumentList.get(0)).apply(implementationArguments, variableMap));
+            }
+
+            @Override
+            public Position getPosition() {
+                return position;
+            }
+        };
+    }
+
+    @Override
+    public int argNumber() {
+        return 1;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        if(position == 0) return Returnable.ReturnType.NUMBER;
+        return null;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/UnaryStringFunctionBuilder.java

@@ -0,0 +1,53 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+
+import java.util.List;
+import java.util.Map;
+
+public class UnaryStringFunctionBuilder implements FunctionBuilder<Function<Void>> {
+
+    private final java.util.function.Consumer<String> function;
+
+    public UnaryStringFunctionBuilder(java.util.function.Consumer<String> function) {
+        this.function = function;
+    }
+
+    @Override
+    public Function<Void> build(List<Returnable<?>> argumentList, Position position) {
+        return new Function<Void>() {
+            @Override
+            public ReturnType returnType() {
+                return ReturnType.VOID;
+            }
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+                function.accept(((Returnable<String>) argumentList.get(0)).apply(implementationArguments, variableMap));
+                return null;
+            }
+
+            @Override
+            public Position getPosition() {
+                return position;
+            }
+        };
+    }
+
+    @Override
+    public int argNumber() {
+        return 1;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        if(position == 0) return Returnable.ReturnType.STRING;
+        return null;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/builders/ZeroArgFunctionBuilder.java

@@ -0,0 +1,53 @@
+package com.dfsek.terra.addons.terrascript.builders;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.FunctionBuilder;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+
+import java.util.List;
+import java.util.Map;
+
+public class ZeroArgFunctionBuilder<T> implements FunctionBuilder<Function<T>> {
+    private final java.util.function.Function<TerraImplementationArguments, T> function;
+    private final Returnable.ReturnType type;
+
+    public ZeroArgFunctionBuilder(java.util.function.Function<TerraImplementationArguments, T> function, Returnable.ReturnType type) {
+        this.function = function;
+        this.type = type;
+    }
+
+    @Override
+    public Function<T> build(List<Returnable<?>> argumentList, Position position) {
+        return new Function<T>() {
+            @Override
+            public ReturnType returnType() {
+                return type;
+            }
+
+            @Override
+            public T apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+                return function.apply((TerraImplementationArguments) implementationArguments);
+            }
+
+            @Override
+            public Position getPosition() {
+                return position;
+            }
+        };
+    }
+
+    @Override
+    public int argNumber() {
+        return 0;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        if(position == 0) return type;
+        return null;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/BiomeFunction.java

@@ -0,0 +1,56 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+import net.jafama.FastMath;
+
+import java.util.Map;
+
+public class BiomeFunction implements Function<String> {
+    private final TerraPlugin main;
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+
+
+    public BiomeFunction(TerraPlugin main, Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Position position) {
+        this.main = main;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.position = position;
+    }
+
+
+    @Override
+    public String apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        BiomeProvider grid = arguments.getWorld().getBiomeProvider();
+
+        return grid.getBiome(arguments.getBuffer().getOrigin().clone().add(new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).intValue(), FastMath.roundToInt(xz.getZ()))), arguments.getWorld().getSeed()).getID();
+    }
+
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.STRING;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/BlockFunction.java

@@ -0,0 +1,83 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.ConstantExpression;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.buffer.items.BufferedBlock;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import net.jafama.FastMath;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class BlockFunction implements Function<Void> {
+    protected final Returnable<Number> x, y, z;
+    protected final Returnable<String> blockData;
+    protected final TerraPlugin main;
+    private final Map<String, BlockState> data = new HashMap<>();
+    private final Returnable<Boolean> overwrite;
+    private final Position position;
+
+    public BlockFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> blockData, Returnable<Boolean> overwrite, TerraPlugin main, Position position) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.blockData = blockData;
+        this.overwrite = overwrite;
+        this.main = main;
+        this.position = position;
+    }
+
+    void setBlock(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap, TerraImplementationArguments arguments, BlockState rot) {
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        RotationUtil.rotateBlockData(rot, arguments.getRotation().inverse());
+        arguments.getBuffer().addItem(new BufferedBlock(rot, overwrite.apply(implementationArguments, variableMap), main, arguments.isWaterlog()), new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).doubleValue(), FastMath.roundToInt(xz.getZ())));
+    }
+
+    @Override
+    public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+        BlockState rot = getBlockState(implementationArguments, variableMap).clone();
+        setBlock(implementationArguments, variableMap, arguments, rot);
+        return null;
+    }
+
+    protected BlockState getBlockState(ImplementationArguments arguments, Map<String, Variable<?>> variableMap) {
+        return data.computeIfAbsent(blockData.apply(arguments, variableMap), main.getWorldHandle()::createBlockData);
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.VOID;
+    }
+
+    public static class Constant extends BlockFunction {
+        private final BlockState state;
+
+        public Constant(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, ConstantExpression<String> blockData, Returnable<Boolean> overwrite, TerraPlugin main, Position position) {
+            super(x, y, z, blockData, overwrite, main, position);
+            this.state = main.getWorldHandle().createBlockData(blockData.getConstant());
+        }
+
+        @Override
+        protected BlockState getBlockState(ImplementationArguments arguments, Map<String, Variable<?>> variableMap) {
+            return state;
+        }
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/CheckBlockFunction.java

@@ -0,0 +1,51 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import net.jafama.FastMath;
+
+import java.util.Map;
+
+public class CheckBlockFunction implements Function<String> {
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+
+    public CheckBlockFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Position position) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.position = position;
+    }
+
+
+    @Override
+    public String apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        String data = arguments.getWorld().getBlockData(arguments.getBuffer().getOrigin().clone().add(new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).doubleValue(), FastMath.roundToInt(xz.getZ())))).getAsString();
+        if(data.contains("[")) return data.substring(0, data.indexOf('[')); // Strip properties
+        else return data;
+    }
+
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.STRING;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/CheckFunction.java

@@ -0,0 +1,80 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
+import com.dfsek.terra.api.world.generator.SamplerCache;
+import net.jafama.FastMath;
+
+import java.util.Map;
+
+public class CheckFunction implements Function<String> {
+    private final TerraPlugin main;
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+
+    public CheckFunction(TerraPlugin main, Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Position position) {
+        this.main = main;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.position = position;
+    }
+
+
+    @Override
+    public String apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+
+
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+
+
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        Vector3 location = arguments.getBuffer().getOrigin().clone().add(new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).doubleValue(), FastMath.roundToInt(xz.getZ())));
+
+        return apply(location, arguments.getWorld());
+    }
+
+    private String apply(Vector3 vector, World world) {
+        int y = vector.getBlockY();
+        if(y >= world.getMaxHeight() || y < 0) return "AIR";
+        SamplerCache cache = world.getConfig().getSamplerCache();
+        double comp = sample(vector.getBlockX(), vector.getBlockY(), vector.getBlockZ(), cache);
+
+        if(comp > 0) return "LAND"; // If noise val is greater than zero, location will always be land.
+
+        //BiomeProvider provider = tw.getBiomeProvider();
+        //TerraBiome b = provider.getBiome(vector.getBlockX(), vector.getBlockZ());
+
+        /*if(vector.getY() > c.getSeaLevel())*/
+        return "AIR"; // Above sea level
+        //return "OCEAN"; // Below sea level
+    }
+
+    private double sample(int x, int y, int z, SamplerCache cache) {
+        int cx = FastMath.floorDiv(x, 16);
+        int cz = FastMath.floorDiv(z, 16);
+        return cache.get(x, z).sample(x - (cx << 4), y, z - (cz << 4));
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.STRING;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/EntityFunction.java

@@ -0,0 +1,57 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.ConstantExpression;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.buffer.items.BufferedEntity;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.entity.EntityType;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+
+import java.util.Map;
+
+public class EntityFunction implements Function<Void> {
+    private final EntityType data;
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+    private final TerraPlugin main;
+
+    public EntityFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> data, TerraPlugin main, Position position) throws ParseException {
+        this.position = position;
+        this.main = main;
+        if(!(data instanceof ConstantExpression)) throw new ParseException("Entity data must be constant", data.getPosition());
+
+        this.data = main.getWorldHandle().getEntity(((ConstantExpression<String>) data).getConstant());
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    @Override
+    public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        arguments.getBuffer().addItem(new BufferedEntity(data, main), new Vector3(xz.getX(), y.apply(implementationArguments, variableMap).doubleValue(), xz.getZ()));
+        return null;
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.VOID;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/GetMarkFunction.java

@@ -0,0 +1,46 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import net.jafama.FastMath;
+
+import java.util.Map;
+
+public class GetMarkFunction implements Function<String> {
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+
+    public GetMarkFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Position position) {
+        this.position = position;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    @Override
+    public String apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+        String mark = arguments.getBuffer().getMark(new Vector3(FastMath.floorToInt(xz.getX()), FastMath.floorToInt(y.apply(implementationArguments, variableMap).doubleValue()), FastMath.floorToInt(xz.getZ())));
+        return mark == null ? "" : mark;
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.STRING;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/LootFunction.java

@@ -0,0 +1,68 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.StructureScript;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.buffer.items.BufferedLootApplication;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.registry.Registry;
+import com.dfsek.terra.api.structure.LootTable;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import net.jafama.FastMath;
+
+import java.util.Map;
+
+public class LootFunction implements Function<Void> {
+    private final Registry<LootTable> registry;
+    private final Returnable<String> data;
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+    private final TerraPlugin main;
+    private final StructureScript script;
+
+    public LootFunction(Registry<LootTable> registry, Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> data, TerraPlugin main, Position position, StructureScript script) {
+        this.registry = registry;
+        this.position = position;
+        this.data = data;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.main = main;
+        this.script = script;
+    }
+
+    @Override
+    public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        String id = data.apply(implementationArguments, variableMap);
+        LootTable table = registry.get(id);
+
+        if(table == null) {
+            main.logger().severe("No such loot table " + id);
+            return null;
+        }
+
+        arguments.getBuffer().addItem(new BufferedLootApplication(table, main, script), new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).intValue(), FastMath.roundToInt(xz.getZ())));
+        return null;
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.VOID;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/PullFunction.java

@@ -0,0 +1,57 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.ConstantExpression;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.buffer.items.BufferedPulledBlock;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import net.jafama.FastMath;
+
+import java.util.Map;
+
+public class PullFunction implements Function<Void> {
+    private final BlockState data;
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+
+    public PullFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> data, TerraPlugin main, Position position) throws ParseException {
+        this.position = position;
+        if(!(data instanceof ConstantExpression)) throw new ParseException("Block data must be constant", data.getPosition());
+
+        this.data = main.getWorldHandle().createBlockData(((ConstantExpression<String>) data).getConstant());
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    @Override
+    public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+        BlockState rot = data.clone();
+        RotationUtil.rotateBlockData(rot, arguments.getRotation().inverse());
+        arguments.getBuffer().addItem(new BufferedPulledBlock(rot), new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).intValue(), FastMath.roundToInt(xz.getZ())));
+        return null;
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.VOID;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/RandomFunction.java

@@ -0,0 +1,36 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+
+import java.util.Map;
+
+public class RandomFunction implements Function<Integer> {
+    private final Returnable<Number> numberReturnable;
+    private final Position position;
+
+    public RandomFunction(Returnable<Number> numberReturnable, Position position) {
+        this.numberReturnable = numberReturnable;
+        this.position = position;
+    }
+
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.NUMBER;
+    }
+
+    @Override
+    public Integer apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        return ((TerraImplementationArguments) implementationArguments).getRandom().nextInt(numberReturnable.apply(implementationArguments, variableMap).intValue());
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/RecursionsFunction.java

@@ -0,0 +1,32 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+
+import java.util.Map;
+
+public class RecursionsFunction implements Function<Number> {
+    private final Position position;
+
+    public RecursionsFunction(Position position) {
+        this.position = position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.NUMBER;
+    }
+
+    @Override
+    public Number apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        return ((TerraImplementationArguments) implementationArguments).getRecursions();
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/SetMarkFunction.java

@@ -0,0 +1,49 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import net.jafama.FastMath;
+
+import java.util.Map;
+
+public class SetMarkFunction implements Function<Void> {
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+    private final Returnable<String> mark;
+
+    public SetMarkFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> mark, Position position) {
+        this.position = position;
+        this.mark = mark;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    @Override
+    public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        arguments.getBuffer().setMark(mark.apply(implementationArguments, variableMap), new Vector3(FastMath.floorToInt(xz.getX()), FastMath.floorToInt(y.apply(implementationArguments, variableMap).doubleValue()), FastMath.floorToInt(xz.getZ())));
+        return null;
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.VOID;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/StateFunction.java

@@ -0,0 +1,52 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.buffer.items.BufferedStateManipulator;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import net.jafama.FastMath;
+
+import java.util.Map;
+
+public class StateFunction implements Function<Void> {
+    private final Returnable<String> data;
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+    private final TerraPlugin main;
+
+    public StateFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> data, TerraPlugin main, Position position) {
+        this.position = position;
+        this.main = main;
+        this.data = data;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    @Override
+    public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        arguments.getBuffer().addItem(new BufferedStateManipulator(main, data.apply(implementationArguments, variableMap)), new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).intValue(), FastMath.roundToInt(xz.getZ())));
+        return null;
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.VOID;
+    }
+}

common/addons/structure-terrascript-functions/src/main/java/com/dfsek/terra/addons/terrascript/functions/StructureFunction.java

@@ -0,0 +1,82 @@
+package com.dfsek.terra.addons.terrascript.functions;
+
+import com.dfsek.terra.addons.terrascript.api.Function;
+import com.dfsek.terra.addons.terrascript.api.ImplementationArguments;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.addons.terrascript.api.buffer.IntermediateBuffer;
+import com.dfsek.terra.addons.terrascript.api.TerraImplementationArguments;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.registry.Registry;
+import com.dfsek.terra.api.structure.Structure;
+import com.dfsek.terra.api.structure.rotation.Rotation;
+import com.dfsek.terra.api.util.RotationUtil;
+import com.dfsek.terra.api.vector.Vector2;
+import com.dfsek.terra.api.vector.Vector3;
+import net.jafama.FastMath;
+
+import java.util.List;
+import java.util.Map;
+
+public class StructureFunction implements Function<Boolean> {
+    private final Registry<Structure> registry;
+    private final Returnable<String> id;
+    private final Returnable<Number> x, y, z;
+    private final Position position;
+    private final TerraPlugin main;
+    private final List<Returnable<String>> rotations;
+
+    public StructureFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> id, List<Returnable<String>> rotations, Registry<Structure> registry, Position position, TerraPlugin main) {
+        this.registry = registry;
+        this.id = id;
+        this.position = position;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.main = main;
+        this.rotations = rotations;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.BOOLEAN;
+    }
+
+    @Override
+    public Boolean apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+
+        if(arguments.getRecursions() > main.getTerraConfig().getMaxRecursion())
+            throw new RuntimeException("Structure recursion too deep: " + arguments.getRecursions());
+
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        String app = id.apply(implementationArguments, variableMap);
+        Structure script = registry.get(app);
+        if(script == null) {
+            main.logger().severe("No such structure " + app);
+            return null;
+        }
+
+        Rotation rotation1;
+        String rotString = rotations.get(arguments.getRandom().nextInt(rotations.size())).apply(implementationArguments, variableMap);
+        try {
+            rotation1 = Rotation.valueOf(rotString);
+        } catch(IllegalArgumentException e) {
+            main.logger().severe("Invalid rotation " + rotString);
+            return null;
+        }
+
+        Vector3 offset = new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).doubleValue(), FastMath.roundToInt(xz.getZ()));
+
+        return script.generate(new IntermediateBuffer(arguments.getBuffer(), offset), arguments.getWorld(), arguments.getRandom(), arguments.getRotation().rotate(rotation1), arguments.getRecursions() + 1);
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+}