Broke and cleaned up server commands

annotations/src/main/java/io/anuke/annotations/Annotations.java

@@ -0,0 +1,111 @@
+package io.anuke.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+public class Annotations{
+
+    /** Marks a class as serializable.*/
+    @Target(ElementType.TYPE)
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Serialize{
+
+    }
+
+    public enum PacketPriority{
+        /** Gets put in a queue and processed if not connected. */
+        normal,
+        /** Gets handled immediately, regardless of connection status. */
+        high,
+        /** Does not get handled unless client is connected. */
+        low
+    }
+
+    /** A set of two booleans, one specifying server and one specifying client. */
+    public enum Loc{
+        /** Method can only be invoked on the client from the server. */
+        server(true, false),
+        /** Method can only be invoked on the server from the client. */
+        client(false, true),
+        /** Method can be invoked from anywhere */
+        both(true, true),
+        /** Neither server nor client. */
+        none(false, false);
+
+        /** If true, this method can be invoked ON clients FROM servers. */
+        public final boolean isServer;
+        /** If true, this method can be invoked ON servers FROM clients. */
+        public final boolean isClient;
+
+        Loc(boolean server, boolean client){
+            this.isServer = server;
+            this.isClient = client;
+        }
+    }
+
+    public enum Variant{
+        /** Method can only be invoked targeting one player. */
+        one(true, false),
+        /** Method can only be invoked targeting all players. */
+        all(false, true),
+        /** Method targets both one player and all players. */
+        both(true, true);
+
+        public final boolean isOne, isAll;
+
+        Variant(boolean isOne, boolean isAll){
+            this.isOne = isOne;
+            this.isAll = isAll;
+        }
+    }
+
+    /** Marks a method as invokable remotely across a server/client connection. */
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Remote{
+        /** Specifies the locations from which this method can be invoked. */
+        Loc targets() default Loc.server;
+
+        /** Specifies which methods are generated. Only affects server-to-client methods. */
+        Variant variants() default Variant.all;
+
+        /** The local locations where this method is called locally, when invoked. */
+        Loc called() default Loc.none;
+
+        /** Whether to forward this packet to all other clients upon recieval. Client only. */
+        boolean forward() default false;
+
+        /**
+         * Whether the packet for this method is sent with UDP instead of TCP.
+         * UDP is faster, but is prone to packet loss and duplication.
+         */
+        boolean unreliable() default false;
+
+        /** Priority of this event. */
+        PacketPriority priority() default PacketPriority.normal;
+    }
+
+    /**
+     * Specifies that this method will be used to write classes of the type returned by {@link #value()}.<br>
+     * This method must return void and have two parameters, the first being of type {@link java.nio.ByteBuffer} and the second
+     * being the type returned by {@link #value()}.
+     */
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface WriteClass{
+        Class<?> value();
+    }
+
+    /**
+     * Specifies that this method will be used to read classes of the type returned by {@link #value()}. <br>
+     * This method must return the type returned by {@link #value()},
+     * and have one parameter, being of type {@link java.nio.ByteBuffer}.
+     */
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ReadClass{
+        Class<?> value();
+    }
+}

annotations/src/main/java/io/anuke/annotations/ClassEntry.java

@@ -0,0 +1,17 @@
+package io.anuke.annotations;
+
+import io.anuke.annotations.MethodEntry;
+
+import java.util.ArrayList;
+
+/** Represents a class witha list method entries to include in it. */
+public class ClassEntry{
+    /** All methods in this generated class. */
+    public final ArrayList<MethodEntry> methods = new ArrayList<>();
+    /** Simple class name. */
+    public final String name;
+
+    public ClassEntry(String name){
+        this.name = name;
+    }
+}

annotations/src/main/java/io/anuke/annotations/IOFinder.java

