Fixed custom client inversion

Added edit logging and whole world rollback

.gitignore

@@ -9,8 +9,12 @@
 /desktop/mindustry-maps/
 /desktop/gifexport/
 /core/lib/
+/core/assets-raw/sprites/generated/
+/annotations/build/
 /kryonet/build/
+/packer/build/
 /server/build/
+/annotations/build/
 /android/assets/mindustry-maps/
 /android/assets/mindustry-saves/
 /core/assets/gifexport/

README.md

@@ -38,6 +38,4 @@ After building, the output .JAR file should be in the output JAR file should be
 
 <a href="https://anuke.itch.io/mindustry"><img src="https://i.imgur.com/sk26hTV.png" width="auto" height="75"></a>
 
-<a href="https://anuke.itch.io/mindustry"><img src="https://i.imgur.com/ZSPVQpn.gif" width="auto" height="75"></a>
-
 <a href="https://play.google.com/store/apps/details?id=io.anuke.mindustry&hl=en"><img src="https://i.imgur.com/8dF6l81.png" width="auto" height="75"></a>

android/AndroidManifest.xml

@@ -9,22 +9,58 @@
     <uses-permission android:name="android.permission.INTERNET" />
 
     <application
-        android:allowBackup="true"
+            android:resizeableActivity="false"
-        android:icon="@mipmap/ic_launcher"
+            android:allowBackup="true"
-        android:roundIcon="@mipmap/ic_launcher_round"
+            android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
+            android:roundIcon="@mipmap/ic_launcher_round"
-        android:theme="@style/GdxTheme" >
+            android:isGame="true"
+            android:appCategory="game"
+            android:label="@string/app_name"
+            android:theme="@style/GdxTheme" android:fullBackupContent="@xml/backup_rules">
         <activity
             android:name="io.anuke.mindustry.AndroidLauncher"
             android:label="@string/app_name"
-            android:screenOrientation="sensorLandscape"
+            android:screenOrientation="sensor"
             android:configChanges="keyboard|keyboardHidden|orientation|screenSize">
+
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <category android:name="android.intent.category.BROWSABLE"/>
+                <data android:mimeType="application/octet-stream"/>
+                <data android:scheme="file" android:host="*" android:pathPattern=".*\\.mmap" />
+            </intent-filter>
+
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <category android:name="android.intent.category.BROWSABLE"/>
+                <data android:mimeType="application/octet-stream"/>
+                <data android:scheme="file" android:host="*" android:pathPattern=".*\\.msav" />
+            </intent-filter>
+
+
+            <intent-filter android:icon="@mipmap/ic_launcher"
+                           android:label="Mindustry Map"
+                           android:priority="1">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:scheme="file"   android:host="*" android:pathPattern=".*\\.mmap"  android:mimeType="*/*"  />
+            </intent-filter>
+
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:scheme="file"  android:host="*" android:pathPattern=".*\\.msav" android:mimeType="*/*"  />
+            </intent-filter>
         </activity>
 
+
         <activity android:name=".DonationsActivity"
             android:theme="@style/GdxTheme" />
 

android/build.gradle

@@ -1,4 +1,8 @@
 
