JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

@@ -112,6 +112,18 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
 			}
         }
+    
+        for(IDefinitionMember membersOfSameType : member.definition.members) {
+            if(membersOfSameType instanceof FieldMember) {
+                final FieldMember fieldMember = ((FieldMember) membersOfSameType);
+                final Expression initializer = fieldMember.initializer;
+                if(initializer != null) {
+                    constructorWriter.loadObject(0);
+                    initializer.accept(statementVisitor.expressionVisitor);
+                    constructorWriter.putField(context.getJavaField(fieldMember));
+                }
+            }
+        }
 
 		for (TypeParameter typeParameter : definition.typeParameters) {
 			final JavaTypeParameterInfo typeParameterInfo = javaModule.getTypeParameterInfo(typeParameter);

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeModule.java

@@ -78,12 +78,13 @@ public class JavaNativeModule {
 		typeByClass.put(void.class, BasicTypeID.VOID);
 		typeByClass.put(boolean.class, BasicTypeID.BOOL);
 		typeByClass.put(byte.class, BasicTypeID.SBYTE);
-		typeByClass.put(short.class, BasicTypeID.SHORT);
-		typeByClass.put(int.class, BasicTypeID.INT);
-		typeByClass.put(long.class, BasicTypeID.LONG);
-		typeByClass.put(float.class, BasicTypeID.FLOAT);
-		typeByClass.put(double.class, BasicTypeID.DOUBLE);
-		typeByClass.put(String.class, StringTypeID.INSTANCE);
+        typeByClass.put(char.class, BasicTypeID.CHAR);
+        typeByClass.put(short.class, BasicTypeID.SHORT);
+        typeByClass.put(int.class, BasicTypeID.INT);
+        typeByClass.put(long.class, BasicTypeID.LONG);
+        typeByClass.put(float.class, BasicTypeID.FLOAT);
+        typeByClass.put(double.class, BasicTypeID.DOUBLE);
+        typeByClass.put(String.class, StringTypeID.INSTANCE);
 		typeByClass.put(Boolean.class, registry.getOptional(BasicTypeID.BOOL));
 		typeByClass.put(Byte.class, registry.getOptional(BasicTypeID.BYTE));
 		typeByClass.put(Short.class, registry.getOptional(BasicTypeID.SHORT));
@@ -93,13 +94,14 @@ public class JavaNativeModule {
 		typeByClass.put(Double.class, registry.getOptional(BasicTypeID.DOUBLE));
 
 		unsignedByClass.put(byte.class, BasicTypeID.BYTE);
-		unsignedByClass.put(short.class, BasicTypeID.USHORT);
-		unsignedByClass.put(int.class, BasicTypeID.UINT);
-		unsignedByClass.put(long.class, BasicTypeID.ULONG);
-		unsignedByClass.put(Byte.class, registry.getOptional(BasicTypeID.BYTE));
-		unsignedByClass.put(Short.class, registry.getOptional(BasicTypeID.SHORT));
-		unsignedByClass.put(Integer.class, registry.getOptional(BasicTypeID.INT));
-		unsignedByClass.put(Long.class, registry.getOptional(BasicTypeID.LONG));
+        unsignedByClass.put(char.class, BasicTypeID.CHAR);
+        unsignedByClass.put(short.class, BasicTypeID.USHORT);
+        unsignedByClass.put(int.class, BasicTypeID.UINT);
+        unsignedByClass.put(long.class, BasicTypeID.ULONG);
+        unsignedByClass.put(Byte.class, registry.getOptional(BasicTypeID.BYTE));
+        unsignedByClass.put(Short.class, registry.getOptional(BasicTypeID.SHORT));
+        unsignedByClass.put(Integer.class, registry.getOptional(BasicTypeID.INT));
+        unsignedByClass.put(Long.class, registry.getOptional(BasicTypeID.LONG));
 	}
 
 	public SemanticModule toSemantic(ModuleSpace space) {
@@ -225,7 +227,7 @@ public class JavaNativeModule {
 	}
 	
 	private boolean isInBasePackage(String className) {
-		return className.startsWith(basePackage + ".") || className.startsWith("java.lang.") || className.startsWith("java.util.");
+		return className.startsWith(module.name) || className.startsWith(basePackage + ".") || className.startsWith("java.lang.") || className.startsWith("java.util.");
 	}
 
 	private ZSPackage getPackage(String className) {

JavaIntegration/src/main/java/org/openzen/zencode/java/logger/ScriptingEngineStreamLogger.java

@@ -63,7 +63,7 @@ public class ScriptingEngineStreamLogger implements ScriptingEngineLogger {
     
     @Override
     public void logCompileException(CompileException exception) {
-        throw new UnsupportedOperationException();
+        throwingErr("Compile Exception:", exception);
     }
     
     @Override

ScriptingExample/scripts/Cell.zs

@@ -0,0 +1,30 @@
+public class Cell {
+
+    public var alive as bool;
+    private var row as usize;
+    private var column as usize;
+
+    public this(row as usize, column as usize) {
+        this(row, column, false);
+    }
+
+    public this(row as usize, column as usize, alive as bool) {
+            this.row = row;
+            this.column = column;
+            this.alive = alive;
+    }
+
+    public getCellNextTick(currentGrid as ConwayGrid) as Cell {
+        //+2 because upperbound exclusive
+        var range = currentGrid[(row - 1) .. (row + 2), (column - 1) .. (column + 2)];
+        var aliveCellsIn3x3Grid = range.filter(element => element.alive).length;
+
+
+        if(!alive) {
+            return new Cell(row, column, aliveCellsIn3x3Grid == 3);
+        }
+
+        //2. Any live cell with two or three live neighbours lives on to the next generation.
+        return new Cell(row, column, aliveCellsIn3x3Grid == 3 || aliveCellsIn3x3Grid == 4);
+    }
+}

ScriptingExample/scripts/ConwayGrid.zs

@@ -0,0 +1,42 @@
+import example.gui.UpdatableGrid;
+
+public class ConwayGrid {
+    public var cells as Cell[,];
+    private var width as usize;
+    private var height as usize;
+
+    public this(width as usize, height as usize) {
+        this.cells = new Cell[,](width, height, (row, column) => new Cell(row, column));
+        this.width = width;
+        this.height = height;
+    }
+
+    public []=(row as int, column as int, alive as bool) as void {
+        this.cells[row,column].alive = alive;
+    }
+
+    public update() as void {
+        var gridCapture = this;
+        this.cells = new Cell[,](width, height, (row, column) => gridCapture.cells[row, column].getCellNextTick(gridCapture));
+    }
+
+    //public [](row as usize, column as usize) as Cell => cells[row,column];
+
+    public [](rows as usize .. usize, columns as usize .. usize) as Cell[]{
+        var usedRows = rows.withBounds(0 .. height);
+        var usedColumns = columns.withBounds(0 .. width);
+
+        var rowSpan = usedRows.to - usedRows.from;
+        var columnSpan = usedColumns.to - usedColumns.from;
+        var cells = this.cells;
+        return new Cell[](rowSpan * columnSpan, cellNo => cells[usedRows.from + (cellNo / columnSpan), usedColumns.from + (cellNo % columnSpan)]);
+    }
+
+    public updateDisplay(display as UpdatableGrid) as void {
+        for row in 0 .. height {
+            for column in 0 .. width {
+                display[row, column] = (cells[row,column].alive ? 'X' : ' ') as char;
+            }
+        }
+    }
+}

ScriptingExample/scripts/ExpandRangeUsize.zs

@@ -0,0 +1,5 @@
+public expand usize .. usize {
+    public withBounds(bounds as usize .. usize) as usize .. usize {
+        return (from < bounds.from ? bounds.from : from) .. (to > bounds.to ? bounds.to : to);
+    }
+}

ScriptingExample/scripts/GridTest.zs

@@ -0,0 +1,27 @@
+import example.gui.UpdatableGrid;
+import example.threading.ZCThread;
+
+var height = 25;
+var width = 25;
+
+var grid = new UpdatableGrid(height, width);
+var conwayGrid = new ConwayGrid(height, width);
+
+conwayGrid[4,5] = true;
+conwayGrid[5,4] = true;
+conwayGrid[5,5] = true;
+conwayGrid[5,6] = true;
+
+
+conwayGrid.updateDisplay(grid);
+grid.show("Hello World");
+
+var i = 0;
+while(true) {
+    println("Generation " + i);
+    conwayGrid.updateDisplay(grid);
+    grid.update();
+    ZCThread.sleep((1).seconds());
+    conwayGrid.update();
+    i++;
+}

ScriptingExample/scripts/nope/match.zs

@@ -1,51 +0,0 @@
-val test as int = 10;
-val tt1 = "tt";
-val tt2 = "tt3";
-val tt4 = "tt5";
-
-
-println(match 10 {
-	1 => "one",
-	10 => "yo",
-	//tt1 === "tt1" for some compiler issue it takes the variable as string input?
-	100 => match tt1 {
-		"10" => "t",
-		"tt1" => tt1,
-		"tt2" => tt1 + tt4,
-		default => tt4
-	},
-	default => tt2
-});
-
-
-println(tt1);
-
-//println(match test {
-//	case 1 : "tt",
-//	default : "kk"
-//});
-
-
-
-function myFunc (par1 as int) as void {
-
-    val v0 = par1 - 1;
-	println(match par1 {
-		10 => v0,
-		default => match(v0) {
-			10 => 99,
-			default => v0
-		}
-	});
-}
-
-
-myFunc(10);
-myFunc(11);
-myFunc(12);
-
-
-val t = (a as int) as int => a;
-
-
-println(t(10));

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Globals.java

@@ -5,85 +5,18 @@
  */
 package org.openzen.zenscript.scriptingexample;
 
-import org.openzen.zencode.java.ZenCodeGlobals;
-import static org.openzen.zencode.java.ZenCodeType.*;
+import org.openzen.zencode.java.*;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class Globals implements ZenCodeGlobals {
-	private Globals() {}
-	
-	@Global
-	public static TestClass something = new TestClass("hello");
-	
-	@Global
-	public static TestClass[] makeArray(int amount) {
-		TestClass[] result = new TestClass[amount];
-		for (int i = 0; i < result.length; i++)
-			result[i] = new TestClass("test " + i);
-		return result;
-	}
-	
-	@Global
-	public static void println(String message) {
-		System.out.println(message);
-	}
-	
-	@Global
-	public static void printMany(TestClass[] objects) {
-		System.out.println(objects.length + " objects present:");
-		for (TestClass object : objects)
-			System.out.println("  - " + object.getName());
-	}
-	
-	@Global
-    public static void addShapedRecipe(String name, TestClass output, TestClass[][] inputs) {
-		System.out.println("Added " + name);
-	}
-	
-	@Global
-	public static void floatMethod(float argument) {
-		System.out.println(argument);
-	}
-	
-	@Global
-	public static void invokeFunctional(MyFunctionalInterface greeter) {
-		System.out.println("doSomething: " + greeter.doSomething("world"));
-	}
-	
-	@Global
-	public static void invokeFunctionalInt(MyFunctionalInterfaceInt calculator){
-		System.out.println("FunctionalInt: " + calculator.doSomething(7, 13));
-	}
-	
-	@Global
-	public static void testOptional(MyOptionalInterface function) {
-		System.out.println("Null: " + function.doSomething(null));
-		System.out.println("Hello: " + function.doSomething("hello"));
-	}
-	
-	public static TestClass bracket(String value) {
-		return new TestClass(value);
-	}
-
-	public static String staticToString(String value) {
-		return value;
-	}
-	
-	@FunctionalInterface
-	public static interface MyFunctionalInterface {
-		String doSomething(String value);
-	}
-	
-	@FunctionalInterface
-	public static interface MyFunctionalInterfaceInt {
-		int doSomething(int valueA, int valueB);
-	}
-	
-	@FunctionalInterface
-	public static interface MyOptionalInterface {
-		int doSomething(@Nullable String value);
-	}
+    
+    private Globals() {
+    }
+    
+    @Global
+    public static void println(String message) {
+        System.out.println(message);
+    }
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

@@ -1,73 +1,56 @@
 package org.openzen.zenscript.scriptingexample;
 
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.openzen.zencode.java.JavaNativeModule;
-import org.openzen.zencode.java.ScriptingEngine;
-import org.openzen.zencode.shared.CompileException;
-import org.openzen.zencode.shared.FileSourceFile;
-import org.openzen.zencode.shared.SourceFile;
-import org.openzen.zenscript.codemodel.FunctionParameter;
-import org.openzen.zenscript.codemodel.SemanticModule;
-import org.openzen.zenscript.codemodel.type.StringTypeID;
-import org.openzen.zenscript.lexer.ParseException;
-import org.openzen.zenscript.parser.BracketExpressionParser;
-import org.openzen.zenscript.parser.EscapableBracketParser;
-import org.openzen.zenscript.parser.PrefixedBracketParser;
-import org.openzen.zenscript.parser.SimpleBracketParser;
-import org.openzen.zenscript.scriptingexample.events.EventManager;
-import org.openzen.zenscript.scriptingexample.events.IEvent;
-import org.openzen.zenscript.scriptingexample.events.impl.CTStringedEvent;
-import org.openzen.zencode.java.logger.ScriptingEngineStreamLogger;
+import org.openzen.zencode.java.*;
+import org.openzen.zencode.java.logger.*;
+import org.openzen.zencode.shared.*;
+import org.openzen.zenscript.codemodel.*;
+import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.lexer.*;
+import org.openzen.zenscript.parser.*;
+import org.openzen.zenscript.scriptingexample.gui.*;
+import org.openzen.zenscript.scriptingexample.threading.*;
+
+import java.io.*;
+import java.nio.file.*;
+import java.util.*;
 
 public class Main {
-	public static void main(String[] args) throws CompileException, ParseException, IOException, NoSuchMethodException {
-		ScriptingEngine scriptingEngine = new ScriptingEngine(new ScriptingEngineStreamLogger());
-		scriptingEngine.debug = true;
-
-		JavaNativeModule example = scriptingEngine.createNativeModule("example", "org.openzen.zenscript.scriptingexample");
-		example.addGlobals(Globals.class);
-		example.addClass(TestBaseInterface.class);
-		example.addClass(TestGenericInterface.class);
-		example.addClass(TestClass.class);
-		example.addClass(TestInterface.class);
-		example.addClass(IEvent.class);
-		example.addClass(EventManager.class);
-		example.addClass(CTStringedEvent.class);
-		scriptingEngine.registerNativeProvided(example);
-
-		File inputDirectory = new File("scripts");
-		final SourceFile[] sourceFiles = Files.walk(inputDirectory.getAbsoluteFile().toPath())
-				.map(Path::toFile)
-				.filter(File::isFile)
-				.filter(f -> f.getName().endsWith(".zs"))
-				.filter(f -> !f.getAbsolutePath().contains("nope"))
-				.map(f -> new FileSourceFile(f.getName(), f))
-				.toArray(SourceFile[]::new);
-		//File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
-		//SourceFile[] sourceFiles = new SourceFile[inputFiles.length];
-		//for (int i = 0; i < inputFiles.length; i++)
-		//	sourceFiles[i] = new FileSourceFile(inputFiles[i].getName(), inputFiles[i]);
-
-		final PrefixedBracketParser parser = new PrefixedBracketParser(null);
-		BracketExpressionParser testParser = new SimpleBracketParser(scriptingEngine.registry, example.loadStaticMethod(Globals.class.getMethod("bracket", String.class)));
-		parser.register("test", testParser);
-		BracketExpressionParser toStringParser = new EscapableBracketParser(scriptingEngine.registry, example.loadStaticMethod(Globals.class.getMethod("staticToString", String.class)));
-		parser.register("toString", toStringParser);
-		FunctionParameter parameter = new FunctionParameter(scriptingEngine.registry.getArray(StringTypeID.AUTO, 1).stored(), "args");
-		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, parser, new FunctionParameter[] { parameter });
-		if (!scripts.isValid())
-			return;
-
-		scriptingEngine.registerCompiled(scripts);
-
-		Map<FunctionParameter, Object> scriptArgs = new HashMap<>();
-		scriptArgs.put(parameter, new String[] { "hello", "world", "example" });
-		scriptingEngine.run(scriptArgs);
-	}
+    
+    public static void main(String[] args) throws CompileException, ParseException, IOException, NoSuchMethodException {
+        ScriptingEngine scriptingEngine = new ScriptingEngine(new ScriptingEngineStreamLogger());
+        scriptingEngine.debug = true;
+        
+        JavaNativeModule example = scriptingEngine.createNativeModule("example", "org.openzen.zenscript.scriptingexample");
+        example.addGlobals(Globals.class);
+        
+        example.addClass(UpdatableGrid.class);
+        example.addClass(TimeSpan.class);
+        example.addClass(TimeSpan.ExpandInt.class);
+        example.addClass(ZCThread.class);
+        
+        scriptingEngine.registerNativeProvided(example);
+        
+        File inputDirectory = new File("scripts");
+        final SourceFile[] sourceFiles = Files.walk(inputDirectory.getAbsoluteFile().toPath())
+                .map(Path::toFile)
+                .filter(File::isFile)
+                .filter(f -> f.getName().endsWith(".zs"))
+                .filter(f -> !f.getAbsolutePath().contains("nope"))
+                .map(f -> new FileSourceFile(f.getName(), f))
+                .toArray(SourceFile[]::new);
+        
+        final PrefixedBracketParser parser = new PrefixedBracketParser(null);
+        
+        FunctionParameter parameter = new FunctionParameter(scriptingEngine.registry.getArray(StringTypeID.AUTO, 1)
+                .stored(), "args");
+        SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, parser, new FunctionParameter[]{parameter});
+        if(!scripts.isValid())
+            return;
+        
+        scriptingEngine.registerCompiled(scripts);
+        
+        Map<FunctionParameter, Object> scriptArgs = new HashMap<>();
+        scriptArgs.put(parameter, new String[]{"hello", "world", "example"});
+        scriptingEngine.run(scriptArgs);
+    }
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestBaseInterface.java

@@ -1,17 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.scriptingexample;
-
-import org.openzen.zencode.java.ZenCodeType;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface TestBaseInterface<T> extends ZenCodeType {
-	@Method
-	T getValue();
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestClass.java

@@ -1,60 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.scriptingexample;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class TestClass implements TestInterface {
-	private final String name;
-	
-	@Constructor
-	public TestClass(String name) {
-		this.name = name;
-	}
-	
-	@Getter
-	public String getName() {
-		return name;
-	}
-	
-	@Method
-	public void dump() {
-		System.out.println("TestClass " + name);
-	}
-	
-	@Method
-	public TestClass wrap(String quotes) {
-		return new TestClass(quotes + name + quotes);
-	}
-	
-	@Caster(implicit = true)
-	@Override
-	public String toString() {
-		return name;
-	}
-
-	@Override
-	public String interfaceMethod() {
-		return "Interface method of " + name;
-	}
-	
-	@Override
-	public String getValue() {
-		return "getValue " + name;
-	}
-	
-	@Method
-	public TestGenericInterface<String> generate() {
-		return () -> name;
-	}
-	
-	@Method
-	public void withDefaultParameter(String a, @OptionalString("world") String b) {
-		System.out.println(a + " " + b);
-	}
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestGenericInterface.java

@@ -1,14 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.scriptingexample;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface TestGenericInterface<T> extends TestBaseInterface<T> {
-	
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestInterface.java

@@ -1,17 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.scriptingexample;
-
-import org.openzen.zencode.java.ZenCodeType;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface TestInterface extends ZenCodeType, TestGenericInterface<String> {
-	@Method
-	String interfaceMethod();
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/EventManager.java

@@ -1,24 +0,0 @@
-package org.openzen.zenscript.scriptingexample.events;
-
-import org.openzen.zencode.java.ZenCodeType;
-import org.openzen.zenscript.scriptingexample.events.impl.CTStringedEvent;
-import org.openzen.zenscript.scriptingexample.events.impl.StringedEvent;
-
-@ZenCodeType.Name("example.org.openzen.scripting_example.events.EventManager")
-public class EventManager {
-    @ZenCodeType.Method
-    public static void register(IEvent<?, ?> event) {
-    //public static <EVE extends IEvent<EVE, VA>, VA extends SomeMCEvent> void register(IEvent<EVE, VA> event) {
-        System.out.println("HIT!!!");
-
-        if(event instanceof CTStringedEvent) {
-            ((CTStringedEvent)event).getHandler().accept(new CTStringedEvent(null));
-        }
-    }
-
-    //@ZenCodeType.Method
-    //public static void register(CTStringedEvent event) {
-    //    System.out.println("HIT!!!");
-    //    event.getConsumer().accept(new StringedEvent("Abcdef"));
-    //}
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/IEvent.java

@@ -1,41 +0,0 @@
-package org.openzen.zenscript.scriptingexample.events;
-
-import org.openzen.zencode.java.ZenCodeType;
-
-import java.util.function.Consumer;
-
-@ZenCodeType.Name("example.org.openzen.scripting_example.events.IEvent")
-public abstract class IEvent<E extends IEvent<E, V>, V extends SomeMCEvent> {
-
-    private V internal;
-
-    private Consumer<E> handler;
-
-    public IEvent(V internal) {
-        this.internal = internal;
-    }
-
-    @ZenCodeType.Constructor
-    public IEvent(Consumer<E> handler) {
-        this.handler = handler;
-    }
-
-    public void setInternal(V internal) {
-        this.internal = internal;
-    }
-
-    public abstract Consumer<V> getConsumer();
-
-
-    public V getInternal() {
-        return internal;
-    }
-
-    public Consumer<E> getHandler() {
-        return handler;
-    }
-
-    public void setHandler(Consumer<E> handler) {
-        this.handler = handler;
-    }
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/SomeMCEvent.java

@@ -1,4 +0,0 @@
-package org.openzen.zenscript.scriptingexample.events;
-
-public interface SomeMCEvent {
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/impl/CTStringedEvent.java

@@ -1,25 +0,0 @@
-package org.openzen.zenscript.scriptingexample.events.impl;
-
-import org.openzen.zencode.java.ZenCodeType;
-import org.openzen.zenscript.scriptingexample.events.IEvent;
-
-import java.util.function.Consumer;
-
-@ZenCodeType.Name("example.org.openzen.scripting_example.events.CTStringedEvent")
-public class CTStringedEvent extends IEvent<CTStringedEvent, StringedEvent> {
-
-    @ZenCodeType.Getter("blub")
-    public String getBlub() {
-        return "ASDF";
-    }
-
-    @ZenCodeType.Constructor
-    public CTStringedEvent(Consumer<CTStringedEvent> handler) {
-        super(handler);
-    }
-
-    @Override
-    public Consumer<StringedEvent> getConsumer() {
-        return stringedEvent -> getHandler().accept(new CTStringedEvent(null));
-    }
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/impl/StringedEvent.java

@@ -1,12 +0,0 @@
-package org.openzen.zenscript.scriptingexample.events.impl;
-
-import org.openzen.zenscript.scriptingexample.events.SomeMCEvent;
-
-public class StringedEvent implements SomeMCEvent {
-    private final String text;
-
-    public StringedEvent(String text) {
-
-        this.text = text;
-    }
-}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/gui/SwingGrid.java

@@ -0,0 +1,40 @@
+package org.openzen.zenscript.scriptingexample.gui;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class SwingGrid extends JFrame {
+    
+    private final char[][] grid;
+    private final JLabel[][] labelGrid;
+    
+    public SwingGrid(String title, char[][] grid) throws HeadlessException {
+        super(title);
+        this.grid = grid;
+        this.setLayout(new GridLayout(grid.length, 0));
+        
+        labelGrid = new JLabel[grid.length][grid[0].length];
+        for(int i = 0; i < grid.length; i++) {
+            char[] chars = grid[i];
+            for(int j = 0; j < chars.length; j++) {
+                this.add(labelGrid[i][j] = new JLabel(String.valueOf(chars[j]), SwingConstants.CENTER));
+            }
+        }
+        
+        this.setLocationRelativeTo(null);
+        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+        EventQueue.invokeLater(() -> {
+            this.setVisible(true);
+        });
+    }
+    
+    
+    public void update() {
+        for(int i = 0; i < grid.length; i++) {
+            char[] chars = grid[i];
+            for(int j = 0; j < chars.length; j++) {
+                labelGrid[i][j].setText(String.valueOf(chars[j]));
+            }
+        }
+    }
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/gui/UpdatableGrid.java

@@ -0,0 +1,35 @@
+package org.openzen.zenscript.scriptingexample.gui;
+
+import org.openzen.zencode.java.*;
+
+@ZenCodeType.Name("example.gui.UpdatableGrid")
+public class UpdatableGrid {
+    
+    private final char[][] grid;
+    private SwingGrid swingGrid;
+    
+    @ZenCodeType.Constructor
+    public UpdatableGrid(int rows, int columns) {
+        grid = new char[rows][columns];
+    }
+    
+    @ZenCodeType.Operator(ZenCodeType.OperatorType.INDEXSET)
+    public void setValue(@ZenCodeType.USize int row, @ZenCodeType.USize int column, char value) {
+        grid[row][column] = value;
+    }
+    
+    @ZenCodeType.Method
+    public void show(String name, @ZenCodeType.OptionalInt(600) int width, @ZenCodeType.OptionalInt(480) int height) {
+        if(swingGrid == null) {
+            swingGrid = new SwingGrid(name, grid);
+        }
+        swingGrid.setSize(width, height);
+    }
+    
+    @ZenCodeType.Method
+    public void update() {
+        if(swingGrid != null) {
+            swingGrid.update();
+        }
+    }
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/threading/TimeSpan.java

@@ -0,0 +1,32 @@
+package org.openzen.zenscript.scriptingexample.threading;
+
+import org.openzen.zencode.java.*;
+
+@ZenCodeType.Name("example.threading.TimeSpan")
+public class TimeSpan {
+    private final long timeNanos;
+    
+    public TimeSpan(long timeNanos) {
+        this.timeNanos = timeNanos;
+    }
+    
+    @ZenCodeType.Getter("timeMillis")
+    public long getTimeMillis() {
+        return timeNanos;
+    }
+    
+    @ZenCodeType.Expansion("int")
+    public static final class ExpandInt {
+        @ZenCodeType.Method
+        public static TimeSpan seconds(int _this) {
+            return new TimeSpan(_this * 1_000);
+        }
+        
+        @ZenCodeType.Method
+        @ZenCodeType.Caster(implicit = true)
+        public static TimeSpan milliSeconds(int _this) {
+            return new TimeSpan(_this);
+        }
+        
+    }
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/threading/ZCThread.java

@@ -0,0 +1,21 @@
+package org.openzen.zenscript.scriptingexample.threading;
+
+import org.openzen.zencode.java.*;
+
+@ZenCodeType.Name("example.threading.ZCThread")
+public class ZCThread {
+    
+    @ZenCodeType.Method
+    public static void sleep(TimeSpan timeSpan) {
+        sleep(timeSpan.getTimeMillis());
+    }
+    
+    @ZenCodeType.Method
+    public static void sleep(long millis) {
+        try {
+            Thread.sleep(millis);
+        } catch(InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/actual_test/classes/AddingClasses.java

@@ -0,0 +1,90 @@
+package org.openzen.zenscript.scriptingexample.tests.actual_test.classes;
+
+import org.junit.jupiter.api.*;
+import org.openzen.zenscript.scriptingexample.tests.helpers.*;
+
+public class AddingClasses extends ZenCodeTest {
+    
+    @Test
+    public void emptyClassCompiles() {
+        ScriptBuilder.create().add("public class SomeClass {").add("}").execute(this);
+        logger.assertNoErrors();
+    }
+    
+    @Test
+    public void memberGettable() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public var x as string;")
+                .add("    public this(){x = 'Hello World';}")
+                .add("}")
+                .add("")
+                .add("println(new SomeClass().x);")
+                .execute(this);
+        
+        logger.assertNoErrors();
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World");
+    }
+    
+    @Test
+    public void functionCallable() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public this(){}")
+                .add("    public callMeMaybe() as void {println('Hello World!');}")
+                .add("}")
+                .add("")
+                .add("new SomeClass().callMeMaybe();")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World!");
+    }
+    
+    @Test
+    public void classAccessibleFromOtherScript() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public this(){}")
+                .add("    public callMeMaybe() as void {println('Hello World!');}")
+                .add("}")
+                .add("")
+                .startNewScript()
+                .add("new SomeClass().callMeMaybe();")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World!");
+    }
+    
+    @Test
+    public void fieldInitializerSetsField() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public var x as string = 'Hello World';")
+                .add("    public this(){}")
+                .add("}")
+                .add("")
+                .add("println(new SomeClass().x);")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Hello World");
+    }
+    
+    @Test
+    public void constructorOverridesFieldInitializer() {
+        ScriptBuilder.create()
+                .add("public class SomeClass {")
+                .add("    public var x as string = 'Hello World';")
+                .add("    public this(){this.x = 'Goodbye World';}")
+                .add("}")
+                .add("")
+                .add("println(new SomeClass().x);")
+                .execute(this);
+        
+        logger.assertPrintOutputSize(1);
+        logger.assertPrintOutput(0, "Goodbye World");
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/helpers/ScriptBuilder.java

@@ -0,0 +1,66 @@
+package org.openzen.zenscript.scriptingexample.tests.helpers;
+
+import java.util.*;
+
+public class ScriptBuilder {
+    
+    private final List<String> scripts;
+    private StringJoiner currentScriptJoiner;
+    
+    private ScriptBuilder() {
+        scripts = new ArrayList<>();
+        startNewScript();
+    }
+    
+    /**
+     * Creates a {@link StringJoiner} that merges with newlines.
+     * The only real reason for this to exist is that it allows code formatting to work properly lol
+     */
+    public static ScriptBuilder create() {
+        return new ScriptBuilder();
+    }
+    
+    public ScriptBuilder add(String line) {
+        currentScriptJoiner.add(line);
+        return this;
+    }
+    
+    public ScriptBuilder startNewScript() {
+        if(currentScriptJoiner != null) {
+            scripts.add(currentScriptJoiner.toString());
+        }
+        
+        currentScriptJoiner = new StringJoiner(System.lineSeparator());
+        return this;
+    }
+    
+    public void appendScriptsToTest(ZenCodeTest test) {
+        startNewScript();
+    
+        for(String script : scripts) {
+            test.addScript(script);
+        }
+    }
+    
+    public void execute(ZenCodeTest test, LogTolerance logTolerance) {
+        appendScriptsToTest(test);
+        test.executeEngine();
+        switch(logTolerance) {
+            case NO_WARNINGS:
+                test.logger.assertNoWarnings();
+            case NO_ERRORS:
+                test.logger.assertNoErrors();
+                break;
+            case ALLOW_ERRORS:
+                break;
+        }
+    }
+    
+    public void execute(ZenCodeTest test) {
+        execute(test, LogTolerance.NO_WARNINGS);
+    }
+    
+    public enum LogTolerance {
+        NO_WARNINGS, NO_ERRORS, ALLOW_ERRORS
+    }
+}

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/helpers/ZenCodeTestLogger.java

@@ -9,6 +9,8 @@ public class ZenCodeTestLogger extends ScriptingEngineStreamLogger {
     
     private static final boolean logDebug = false;
     private final List<String> printlnOutputs = new ArrayList<>();
+    private final List<String> errors = new ArrayList<>();
+    private final List<String> warnings = new ArrayList<>();
     private boolean isEngineComplete = false;
     
     @Override
@@ -18,9 +20,33 @@ public class ZenCodeTestLogger extends ScriptingEngineStreamLogger {
         }
     }
     
+    @Override
+    public void warning(String message) {
+        warnings.add(message);
+        super.warning(message);
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        warnings.add(message);
+        super.throwingWarn(message, throwable);
+    }
+    
     public void logPrintln(String line) {
         info(line);
-        this.printlnOutputs.addAll(Arrays.asList(line.split(System.lineSeparator())));
+        this.printlnOutputs.addAll(Arrays.asList(String.valueOf(line).split(System.lineSeparator())));
+    }
+    
+    @Override
+    public void error(String message) {
+        errors.add(message);
+        super.error(message);
+    }
+    
+    @Override
+    public void throwingErr(String message, Throwable throwable) {
+        errors.add(message);
+        super.throwingErr(message, throwable);
     }
     
     void setEngineComplete() {
@@ -40,4 +66,12 @@ public class ZenCodeTestLogger extends ScriptingEngineStreamLogger {
         }
         Assertions.assertEquals(size, printlnOutputs.size());
     }
+    
+    public void assertNoErrors() {
+        Assertions.assertEquals(0, errors.size());
+    }
+    
+    public void assertNoWarnings() {
+        Assertions.assertEquals(0, warnings.size());
+    }
 }