@@ -0,0 +1,90 @@
+package io.anuke.annotations;
+
+import io.anuke.annotations.Annotations.ReadClass;
+import io.anuke.annotations.Annotations.WriteClass;
+
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.type.MirroredTypeException;
+import javax.tools.Diagnostic.Kind;
+import java.util.HashMap;
+import java.util.Set;
+
+/**
+ * This class finds reader and writer methods annotated by the {@link io.anuke.annotations.Annotations.WriteClass}
+ * and {@link io.anuke.annotations.Annotations.ReadClass} annotations.
+ */
+public class IOFinder{
+
+    /**
+     * Finds all class serializers for all types and returns them. Logs errors when necessary.
+     * Maps fully qualified class names to their serializers.
+     */
+    public HashMap<String, ClassSerializer> findSerializers(RoundEnvironment env){
+        HashMap<String, ClassSerializer> result = new HashMap<>();
+
+        //get methods with the types
+        Set<? extends Element> writers = env.getElementsAnnotatedWith(WriteClass.class);
+        Set<? extends Element> readers = env.getElementsAnnotatedWith(ReadClass.class);
+
+        //look for writers first
+        for(Element writer : writers){
+            WriteClass writean = writer.getAnnotation(WriteClass.class);
+            String typeName = getValue(writean);
+
+            //make sure there's only one read method
+            if(readers.stream().filter(elem -> getValue(elem.getAnnotation(ReadClass.class)).equals(typeName)).count() > 1){
+                Utils.messager.printMessage(Kind.ERROR, "Multiple writer methods for type '" + typeName + "'", writer);
+            }
+
+            //make sure there's only one write method
+            long count = readers.stream().filter(elem -> getValue(elem.getAnnotation(ReadClass.class)).equals(typeName)).count();
+            if(count == 0){
+                Utils.messager.printMessage(Kind.ERROR, "Writer method does not have an accompanying reader: ", writer);
+            }else if(count > 1){
+                Utils.messager.printMessage(Kind.ERROR, "Writer method has multiple reader for type: ", writer);
+            }
+
+            Element reader = readers.stream().filter(elem -> getValue(elem.getAnnotation(ReadClass.class)).equals(typeName)).findFirst().get();
+
+            //add to result list
+            result.put(typeName, new ClassSerializer(Utils.getMethodName(reader), Utils.getMethodName(writer), typeName));
+        }
+
+        return result;
+    }
+
+    private String getValue(WriteClass write){
+        try{
+            Class<?> type = write.value();
+            return type.getName();
+        }catch(MirroredTypeException e){
+            return e.getTypeMirror().toString();
+        }
+    }
+
+    private String getValue(ReadClass read){
+        try{
+            Class<?> type = read.value();
+            return type.getName();
+        }catch(MirroredTypeException e){
+            return e.getTypeMirror().toString();
+        }
+    }
+
+    /** Information about read/write methods for a specific class type. */
+    public static class ClassSerializer{
+        /** Fully qualified method name of the reader. */
+        public final String readMethod;
+        /** Fully qualified method name of the writer. */
+        public final String writeMethod;
+        /** Fully qualified class type name. */
+        public final String classType;
+
+        public ClassSerializer(String readMethod, String writeMethod, String classType){
+            this.readMethod = readMethod;
+            this.writeMethod = writeMethod;
+            this.classType = classType;
+        }
+    }
+}

annotations/src/main/java/io/anuke/annotations/MethodEntry.java

@@ -0,0 +1,53 @@
+package io.anuke.annotations;
+
+import io.anuke.annotations.Annotations.Loc;
+import io.anuke.annotations.Annotations.PacketPriority;
+import io.anuke.annotations.Annotations.Variant;
+
+import javax.lang.model.element.ExecutableElement;
+
+/** Class that repesents a remote method to be constructed and put into a class. */
+public class MethodEntry{
+    /** Simple target class name. */
+    public final String className;
+    /** Fully qualified target method to call. */
+    public final String targetMethod;
+    /** Whether this method can be called on a client/server. */
+    public final Loc where;
+    /**
+     * Whether an additional 'one' and 'all' method variant is generated. At least one of these must be true.
+     * Only applicable to client (server-invoked) methods.
+     */
+    public final Variant target;
+    /** Whether this method is called locally as well as remotely. */
+    public final Loc local;
+    /** Whether this method is unreliable and uses UDP. */
+    public final boolean unreliable;
+    /** Whether to forward this method call to all other clients when a client invokes it. Server only. */
+    public final boolean forward;
+    /** Unique method ID. */
+    public final int id;
+    /** The element method associated with this entry. */
+    public final ExecutableElement element;
+    /** The assigned packet priority. Only used in clients. */
+    public final PacketPriority priority;
+
+    public MethodEntry(String className, String targetMethod, Loc where, Variant target,
+                       Loc local, boolean unreliable, boolean forward, int id, ExecutableElement element, PacketPriority priority){
+        this.className = className;
+        this.forward = forward;
+        this.targetMethod = targetMethod;
+        this.where = where;
+        this.target = target;
+        this.local = local;
+        this.id = id;
+        this.element = element;
+        this.unreliable = unreliable;
+        this.priority = priority;
+    }
+
+    @Override
+    public int hashCode(){
+        return targetMethod.hashCode();
+    }
+}