+apply plugin: "com.android.application"
+
+configurations { natives }
+
 repositories {
 	mavenCentral()
     jcenter()
@@ -8,9 +12,20 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.android.support:support-v4:22.1.1'
+    implementation project(":core")
+    implementation project(":kryonet")
+    implementation 'com.android.support:support-v4:25.3.1'
     implementation 'org.sufficientlysecure:donations:2.5'
     implementation 'com.google.android.gms:play-services-auth:11.8.0'
+
+    implementation "com.badlogicgames.gdx:gdx-backend-android:$gdxVersion"
+    natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-armeabi"
+    natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-armeabi-v7a"
+    natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-arm64-v8a"
+    natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-x86"
+    natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-x86_64"
+    implementation "com.badlogicgames.gdx:gdx-ai:$aiVersion"
+    implementation "com.badlogicgames.gdx:gdx-controllers-android:$gdxVersion"
 }
 
 task deploy(type: Copy){
@@ -22,8 +37,8 @@ task deploy(type: Copy){
 }
 
 android {
-    buildToolsVersion '26.0.2'
+    buildToolsVersion '27.0.3'
-    compileSdkVersion 26
+    compileSdkVersion 27
     sourceSets {
         main {
             manifest.srcFile 'AndroidManifest.xml'
@@ -35,7 +50,7 @@ android {
             jniLibs.srcDirs = ['libs']
         }
 
-        instrumentTest.setRoot('tests')
+        androidTest.setRoot('tests')
     }
     packagingOptions {
         exclude 'META-INF/robovm/ios/robovm.xml'

android/res/layout-v14/gdxdialogs_inputtext.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/layout_root"
-    android:layout_width="fill_parent"
-    android:layout_height="fill_parent"
-    android:orientation="vertical"
-    android:padding="10dp" >
-
-    <EditText
-        android:id="@+id/gdxDialogsEditTextInput"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:inputType="text"
-        android:maxLines="1"
-        android:maxLength="15"
-         >
- 
-        <requestFocus />
- 
-    </EditText>
- 
-</LinearLayout>

android/res/layout/gdxdialogs_inputtext.xml

@@ -6,27 +6,6 @@
     android:orientation="vertical"
     android:padding="10dp" >
 
-    <TextView
-        android:id="@+id/gdxDialogsEnterTitle"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        
-        android:textAppearance="?android:attr/textAppearanceLarge"
-        
-        
-         />
-    
-    <TextView
-        android:id="@+id/gdxDialogsEnterMessage"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        
-        android:textAppearance="?android:attr/textAppearanceMedium"
-        
-        
-         />
-    
- 
     <EditText
         android:id="@+id/gdxDialogsEditTextInput"
         android:layout_width="match_parent"

android/res/values-v21/styles.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-
     <style name="GdxTheme" parent="android:Theme.Material.NoActionBar">
         <item name="android:windowBackground">@android:color/transparent</item>
         <item name="android:colorBackgroundCacheHint">@null</item>
@@ -9,11 +8,4 @@
         <item name="android:windowContentOverlay">@null</item>
         <item name="android:windowFullscreen">true</item>
     </style>
-
-    <style name="LightBackground" parent="android:Theme.Material.Light" >
-        <item name="android:colorBackground">@android:color/black</item>
-        <item name="android:textColorPrimary">@android:color/white</item>
-        <item name="android:textColorSecondary">@android:color/white</item>
-        <item name="android:textColorSecondaryInverse">@android:color/white</item>
-    </style>
 </resources>

android/res/xml/backup_rules.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<full-backup-content>
+
+</full-backup-content>

android/src/io/anuke/mindustry/AndroidLauncher.java

@@ -3,14 +3,18 @@ package io.anuke.mindustry;
 import android.Manifest;
 import android.content.Context;
 import android.content.Intent;
+import android.content.pm.ActivityInfo;
 import android.content.pm.PackageManager;
+import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
 import android.provider.Settings.Secure;
 import android.telephony.TelephonyManager;
 import android.util.Log;
+import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.backends.android.AndroidApplication;
 import com.badlogic.gdx.backends.android.AndroidApplicationConfiguration;
+import com.badlogic.gdx.files.FileHandle;
 import com.badlogic.gdx.utils.Base64Coder;
 import com.google.android.gms.common.GoogleApiAvailability;
 import com.google.android.gms.common.GooglePlayServicesNotAvailableException;
@@ -19,23 +23,36 @@ import com.google.android.gms.security.ProviderInstaller;
 import io.anuke.kryonet.DefaultThreadImpl;
 import io.anuke.kryonet.KryoClient;
 import io.anuke.kryonet.KryoServer;
+import io.anuke.mindustry.core.Platform;
 import io.anuke.mindustry.core.ThreadHandler.ThreadProvider;
-import io.anuke.mindustry.io.Platform;
+import io.anuke.mindustry.io.SaveIO;
+import io.anuke.mindustry.io.Saves.SaveSlot;
 import io.anuke.mindustry.net.Net;
-import io.anuke.ucore.core.Settings;
+import io.anuke.mindustry.ui.dialogs.FileChooser;
+import io.anuke.ucore.function.Consumer;
 import io.anuke.ucore.scene.ui.TextField;
 import io.anuke.ucore.scene.ui.layout.Unit;
+import io.anuke.ucore.util.Bundles;
+import io.anuke.ucore.util.Strings;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
 import java.text.DateFormat;
 import java.text.NumberFormat;
 import java.text.SimpleDateFormat;
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.Locale;
-import java.util.Random;
+
+import static io.anuke.mindustry.Vars.*;
 
 public class AndroidLauncher extends AndroidApplication{
+	public static final int PERMISSION_REQUEST_CODE = 1;
+
 	boolean doubleScaleTablets = true;
-	int WRITE_REQUEST_CODE = 1;
+	FileChooser chooser;
 
 	@Override
 	protected void onCreate(Bundle savedInstanceState){
@@ -77,26 +94,6 @@ public class AndroidLauncher extends AndroidApplication{
 				showDonations();
 			}
 
-			@Override
-			public void requestWritePerms() {
-				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-					if(checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED &&
-							checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
-						requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE,
-								Manifest.permission.READ_EXTERNAL_STORAGE}, WRITE_REQUEST_CODE);
-					}else{
-
-						if (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
-							requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, WRITE_REQUEST_CODE);
-						}
-
-						if (checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
-							requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, WRITE_REQUEST_CODE);
-						}
-					}
-				}
-			}
-
 			@Override
 			public ThreadProvider getThreadProvider() {
 				return new DefaultThreadImpl();
@@ -108,7 +105,7 @@ public class AndroidLauncher extends AndroidApplication{
 			}
 
 			@Override
-			public byte[] getUUID() {
+			public String getUUID() {
 				try {
 					String s = Secure.getString(getContext().getContentResolver(),
 							Secure.ANDROID_ID);
@@ -120,23 +117,58 @@ public class AndroidLauncher extends AndroidApplication{
 								+ Character.digit(s.charAt(i + 1), 16));
 					}
 
-					if(new String(Base64Coder.encode(data)).equals("AAAAAAAAAOA=")) throw new RuntimeException("Bad UUID.");
+					String result = new String(Base64Coder.encode(data));
 
-					return data;
+					if(result.equals("AAAAAAAAAOA=")) throw new RuntimeException("Bad UUID.");
+
+					return result;
 				}catch (Exception e){
-
+					return super.getUUID();
-                    String uuid = Settings.getString("uuid", "");
-                    if(uuid.isEmpty()){
-                        byte[] result = new byte[8];
-                        new Random().nextBytes(result);
-                        uuid = new String(Base64Coder.encode(result));
-                        Settings.putString("uuid", uuid);
-                        Settings.save();
-                        return result;
-                    }
-                    return Base64Coder.decode(uuid);
 				}
 			}
+
+			@Override
+			public void shareFile(FileHandle file){
+
+			}
+
+			@Override
+			public void showFileChooser(String text, String content, Consumer<FileHandle> cons, boolean open, String filetype) {
+				chooser = new FileChooser(text, file -> file.extension().equalsIgnoreCase(filetype), open, cons);
+
+				if(Build.VERSION.SDK_INT < Build.VERSION_CODES.M || (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED &&
+						checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED)){
+					chooser.show();
+					chooser = null;
+				}else {
+					ArrayList<String> perms = new ArrayList<>();
+
+					if (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+						perms.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
+					}
+
+					if (checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+						perms.add(Manifest.permission.READ_EXTERNAL_STORAGE);
+					}
+
+					requestPermissions(perms.toArray(new String[perms.size()]), PERMISSION_REQUEST_CODE);
+				}
+			}
+
+			@Override
+			public void beginForceLandscape() {
+				setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+			}
+
+			@Override
+			public void endForceLandscape() {
+				setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
+			}
+
+			@Override
+			public boolean canDonate(){
+				return true;
+			}
 		};
 
 		try {
@@ -158,6 +190,78 @@ public class AndroidLauncher extends AndroidApplication{
         Net.setServerProvider(new KryoServer());
 
         initialize(new Mindustry(), config);
+
+		checkFiles(getIntent());
+	}
+
+	@Override
+	public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
+		if(requestCode == PERMISSION_REQUEST_CODE){
+			for(int i : grantResults){
+				if(i != PackageManager.PERMISSION_GRANTED) return;
+			}
+
+			if(chooser != null){
+				chooser.show();
+			}
+		}
+	}
+
+	private void checkFiles(Intent intent){
+		try {
+			Uri uri = intent.getData();
+			if (uri != null) {
+				File myFile = null;
+				String scheme = uri.getScheme();
+				if (scheme.equals("file")) {
+					String fileName = uri.getEncodedPath();
+					myFile = new File(fileName);
+				} else if (!scheme.equals("content")) {
+					//error
+					return;
+				}
+
+				boolean save = uri.getPath().endsWith(saveExtension);
+				boolean map = uri.getPath().endsWith(mapExtension);
+
+				InputStream inStream;
+				if (myFile != null) inStream = new FileInputStream(myFile);
+				else inStream = getContentResolver().openInputStream(uri);
+
+				Gdx.app.postRunnable(() -> {
+
+					if(save){ //open save
+						System.out.println("Opening save.");
+						FileHandle file = Gdx.files.local("temp-save." + saveExtension);
+						file.write(inStream, false);
+
+						if(SaveIO.isSaveValid(file)){
+							try{
+								SaveSlot slot = control.getSaves().importSave(file);
+								ui.load.runLoadSave(slot);
+							}catch (IOException e){
+								ui.showError(Bundles.format("text.save.import.fail", Strings.parseException(e, false)));
+							}
+						}else{
+							ui.showError("$text.save.import.invalid");
+						}
+
+					}else if(map){ //open map
+						Gdx.app.postRunnable(() -> {
+							System.out.println("Opening map.");
+							if (!ui.editor.isShown()) {
+								ui.editor.show();
+							}
+
+							ui.editor.beginEditMap(inStream);
+						});
+					}
+				});
+			}
+
+		}catch (IOException e){
+			e.printStackTrace();
+		}
 	}
 	
 	private boolean isPackageInstalled(String packagename) {

android/src/io/anuke/mindustry/AndroidTextFieldDialog.java

@@ -25,7 +25,6 @@ public class AndroidTextFieldDialog{
 	public AndroidTextFieldDialog show() {
 
 		activity.runOnUiThread(() -> {
-            Gdx.app.error("Android Dialogs", AndroidTextFieldDialog.class.getSimpleName() + " now shown.");
             AlertDialog dialog = builder.create();
 
             dialog.getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_VISIBLE);
@@ -48,7 +47,7 @@ public class AndroidTextFieldDialog{
 
             alertDialogBuilder.setView(promptsView);
 
-            userInput = (EditText) promptsView.findViewById(getResourceId("gdxDialogsEditTextInput", "id"));
+            userInput = promptsView.findViewById(getResourceId("gdxDialogsEditTextInput", "id"));
 
             alertDialogBuilder.setCancelable(false);
             builder = alertDialogBuilder;

annotations/build.gradle

@@ -0,0 +1,4 @@
+apply plugin: "java"
+
+sourceCompatibility = 1.8
+sourceSets.main.java.srcDirs = [ "src/" ]

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

@@ -0,0 +1,99 @@
+package io.anuke.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Goal: To create a system to send events to the server from the client and vice versa, without creating a new packet type each time.<br>
+ * These events may optionally also trigger on the caller client/server as well.<br>
+ */
+public class Annotations {
+
+    /**Marks a method as invokable remotely across a server/client connection.*/
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.CLASS)
+    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. Server 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;
+        /**The simple class name where this method is placed.*/
+        String in() default "Call";
+        /**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.CLASS)
+    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.CLASS)
+    public @interface ReadClass {
+        Class<?> value();
+    }
+
+    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 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/ClassEntry.java

@@ -0,0 +1,15 @@
+package io.anuke.annotations;
+
+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/io/anuke/annotations/IOFinder.java

@@ -0,0 +1,86 @@
+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/io/anuke/annotations/MethodEntry.java

@@ -0,0 +1,51 @@
+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/io/anuke/annotations/RemoteMethodAnnotationProcessor.java

@@ -0,0 +1,157 @@
+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";
+
+    /**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(annotation.in())) {
+                        ClassEntry clas = new ClassEntry(annotation.in());
+                        classMap.put(annotation.in(), clas);
+                        classes.add(clas);
+
+                        Utils.messager.printMessage(Kind.NOTE, "Generating class '" + clas.name + "'.");
+                    }
+
+                    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, 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/io/anuke/annotations/RemoteReadGenerator.java

@@ -0,0 +1,143 @@
+package io.anuke.annotations;
+
+import com.squareup.javapoet.*;
+import io.anuke.annotations.IOFinder.ClassSerializer;
+
+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/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)", "io.anuke.mindustry.net.Packets.InvokePacket", "com.badlogic.gdx.utils.Pools");
+        //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/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");
+    }
+}

build.gradle

@@ -9,7 +9,7 @@ buildscript {
     dependencies {
         classpath 'com.mobidevelop.robovm:robovm-gradle-plugin:2.3.0'
         classpath 'de.richsource.gradle.plugins:gwt-gradle-plugin:0.6'
-        classpath 'com.android.tools.build:gradle:3.0.1'
+        classpath 'com.android.tools.build:gradle:3.1.0'
         classpath "com.badlogicgames.gdx:gdx-tools:1.9.8"
     }
 }
@@ -21,13 +21,13 @@ allprojects {
     version = 'release'
 
     ext {
-        versionNumber = '3.5'
+        versionNumber = '4.0'
-        versionType = 'release'
+        versionType = 'alpha'
         appName = 'Mindustry'
         gdxVersion = '1.9.8'
         roboVMVersion = '2.3.0'
         aiVersion = '1.8.1'
-        uCoreVersion = '55f0d90'
+        uCoreVersion = 'e7a37cff68'
 
         getVersionString = {
             String buildVersion = getBuildVersion()
@@ -85,7 +85,8 @@ project(":desktop") {
         compile "com.badlogicgames.gdx:gdx-backend-lwjgl3:$gdxVersion"
         compile "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-desktop"
         compile "com.badlogicgames.gdx:gdx-controllers-lwjgl3:$gdxVersion"
-        compile 'com.github.MinnDevelopment:java-discord-rpc:v1.3.2'
+        compile 'com.github.MinnDevelopment:java-discord-rpc:v2.0.0'
+        compile 'com.yuvimasory:orange-extensions:1.3.0'
     }
 }
 
@@ -96,6 +97,8 @@ project(":html") {
 
     dependencies {
         compile project(":core")
+        compileOnly project(":annotations")
+
         compile "com.badlogicgames.gdx:gdx-backend-gwt:$gdxVersion"
         compile "com.badlogicgames.gdx:gdx:$gdxVersion:sources"
         compile "com.badlogicgames.gdx:gdx-backend-gwt:$gdxVersion:sources"
@@ -107,25 +110,10 @@ project(":html") {
         compile "com.sksamuel.gwt:gwt-websockets:1.0.4"
         compile "com.sksamuel.gwt:gwt-websockets:1.0.4:sources"
     }
-}
 
-project(":android") {
+    compileJava.options.compilerArgs = [
-    apply plugin: "android"
+        "-processor", "io.anuke.annotations.RemoteMethodAnnotationProcessor"
-
+    ]
-    configurations { natives }
-
-    dependencies {
-        implementation project(":core")
-        implementation project(":kryonet")
-        implementation "com.badlogicgames.gdx:gdx-backend-android:$gdxVersion"
-        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-armeabi"
-        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-armeabi-v7a"
-        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-arm64-v8a"
-        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-x86"
-        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-x86_64"
-        implementation "com.badlogicgames.gdx:gdx-ai:$aiVersion"
-        implementation "com.badlogicgames.gdx:gdx-controllers-android:$gdxVersion"
-    }
 }
 
 project(":ios") {
@@ -142,17 +130,14 @@ project(":ios") {
         compile "com.badlogicgames.gdx:gdx-backend-robovm:$gdxVersion"
         compile "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-ios"
     }
-
-    robovm {
-        iosSignIdentity = "a"
-        iosProvisioningProfile = ""
-    }
 }
 
 project(":core") {
     apply plugin: "java"
 
     dependencies {
+        compileOnly project(":annotations")
+
         boolean comp = System.properties["release"] == null || System.properties["release"] == "false"
 
         if(!comp){
@@ -161,25 +146,31 @@ project(":core") {
             println("Compiling DEBUG build.")
         }
 
-        if(new File('../uCore').exists() && comp){
+        if(new File(projectDir.parent, '../uCore').exists() && comp){
             compile project(":uCore")
         }else{
             compile "com.github.anuken:ucore:$uCoreVersion"
         }
 
-        if(new File('../GDXGifRecorder').exists() && comp) {
+        if(new File(projectDir.parent, '../GDXGifRecorder').exists() && comp) {
             compile project(":GDXGifRecorder")
         }
+
         compile "com.badlogicgames.gdx:gdx:$gdxVersion"
-        compile "com.badlogicgames.gdx:gdx-ai:$aiVersion"
         compile "com.badlogicgames.gdx:gdx-controllers:$gdxVersion"
     }
+
+    compileJava.options.compilerArgs = [
+        "-processor", "io.anuke.annotations.RemoteMethodAnnotationProcessor"
+    ]
 }
 
 project(":server") {
     apply plugin: "java"
 
     dependencies {
+        compileOnly project(":annotations")
+
         compile project(":core")
         compile project(":kryonet")
         compile "com.badlogicgames.gdx:gdx-backend-headless:$gdxVersion"
@@ -187,6 +178,22 @@ project(":server") {
     }
 }
 
+project(":packer") {
+    apply plugin: "java"
+
+    dependencies {
+        compile project(":core")
+    }
+}
+
+project(":annotations") {
+    apply plugin: "java"
+
+    dependencies {
+        compile 'com.squareup:javapoet:1.11.0'
+    }
+}
+
 project(":kryonet") {
     apply plugin: "java"