....

annotations/src/main/java/mindustry/annotations/BaseProcessor.java

@@ -44,6 +44,23 @@ public abstract class BaseProcessor extends AbstractProcessor{
         || type.equals("long") || type.equals("float") || type.equals("double") || type.equals("char");
     }
 
+    public static String getDefault(String value){
+        switch(value){
+            case "float":
+            case "double":
+            case "int":
+            case "long":
+            case "short":
+            case "char":
+            case "byte":
+                return "0";
+            case "boolean":
+                return "false";
+            default:
+                return "null";
+        }
+    }
+
     public static String simpleName(String str){
         return str.contains(".") ? str.substring(str.lastIndexOf('.') + 1) : str;
     }

annotations/src/main/java/mindustry/annotations/impl/EntityProcess.java

@@ -335,24 +335,6 @@ public class EntityProcess extends BaseProcessor{
 
             idBuilder.addStaticBlock(idStore.build());
 
-            //create mock types of all components
-            for(Stype component : allComponents){
-
-
-                Array<Stype> dependencies = getDependencies(component);
-                Array<Stype> out = new Array<>();
-                out.add(component);
-                out.addAll(component.superclasses());
-                dependencies.each(dep -> {
-                    out.add(dep);
-                    out.addAll(dep.superclasses());
-                });
-
-                out.distinct();
-
-                Log.info("Dependencies of {0}:\n{1}\n\n", component, out.toString("\n", s -> "&lb> " + s));
-            }
-
             write(idBuilder);
         }else{
             //round 2: generate actual classes and implement interfaces
@@ -394,6 +376,43 @@ public class EntityProcess extends BaseProcessor{
 
                 write(def.builder, imports.asArray());
             }
+
+            //create mock types of all components
+            for(Stype interf : interfaces){
+                Array<Stype> dependencies = interf.allInterfaces();
+                dependencies.add(interf);
+                Log.info(interf + ": sub  " + interf.allSuperclasses() + " " + interf.allInterfaces());
+
+                Array<Smethod> methods = dependencies.flatMap(Stype::methods);
+                methods.sort(Structs.comparing(Object::toString));
+
+                ObjectSet<String> signatures = new ObjectSet<>();
+
+                TypeSpec.Builder nullBuilder = TypeSpec.classBuilder("Null" + interf.name().substring(0, interf.name().length() - 1))
+                .addModifiers(Modifier.PUBLIC, Modifier.FINAL);
+
+                nullBuilder.addSuperinterface(interf.tname());
+
+                for(Smethod method : methods){
+                    String signature = method.toString();
+                    if(signatures.contains(signature)) continue;
+
+                    Stype type = method.type();
+                    MethodSpec.Builder builder = MethodSpec.overriding(method.e).addModifiers(Modifier.PUBLIC, Modifier.FINAL);
+
+                    if(!method.isVoid()){
+                        builder.addStatement("return " + getDefault(method.ret().toString()));
+                    }
+
+                    nullBuilder.addMethod(builder.build());
+
+                    signatures.add(signature);
+                }
+
+                //write(nullBuilder);
+
+                Log.info("Methods to override for {0}:\n{1}\n\n", interf, methods.toString("\n", s -> "&lg> &lb" + s));
+            }
         }
     }
 

annotations/src/main/java/mindustry/annotations/util/Selement.java

@@ -54,11 +54,11 @@ public class Selement<T extends Element>{
 
     @Override
     public int hashCode(){
-        return toString().hashCode();
+        return e.hashCode();
     }
 
     @Override
     public boolean equals(Object o){
-        return o != null && toString().equals(o.toString());
+        return o != null && o.getClass() == getClass() && e == ((Selement)o).e;
     }
 }

annotations/src/main/java/mindustry/annotations/util/Smethod.java

@@ -14,10 +14,21 @@ public class Smethod extends Selement<ExecutableElement>{
         super(executableElement);
     }
 
+    public boolean isAny(Modifier... mod){
+        for(Modifier m : mod){
+            if(is(m)) return true;
+        }
+        return false;
+    }
+
     public boolean is(Modifier mod){
         return e.getModifiers().contains(mod);
     }
 
+    public Stype type(){
+        return new Stype((TypeElement)up());
+    }
+
     public Array<TypeMirror> thrown(){
         return Array.with(e.getThrownTypes()).as(TypeMirror.class);
     }

annotations/src/main/java/mindustry/annotations/util/Stype.java

@@ -24,10 +24,19 @@ public class Stype extends Selement<TypeElement>{
         return Array.with(e.getInterfaces()).map(Stype::of);
     }
 
+    public Array<Stype> allInterfaces(){
+        return interfaces().flatMap(Stype::allInterfaces).distinct();
+    }
+
     public Array<Stype> superclasses(){
         return Array.with(BaseProcessor.typeu.directSupertypes(mirror())).map(Stype::of);
     }
 
+    public Array<Stype> allSuperclasses(){
+        //this is truly PEAK efficiency
+        return superclasses().flatMap(Stype::allSuperclasses).distinct();
+    }
+
     public Stype superclass(){
         return new Stype((TypeElement)BaseProcessor.typeu.asElement(BaseProcessor.typeu.directSupertypes(mirror()).get(0)));
     }