annotations/src/main/java/io/anuke/annotations/RemoteMethodAnnotationProcessor.java

@@ -0,0 +1,158 @@
+package io.anuke.annotations;
+
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+import io.anuke.annotations.Annotations.Loc;
+import io.anuke.annotations.Annotations.Remote;
+import io.anuke.annotations.IOFinder.ClassSerializer;
+
+import javax.annotation.processing.*;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic.Kind;
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+/** The annotation processor for generating remote method call code. */
+@SupportedSourceVersion(SourceVersion.RELEASE_8)
+@SupportedAnnotationTypes({
+    "io.anuke.annotations.Annotations.Remote",
+    "io.anuke.annotations.Annotations.WriteClass",
+    "io.anuke.annotations.Annotations.ReadClass",
+})
+public class RemoteMethodAnnotationProcessor extends AbstractProcessor{
+    /** Maximum size of each event packet. */
+    public static final int maxPacketSize = 4096;
+    /** Name of the base package to put all the generated classes. */
+    private static final String packageName = "io.anuke.mindustry.gen";
+
+    /** Name of class that handles reading and invoking packets on the server. */
+    private static final String readServerName = "RemoteReadServer";
+    /** Name of class that handles reading and invoking packets on the client. */
+    private static final String readClientName = "RemoteReadClient";
+    /**Simple class name of generated class name.*/
+    private static final String callLocation = "Call";
+
+    /** Processing round number. */
+    private int round;
+
+    //class serializers
+    private HashMap<String, ClassSerializer> serializers;
+    //all elements with the Remote annotation
+    private Set<? extends Element> elements;
+    //map of all classes to generate by name
+    private HashMap<String, ClassEntry> classMap;
+    //list of all method entries
+    private ArrayList<MethodEntry> methods;
+    //list of all method entries
+    private ArrayList<ClassEntry> classes;
+
+    @Override
+    public synchronized void init(ProcessingEnvironment processingEnv){
+        super.init(processingEnv);
+        //put all relevant utils into utils class
+        Utils.typeUtils = processingEnv.getTypeUtils();
+        Utils.elementUtils = processingEnv.getElementUtils();
+        Utils.filer = processingEnv.getFiler();
+        Utils.messager = processingEnv.getMessager();
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv){
+        if(round > 1) return false; //only process 2 rounds
+
+        round++;
+
+        try{
+
+            //round 1: find all annotations, generate *writers*
+            if(round == 1){
+                //get serializers
+                serializers = new IOFinder().findSerializers(roundEnv);
+                //last method ID used
+                int lastMethodID = 0;
+                //find all elements with the Remote annotation
+                elements = roundEnv.getElementsAnnotatedWith(Remote.class);
+                //map of all classes to generate by name
+                classMap = new HashMap<>();
+                //list of all method entries
+                methods = new ArrayList<>();
+                //list of all method entries
+                classes = new ArrayList<>();
+
+                List<Element> orderedElements = new ArrayList<>(elements);
+                orderedElements.sort(Comparator.comparing(Object::toString));
+
+                //create methods
+                for(Element element : orderedElements){
+                    Remote annotation = element.getAnnotation(Remote.class);
+
+                    //check for static
+                    if(!element.getModifiers().contains(Modifier.STATIC) || !element.getModifiers().contains(Modifier.PUBLIC)){
+                        Utils.messager.printMessage(Kind.ERROR, "All @Remote methods must be public and static: ", element);
+                    }
+
+                    //can't generate none methods
+                    if(annotation.targets() == Loc.none){
+                        Utils.messager.printMessage(Kind.ERROR, "A @Remote method's targets() cannot be equal to 'none':", element);
+                    }
+
+                    //get and create class entry if needed
+                    if(!classMap.containsKey(callLocation)){
+                        ClassEntry clas = new ClassEntry(callLocation);
+                        classMap.put(callLocation, clas);
+                        classes.add(clas);
+
+                        Utils.messager.printMessage(Kind.NOTE, "Generating class '" + clas.name + "'.");
+                    }
+
+                    ClassEntry entry = classMap.get(callLocation);
+
+                    //create and add entry
+                    MethodEntry method = new MethodEntry(entry.name, Utils.getMethodName(element), annotation.targets(), annotation.variants(),
+                            annotation.called(), annotation.unreliable(), annotation.forward(), lastMethodID++, (ExecutableElement) element, annotation.priority());
+
+                    entry.methods.add(method);
+                    methods.add(method);
+                }
+
+                //create read/write generators
+                RemoteWriteGenerator writegen = new RemoteWriteGenerator(serializers);
+
+                //generate the methods to invoke (write)
+                writegen.generateFor(classes, packageName);
+
+                return true;
+            }else if(round == 2){ //round 2: generate all *readers*
+                RemoteReadGenerator readgen = new RemoteReadGenerator(serializers);
+
+                //generate server readers
+                readgen.generateFor(methods.stream().filter(method -> method.where.isClient).collect(Collectors.toList()), readServerName, packageName, true);
+                //generate client readers
+                readgen.generateFor(methods.stream().filter(method -> method.where.isServer).collect(Collectors.toList()), readClientName, packageName, false);
+
+                //create class for storing unique method hash
+                TypeSpec.Builder hashBuilder = TypeSpec.classBuilder("MethodHash").addModifiers(Modifier.PUBLIC);
+                hashBuilder.addField(FieldSpec.builder(int.class, "HASH", Modifier.STATIC, Modifier.PUBLIC, Modifier.FINAL)
+                        .initializer("$1L", Objects.hash(methods)).build());
+
+                //build and write resulting hash class
+                TypeSpec spec = hashBuilder.build();
+                JavaFile.builder(packageName, spec).build().writeTo(Utils.filer);
+
+                return true;
+            }
+
+        }catch(Exception e){
+            e.printStackTrace();
+            throw new RuntimeException(e);
+        }
+
+        return false;
+    }
+}

