Massive amount of fixes and changes with multiplayer/annotations

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

@@ -15,22 +15,19 @@ public class Annotations {
     @Target(ElementType.METHOD)
     @Retention(RetentionPolicy.CLASS)
     public @interface Remote {
-        /**If true, this method can only be invoked on clients from the server.
-         * If false, this method can only be invoked on servers from a client.*/
-        boolean server() default true;
-        /**Whether a client-specific method is generated that accepts a connecton ID and sends to only one player. Default is false.
-         * Only affects client methods.*/
-        boolean one() default false;
-        /**Whether a 'global' method is generated that sends the event to all players. Default is true.
-         * Only affects client methods.*/
-        boolean all() default true;
-        /**Whether this method is invoked locally as well as remotely.*/
-        boolean local() default true;
+        /**Specifies the locations where this method can be invoked.*/
+        Loc targets() default Loc.server;
+        /**Specifies which methods are generated. Only affects client methods.*/
+        Variant variants() default Variant.all;
+        /**The local locations where this method is called.*/
+        Loc called() default Loc.none;
+        /**Whether to forward this packet to all other clients.*/
+        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;
         /**The simple class name where this method is placed.*/
-        String target() default "Call";
+        String in() default "Call";
     }
 
     /**Specifies that this method will be used to write classes of the type returned by {@link #value()}.<br>
@@ -50,4 +47,42 @@ public class Annotations {
     public @interface ReadClass {
         Class<?> value();
     }
+
+    /**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 no 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;
+        }
+    }
 }

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

@@ -1,5 +1,8 @@
 package io.anuke.annotations;
 
+import io.anuke.annotations.Annotations.Loc;
+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.*/
@@ -9,26 +12,28 @@ public class MethodEntry {
     /**Fully qualified target method to call.*/
     public final String targetMethod;
     /**Whether this method can be called on a client/server.*/
-    public final boolean 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 boolean allVariant, oneVariant;
+    public final Variant target;
     /**Whether this method is called locally as well as remotely.*/
-    public final boolean local;
+    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;
 
-    public MethodEntry(String className, String targetMethod, boolean server,
-                       boolean allVariant, boolean oneVariant, boolean local, boolean unreliable, int id, ExecutableElement element) {
+    public MethodEntry(String className, String targetMethod, Loc where, Variant target,
+                       Loc local, boolean unreliable, boolean forward, int id, ExecutableElement element) {
         this.className = className;
+        this.forward = forward;
         this.targetMethod = targetMethod;
-        this.server = server;
-        this.allVariant = allVariant;
-        this.oneVariant = oneVariant;
+        this.where = where;
+        this.target = target;
         this.local = local;
         this.id = id;
         this.element = element;

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

@@ -3,6 +3,7 @@ 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;
 
@@ -38,8 +39,19 @@ public class RemoteMethodAnnotationProcessor extends AbstractProcessor {
     /**Name of class that handles reading and invoking packets on the client.*/
     private static final String readClientName = "RemoteReadClient";
 
-    /**Whether the initial round is done.*/
-    private boolean done;
+    /**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) {
@@ -53,83 +65,91 @@ public class RemoteMethodAnnotationProcessor extends AbstractProcessor {
 
     @Override
     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
-        if(done) return false; //only process 1 round
-        done = true;
+        if(round > 1) return false; //only process 2 rounds
+
+        round ++;
 
         try {
 
-            //get serializers
-            HashMap<String, ClassSerializer> serializers = new IOFinder().findSerializers(roundEnv);
+            //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
-            Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Remote.class);
-            //map of all classes to generate by name
-            HashMap<String, ClassEntry> classMap = new HashMap<>();
-            //list of all method entries
-            ArrayList<MethodEntry> methods = new ArrayList<>();
-            //list of all method entries
-            ArrayList<ClassEntry> classes = new ArrayList<>();
+                //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<>();
 
-            //create methods
-            for (Element element : elements) {
-                Remote annotation = element.getAnnotation(Remote.class);
+                //create methods
+                for (Element element : elements) {
+                    Remote annotation = element.getAnnotation(Remote.class);
 
-                //check for static
-                if(!element.getModifiers().contains(Modifier.STATIC)) {
-                    Utils.messager.printMessage(Kind.ERROR, "All Remote methods must be static: ", element);
+                    //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 where() cannot be equal to 'none':", element);
+                    }
+
+                    //get and create class entry if needed
+                    if (!classMap.containsKey(annotation.in())) {
+                        ClassEntry clas = new ClassEntry(annotation.in());
+                        classMap.put(annotation.in(), clas);
+                        classes.add(clas);
+                    }
+
+                    ClassEntry entry = classMap.get(annotation.in());
+
+                    //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);
+
+                    entry.methods.add(method);
+                    methods.add(method);
                 }
 
-                //get and create class entry if needed
-                if (!classMap.containsKey(annotation.target())) {
-                    ClassEntry clas = new ClassEntry(annotation.target());
-                    classMap.put(annotation.target(), clas);
-                    classes.add(clas);
-                }
+                //create read/write generators
+                RemoteWriteGenerator writegen = new RemoteWriteGenerator(serializers);
 
-                ClassEntry entry = classMap.get(annotation.target());
+                //generate the methods to invoke (write)
+                writegen.generateFor(classes, packageName);
 
-                //make sure that each server annotation has at least one method to generate, otherwise throw an error
-                if (annotation.server() && !annotation.all() && !annotation.one()) {
-                    Utils.messager.printMessage(Kind.ERROR, "A client method must not have all() and one() both be false!", element);
-                    return false;
-                }
+                return true;
+            }else if(round == 2) { //round 2: generate all *readers*
+                RemoteReadGenerator readgen = new RemoteReadGenerator(serializers);
 
-                //create and add entry
-                MethodEntry method = new MethodEntry(entry.name, Utils.getMethodName(element), annotation.server(),
-                        annotation.all(), annotation.one(), annotation.local(), annotation.unreliable(), lastMethodID ++, (ExecutableElement)element);
+                //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);
 
-                entry.methods.add(method);
-                methods.add(method);
+                //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;
             }
 
-            //create read/write generators
-            RemoteReadGenerator readgen = new RemoteReadGenerator(serializers);
-            RemoteWriteGenerator writegen = new RemoteWriteGenerator(serializers);
-
-            //generate server readers
-            readgen.generateFor(methods.stream().filter(method -> !method.server).collect(Collectors.toList()), readServerName, packageName, true);
-            //generate client readers
-            readgen.generateFor(methods.stream().filter(method -> method.server).collect(Collectors.toList()), readClientName, packageName, false);
-
-            //generate the methods to invoke (write)
-            writegen.generateFor(classes, packageName);
-
-            //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/io/anuke/annotations/RemoteReadGenerator.java

@@ -70,9 +70,8 @@ public class RemoteReadGenerator {
             for(int i = 0; i < entry.element.getParameters().size(); i ++){
                 VariableElement var = entry.element.getParameters().get(i);
 
-                if(entry.server || i != 0) { //if client, skip first parameter since it's always of type player and doesn't need to be read
+                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
-                    //TODO check if the result is correct
                     String typeName = var.asType().toString();
                     //name of parameter
                     String varName = var.getSimpleName().toString();
@@ -98,16 +97,41 @@ public class RemoteReadGenerator {
                         //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(", ");
+                    //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(", ");
+                }
             }
 
-            //now execute it
-            readBlock.addStatement("com.badlogic.gdx.Gdx.app.postRunnable(() -> $N." + entry.element.getSimpleName() + "(" + varResult.toString() + "))",
-                    ((TypeElement)entry.element.getEnclosingElement()).getQualifiedName().toString());
+
+
+            //begin lambda control flow
+            readBlock.beginControlFlow("com.badlogic.gdx.Gdx.app.postRunnable(() -> ");
+
+            //call forwarded method before the method, so if it throws a ValidateException, the method won't be forwarded
+            if(entry.forward && entry.where.isServer){
+                //try block to catch validate exception
+                readBlock.beginControlFlow("try");
+
+                //call forwarded method
+                readBlock.addStatement(packageName + "." + entry.className + "." + entry.element.getSimpleName() +
+                        "__forward(player.clientid" + (varResult.length() == 0 ? "" : ", ") + varResult.toString() + ")");
+
+                //when a ValidateException is caught, print the error and return
+                readBlock.nextControlFlow("catch (io.anuke.mindustry.net.ValidateException e)");
+                readBlock.addStatement("e.printStackTrace()");
+                readBlock.addStatement("return");
+                readBlock.endControlFlow();
+            }
+
+            //execute the relevant method
+            readBlock.addStatement("$N." + entry.element.getSimpleName() + "(" + varResult.toString() + ")", ((TypeElement) entry.element.getEnclosingElement()).getQualifiedName().toString());
+            //end lambda
+            readBlock.endControlFlow(")");
         }
 
         //end control flow if necessary

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

@@ -1,6 +1,7 @@
 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;
@@ -27,6 +28,7 @@ public class RemoteWriteGenerator {
 
         for(ClassEntry entry : entries){
             //create builder
+            System.out.println("Generating class! " + entry.name);
             TypeSpec.Builder classBuilder = TypeSpec.classBuilder(entry.name).addModifiers(Modifier.PUBLIC);
 
             //add temporary write buffer
@@ -36,13 +38,18 @@ public class RemoteWriteGenerator {
             //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.server || methodEntry.allVariant){
-                    writeMethodVariant(classBuilder, methodEntry, true);
+                if(methodEntry.where.isClient || methodEntry.target.isAll){
+                    writeMethodVariant(classBuilder, methodEntry, true, false);
                 }
 
-                //write the 'send even to one player' variant, which is only applicable on the server
-                if(methodEntry.server && methodEntry.oneVariant){
-                    writeMethodVariant(classBuilder, methodEntry, 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);
                 }
             }
 
@@ -53,16 +60,16 @@ public class RemoteWriteGenerator {
     }
 
     /**Creates a specific variant for a method entry.*/
-    private void writeMethodVariant(TypeSpec.Builder classBuilder, MethodEntry methodEntry, boolean toAll){
+    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())
-                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+        MethodSpec.Builder method = MethodSpec.methodBuilder(elem.getSimpleName().toString() + (forwarded ? "__forward" : "")) //add except suffix when forwarding
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.SYNCHRONIZED)
                 .returns(void.class);
 
         //validate client methods to make sure
-        if(!methodEntry.server){
+        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;
@@ -79,8 +86,18 @@ public class RemoteWriteGenerator {
             method.addParameter(int.class, "playerClientID");
         }
 
-        //call local method if applicable
-        if(methodEntry.local && methodEntry.server){
+        //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();
@@ -93,21 +110,27 @@ public class RemoteWriteGenerator {
             //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(io.anuke.mindustry.net.Net." + (!methodEntry.server ? "client" : "server")+"())");
+        method.beginControlFlow("if("+getCheckString(methodEntry.where)+")");
 
         //add statement to create packet from pool
         method.addStatement("$1N packet = $2N.obtain($1N.class)", "io.anuke.mindustry.net.Packets.InvokePacket", "com.badlogic.gdx.utils.Pools");
         //assign buffer
         method.addStatement("packet.writeBuffer = TEMP_BUFFER");
+        //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.server && i == 0){
+            if((!methodEntry.where.isServer/* || methodEntry.mode == Loc.both*/) && i == 0){
                 continue;
             }
 
@@ -147,21 +170,31 @@ public class RemoteWriteGenerator {
         //assign packet length
         method.addStatement("packet.writeLength = TEMP_BUFFER.position()");
 
-        //send the actual packet
-        if(toAll){
-            //send to all players / to server
-            method.addStatement("io.anuke.mindustry.net.Net.send(packet, "+
-                    (methodEntry.unreliable ? "io.anuke.mindustry.net.Net.SendMode.udp" : "io.anuke.mindustry.net.Net.SendMode.tcp")+")");
-        }else{
-            //send to specific client from server
-            method.addStatement("io.anuke.mindustry.net.Net.sendTo(playerClientID, packet, "+
-                    (methodEntry.unreliable ? "io.anuke.mindustry.net.Net.SendMode.udp" : "io.anuke.mindustry.net.Net.SendMode.tcp")+")");
+        String sendString;
+
+        if(forwarded){ //forward packet
+            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";
+    }
 }