annotations/src/main/java/io/anuke/annotations/RemoteReadGenerator.java

@@ -0,0 +1,148 @@
+package io.anuke.annotations;
+
+import com.squareup.javapoet.*;
+import io.anuke.annotations.IOFinder.ClassSerializer;
+import io.anuke.annotations.MethodEntry;
+import io.anuke.annotations.Utils;
+
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.tools.Diagnostic.Kind;
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.List;
+
+/** Generates code for reading remote invoke packets on the client and server. */
+public class RemoteReadGenerator{
+    private final HashMap<String, ClassSerializer> serializers;
+
+    /** Creates a read generator that uses the supplied serializer setup. */
+    public RemoteReadGenerator(HashMap<String, ClassSerializer> serializers){
+        this.serializers = serializers;
+    }
+
+    /**
+     * Generates a class for reading remote invoke packets.
+     *
+     * @param entries List of methods to use/
+     * @param className Simple target class name.
+     * @param packageName Full target package name.
+     * @param needsPlayer Whether this read method requires a reference to the player sender.
+     */
+    public void generateFor(List<MethodEntry> entries, String className, String packageName, boolean needsPlayer)
+            throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException, IOException{
+
+        TypeSpec.Builder classBuilder = TypeSpec.classBuilder(className).addModifiers(Modifier.PUBLIC);
+
+        //create main method builder
+        MethodSpec.Builder readMethod = MethodSpec.methodBuilder("readPacket")
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+                .addParameter(ByteBuffer.class, "buffer") //buffer to read form
+                .addParameter(int.class, "id") //ID of method type to read
+                .returns(void.class);
+
+        if(needsPlayer){
+            //since the player type isn't loaded yet, creating a type def is necessary
+            //this requires reflection since the TypeName constructor is private for some reason
+            Constructor<TypeName> cons = TypeName.class.getDeclaredConstructor(String.class);
+            cons.setAccessible(true);
+
+            TypeName playerType = cons.newInstance("io.anuke.mindustry.entities.Player");
+            //add player parameter
+            readMethod.addParameter(playerType, "player");
+        }
+
+        CodeBlock.Builder readBlock = CodeBlock.builder(); //start building block of code inside read method
+        boolean started = false; //whether an if() statement has been written yet
+
+        for(MethodEntry entry : entries){
+            //write if check for this entry ID
+            if(!started){
+                started = true;
+                readBlock.beginControlFlow("if(id == " + entry.id + ")");
+            }else{
+                readBlock.nextControlFlow("else if(id == " + entry.id + ")");
+            }
+
+            readBlock.beginControlFlow("try");
+
+            //concatenated list of variable names for method invocation
+            StringBuilder varResult = new StringBuilder();
+
+            //go through each parameter
+            for(int i = 0; i < entry.element.getParameters().size(); i++){
+                VariableElement var = entry.element.getParameters().get(i);
+
+                if(!needsPlayer || i != 0){ //if client, skip first parameter since it's always of type player and doesn't need to be read
+                    //full type name of parameter
+                    String typeName = var.asType().toString();
+                    //name of parameter
+                    String varName = var.getSimpleName().toString();
+                    //captialized version of type name for reading primitives
+                    String capName = typeName.equals("byte") ? "" : Character.toUpperCase(typeName.charAt(0)) + typeName.substring(1);
+
+                    //write primitives automatically
+                    if(Utils.isPrimitive(typeName)){
+                        if(typeName.equals("boolean")){
+                            readBlock.addStatement("boolean " + varName + " = buffer.get() == 1");
+                        }else{
+                            readBlock.addStatement(typeName + " " + varName + " = buffer.get" + capName + "()");
+                        }
+                    }else{
+                        //else, try and find a serializer
+                        ClassSerializer ser = serializers.get(typeName);
+
+                        if(ser == null){ //make sure a serializer exists!
+                            Utils.messager.printMessage(Kind.ERROR, "No @ReadClass method to read class type: '" + typeName + "'", var);
+                            return;
+                        }
+
+                        //add statement for reading it
+                        readBlock.addStatement(typeName + " " + varName + " = " + ser.readMethod + "(buffer)");
+                    }
+
+                    //append variable name to string builder
+                    varResult.append(var.getSimpleName());
+                    if(i != entry.element.getParameters().size() - 1) varResult.append(", ");
+                }else{
+                    varResult.append("player");
+                    if(i != entry.element.getParameters().size() - 1) varResult.append(", ");
+                }
+            }
+
+            //execute the relevant method before the forward
+            //if it throws a ValidateException, the method won't be forwarded
+            readBlock.addStatement("$N." + entry.element.getSimpleName() + "(" + varResult.toString() + ")", ((TypeElement) entry.element.getEnclosingElement()).getQualifiedName().toString());
+
+            //call forwarded method, don't forward on the client reader
+            if(entry.forward && entry.where.isServer && needsPlayer){
+                //call forwarded method
+                readBlock.addStatement(packageName + "." + entry.className + "." + entry.element.getSimpleName() +
+                        "__forward(player.con.id" + (varResult.length() == 0 ? "" : ", ") + varResult.toString() + ")");
+            }
+
+            readBlock.nextControlFlow("catch (java.lang.Exception e)");
+            readBlock.addStatement("throw new java.lang.RuntimeException(\"Failed to to read remote method '" + entry.element.getSimpleName() + "'!\", e)");
+            readBlock.endControlFlow();
+        }
+
+        //end control flow if necessary
+        if(started){
+            readBlock.nextControlFlow("else");
+            readBlock.addStatement("throw new $1N(\"Invalid read method ID: \" + id + \"\")", RuntimeException.class.getName()); //handle invalid method IDs
+            readBlock.endControlFlow();
+        }
+
+        //add block and method to class
+        readMethod.addCode(readBlock.build());
+        classBuilder.addMethod(readMethod.build());
+
+        //build and write resulting class
+        TypeSpec spec = classBuilder.build();
+        JavaFile.builder(packageName, spec).build().writeTo(Utils.filer);
+    }
+}

annotations/src/main/java/io/anuke/annotations/RemoteWriteGenerator.java

@@ -0,0 +1,226 @@
+package io.anuke.annotations;
+
+import com.squareup.javapoet.*;
+import io.anuke.annotations.Annotations.Loc;
+import io.anuke.annotations.IOFinder.ClassSerializer;
+
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.tools.Diagnostic.Kind;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.List;
+
+/** Generates code for writing remote invoke packets on the client and server. */
+public class RemoteWriteGenerator{
+    private final HashMap<String, ClassSerializer> serializers;
+
+    /** Creates a write generator that uses the supplied serializer setup. */
+    public RemoteWriteGenerator(HashMap<String, ClassSerializer> serializers){
+        this.serializers = serializers;
+    }
+
+    /** Generates all classes in this list. */
+    public void generateFor(List<ClassEntry> entries, String packageName) throws IOException{
+
+        for(ClassEntry entry : entries){
+            //create builder
+            TypeSpec.Builder classBuilder = TypeSpec.classBuilder(entry.name).addModifiers(Modifier.PUBLIC);
+
+            //add temporary write buffer
+            classBuilder.addField(FieldSpec.builder(ByteBuffer.class, "TEMP_BUFFER", Modifier.STATIC, Modifier.PRIVATE, Modifier.FINAL)
+                    .initializer("ByteBuffer.allocate($1L)", RemoteMethodAnnotationProcessor.maxPacketSize).build());
+
+            //go through each method entry in this class
+            for(MethodEntry methodEntry : entry.methods){
+                //write the 'send event to all players' variant: always happens for clients, but only happens if 'all' is enabled on the server method
+                if(methodEntry.where.isClient || methodEntry.target.isAll){
+                    writeMethodVariant(classBuilder, methodEntry, true, false);
+                }
+
+                //write the 'send event to one player' variant, which is only applicable on the server
+                if(methodEntry.where.isServer && methodEntry.target.isOne){
+                    writeMethodVariant(classBuilder, methodEntry, false, false);
+                }
+
+                //write the forwarded method version
+                if(methodEntry.where.isServer && methodEntry.forward){
+                    writeMethodVariant(classBuilder, methodEntry, true, true);
+                }
+            }
+
+            //build and write resulting class
+            TypeSpec spec = classBuilder.build();
+            JavaFile.builder(packageName, spec).build().writeTo(Utils.filer);
+        }
+    }
+
+    /** Creates a specific variant for a method entry. */
+    private void writeMethodVariant(TypeSpec.Builder classBuilder, MethodEntry methodEntry, boolean toAll, boolean forwarded){
+        ExecutableElement elem = methodEntry.element;
+
+        //create builder
+        MethodSpec.Builder method = MethodSpec.methodBuilder(elem.getSimpleName().toString() + (forwarded ? "__forward" : "")) //add except suffix when forwarding
+                .addModifiers(Modifier.STATIC, Modifier.SYNCHRONIZED)
+                .returns(void.class);
+
+        //forwarded methods aren't intended for use, and are not public
+        if(!forwarded){
+            method.addModifiers(Modifier.PUBLIC);
+        }
+
+        //validate client methods to make sure
+        if(methodEntry.where.isClient){
+            if(elem.getParameters().isEmpty()){
+                Utils.messager.printMessage(Kind.ERROR, "Client invoke methods must have a first parameter of type Player.", elem);
+                return;
+            }
+
+            if(!elem.getParameters().get(0).asType().toString().equals("io.anuke.mindustry.entities.Player")){
+                Utils.messager.printMessage(Kind.ERROR, "Client invoke methods should have a first parameter of type Player.", elem);
+                return;
+            }
+        }
+
+        //if toAll is false, it's a 'send to one player' variant, so add the player as a parameter
+        if(!toAll){
+            method.addParameter(int.class, "playerClientID");
+        }
+
+        //add sender to ignore
+        if(forwarded){
+            method.addParameter(int.class, "exceptSenderID");
+        }
+
+        //call local method if applicable, shouldn't happen when forwarding method as that already happens by default
+        if(!forwarded && methodEntry.local != Loc.none){
+            //add in local checks
+            if(methodEntry.local != Loc.both){
+                method.beginControlFlow("if(" + getCheckString(methodEntry.local) + " || !io.anuke.mindustry.net.Net.active())");
+            }
+
+            //concatenate parameters
+            int index = 0;
+            StringBuilder results = new StringBuilder();
+            for(VariableElement var : elem.getParameters()){
+                //special case: calling local-only methods uses the local player
+                if(index == 0 && methodEntry.where == Loc.client){
+                    results.append("io.anuke.mindustry.Vars.players[0]");
+                }else{
+                    results.append(var.getSimpleName());
+                }
+                if(index != elem.getParameters().size() - 1) results.append(", ");
+                index++;
+            }
+
+            //add the statement to call it
+            method.addStatement("$N." + elem.getSimpleName() + "(" + results.toString() + ")",
+                    ((TypeElement) elem.getEnclosingElement()).getQualifiedName().toString());
+
+            if(methodEntry.local != Loc.both){
+                method.endControlFlow();
+            }
+        }
+
+        //start control flow to check if it's actually client/server so no netcode is called
+        method.beginControlFlow("if(" + getCheckString(methodEntry.where) + ")");
+
+        //add statement to create packet from pool
+        method.addStatement("$1N packet = $2N.obtain($1N.class, $1N::new)", "io.anuke.mindustry.net.Packets.InvokePacket", "io.anuke.ucore.util.Pooling");
+        //assign buffer
+        method.addStatement("packet.writeBuffer = TEMP_BUFFER");
+        //assign priority
+        method.addStatement("packet.priority = (byte)" + methodEntry.priority.ordinal());
+        //assign method ID
+        method.addStatement("packet.type = (byte)" + methodEntry.id);
+        //rewind buffer
+        method.addStatement("TEMP_BUFFER.position(0)");
+
+        for(int i = 0; i < elem.getParameters().size(); i++){
+            //first argument is skipped as it is always the player caller
+            if((!methodEntry.where.isServer/* || methodEntry.mode == Loc.both*/) && i == 0){
+                continue;
+            }
+
+            VariableElement var = elem.getParameters().get(i);
+
+            //add parameter to method
+            method.addParameter(TypeName.get(var.asType()), var.getSimpleName().toString());
+
+            //name of parameter
+            String varName = var.getSimpleName().toString();
+            //name of parameter type
+            String typeName = var.asType().toString();
+            //captialized version of type name for writing primitives
+            String capName = typeName.equals("byte") ? "" : Character.toUpperCase(typeName.charAt(0)) + typeName.substring(1);
+            //special case: method can be called from anywhere to anywhere
+            //thus, only write the player when the SERVER is writing data, since the client is the only one who reads it
+            boolean writePlayerSkipCheck = methodEntry.where == Loc.both && i == 0;
+
+            if(writePlayerSkipCheck){ //write begin check
+                method.beginControlFlow("if(io.anuke.mindustry.net.Net.server())");
+            }
+
+            if(Utils.isPrimitive(typeName)){ //check if it's a primitive, and if so write it
+                if(typeName.equals("boolean")){ //booleans are special
+                    method.addStatement("TEMP_BUFFER.put(" + varName + " ? (byte)1 : 0)");
+                }else{
+                    method.addStatement("TEMP_BUFFER.put" +
+                            capName + "(" + varName + ")");
+                }
+            }else{
+                //else, try and find a serializer
+                ClassSerializer ser = serializers.get(typeName);
+
+                if(ser == null){ //make sure a serializer exists!
+                    Utils.messager.printMessage(Kind.ERROR, "No @WriteClass method to write class type: '" + typeName + "'", var);
+                    return;
+                }
+
+                //add statement for writing it
+                method.addStatement(ser.writeMethod + "(TEMP_BUFFER, " + varName + ")");
+            }
+
+            if(writePlayerSkipCheck){ //write end check
+                method.endControlFlow();
+            }
+        }
+
+        //assign packet length
+        method.addStatement("packet.writeLength = TEMP_BUFFER.position()");
+
+        String sendString;
+
+        if(forwarded){ //forward packet
+            if(!methodEntry.local.isClient){ //if the client doesn't get it called locally, forward it back after validation
+                sendString = "send(";
+            }else{
+                sendString = "sendExcept(exceptSenderID, ";
+            }
+        }else if(toAll){ //send to all players / to server
+            sendString = "send(";
+        }else{ //send to specific client from server
+            sendString = "sendTo(playerClientID, ";
+        }
+
+        //send the actual packet
+        method.addStatement("io.anuke.mindustry.net.Net." + sendString + "packet, " +
+                (methodEntry.unreliable ? "io.anuke.mindustry.net.Net.SendMode.udp" : "io.anuke.mindustry.net.Net.SendMode.tcp") + ")");
+
+
+        //end check for server/client
+        method.endControlFlow();
+
+        //add method to class, finally
+        classBuilder.addMethod(method.build());
+    }
+
+    private String getCheckString(Loc loc){
+        return loc.isClient && loc.isServer ? "io.anuke.mindustry.net.Net.server() || io.anuke.mindustry.net.Net.client()" :
+                loc.isClient ? "io.anuke.mindustry.net.Net.client()" :
+                        loc.isServer ? "io.anuke.mindustry.net.Net.server()" : "false";
+    }
+}

annotations/src/main/java/io/anuke/annotations/SerializeAnnotationProcessor.java

@@ -0,0 +1,110 @@
+package io.anuke.annotations;
+
+import com.squareup.javapoet.*;
+import io.anuke.annotations.Annotations.Serialize;
+
+import javax.annotation.processing.*;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.util.ElementFilter;
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+
+@SupportedSourceVersion(SourceVersion.RELEASE_8)
+@SupportedAnnotationTypes({
+"io.anuke.annotations.Annotations.Serialize"
+})
+public class SerializeAnnotationProcessor extends AbstractProcessor{
+    /**Target class name.*/
+    private static final String className = "Serialization";
+    /** Name of the base package to put all the generated classes. */
+    private static final String packageName = "io.anuke.mindustry.gen";
+
+    private int round;
+
+    @Override
+    public synchronized void init(ProcessingEnvironment processingEnv){
+        super.init(processingEnv);
+        //put all relevant utils into utils class
+        Utils.typeUtils = processingEnv.getTypeUtils();
+        Utils.elementUtils = processingEnv.getElementUtils();
+        Utils.filer = processingEnv.getFiler();
+        Utils.messager = processingEnv.getMessager();
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv){
+        if(round++ != 0) return false; //only process 1 round
+
+        try{
+            Set<TypeElement> elements = ElementFilter.typesIn(roundEnv.getElementsAnnotatedWith(Serialize.class));
+
+            TypeSpec.Builder classBuilder = TypeSpec.classBuilder(className).addModifiers(Modifier.PUBLIC);
+            MethodSpec.Builder method = MethodSpec.methodBuilder("init").addModifiers(Modifier.PUBLIC, Modifier.STATIC);
+
+            for(TypeElement elem : elements){
+                TypeName type = TypeName.get(elem.asType());
+
+                TypeSpec.Builder serializer = TypeSpec.anonymousClassBuilder("")
+                .addSuperinterface(ParameterizedTypeName.get(
+                ClassName.bestGuess("io.anuke.ucore.io.TypeSerializer"), type));
+
+                MethodSpec.Builder writeMethod = MethodSpec.methodBuilder("write")
+                .returns(void.class)
+                .addParameter(DataOutput.class, "stream")
+                .addParameter(type, "object")
+                .addAnnotation(Override.class)
+                .addException(IOException.class)
+                .addModifiers(Modifier.PUBLIC);
+
+                MethodSpec.Builder readMethod = MethodSpec.methodBuilder("read")
+                .returns(type)
+                .addParameter(DataInput.class, "stream")
+                .addAnnotation(Override.class)
+                .addException(IOException.class)
+                .addModifiers(Modifier.PUBLIC);
+
+                readMethod.addStatement("$L object = new $L()", type, type);
+
+                List<VariableElement> fields = ElementFilter.fieldsIn(Utils.elementUtils.getAllMembers(elem));
+                for(VariableElement field : fields){
+                    if(field.getModifiers().contains(Modifier.STATIC) || field.getModifiers().contains(Modifier.TRANSIENT) || field.getModifiers().contains(Modifier.PRIVATE)) continue;
+
+                    String name = field.getSimpleName().toString();
+                    String typeName = Utils.typeUtils.erasure(field.asType()).toString().replace('$', '.');
+                    String capName = Character.toUpperCase(typeName.charAt(0)) + typeName.substring(1);
+
+                    if(field.asType().getKind().isPrimitive()){
+                        writeMethod.addStatement("stream.write" + capName + "(object." + name + ")");
+                        readMethod.addStatement("object." + name + "= stream.read" + capName + "()");
+                    }else{
+                        writeMethod.addStatement("io.anuke.ucore.core.Settings.getSerializer(" + typeName+ ".class).write(stream, object." + name + ")");
+                        readMethod.addStatement("object." + name + " = (" +typeName+")io.anuke.ucore.core.Settings.getSerializer(" + typeName+ ".class).read(stream)");
+                    }
+                }
+
+                readMethod.addStatement("return object");
+
+                serializer.addMethod(writeMethod.build());
+                serializer.addMethod(readMethod.build());
+
+                method.addStatement("io.anuke.ucore.core.Settings.setSerializer($N, $L)",  Utils.elementUtils.getBinaryName(elem).toString().replace('$', '.') + ".class", serializer.build());
+            }
+
+            classBuilder.addMethod(method.build());
+
+            //write result
+            JavaFile.builder(packageName, classBuilder.build()).build().writeTo(Utils.filer);
+
+            return true;
+        }catch(Exception e){
+            e.printStackTrace();
+            throw new RuntimeException(e);
+        }
+    }
+}

annotations/src/main/java/io/anuke/annotations/Utils.java

@@ -0,0 +1,24 @@
+package io.anuke.annotations;
+
+import javax.annotation.processing.Filer;
+import javax.annotation.processing.Messager;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+
+public class Utils{
+    public static Types typeUtils;
+    public static Elements elementUtils;
+    public static Filer filer;
+    public static Messager messager;
+
+    public static String getMethodName(Element element){
+        return ((TypeElement) element.getEnclosingElement()).getQualifiedName().toString() + "." + element.getSimpleName();
+    }
+
+    public static boolean isPrimitive(String type){
+        return type.equals("boolean") || type.equals("byte") || type.equals("short") || type.equals("int")
+                || type.equals("long") || type.equals("float") || type.equals("double") || type.equals("char");
+    }
+}