Added mobile autotargetting

src/omaloon/OlVars.java

@@ -0,0 +1,76 @@
+package omaloon;
+
+import arc.*;
+import arc.func.*;
+import arc.util.*;
+import lombok.*;
+import mindustry.*;
+import mindustry.game.EventType.*;
+import omaloon.ui.*;
+
+import static arc.Core.settings;
+
+public class OlVars{
+    @Getter(lazy = true)
+    private static final ClientLauncher clientLauncher = findClientLauncher();
+    @Getter(value = AccessLevel.PRIVATE, lazy = true)
+    private static final Cons<ApplicationListener> listenerAdder = computeClientListeners();
+
+    private static ClientLauncher findClientLauncher(){
+        if(Vars.headless) return null;
+        val seq = Core.app.getListeners();
+        for(int i = 0; i < seq.size; i++){
+            ApplicationListener listener = seq.get(i);
+            if(listener instanceof ClientLauncher launcher) return launcher;
+        }
+
+        if(Vars.platform instanceof ClientLauncher launcher) return launcher;
+
+        throw new RuntimeException("Cannot run Omaloon because your client is strange...");
+    }
+
+    private static Cons<ApplicationListener> computeClientListeners(){
+        if(Vars.headless){
+            return Core.app::addListener;
+        }else{
+            return getClientLauncher()::add;
+        }
+    }
+
+    public static <T extends ApplicationListener> T appListener(T applicationListener){
+        getListenerAdder().get(applicationListener);
+        return applicationListener;
+    }
+
+    public static void init(){
+        setKeybinds(OlBinding.values());
+    }
+
+    /**
+     * @author Zelaux
+     * <a href="https://github.com/Zelaux/MindustryModCore/blob/v2/core/src/mmc/core/ModUI.java#L33">source</a>
+     */
+    public static void setKeybinds(KeyBinds.KeyBind... modBindings){
+        Time.mark();
+        KeyBinds.KeyBind[] originalBinds = Core.keybinds.getKeybinds();
+        KeyBinds.KeyBind[] newBinds = new KeyBinds.KeyBind[originalBinds.length + modBindings.length];
+
+        System.arraycopy(originalBinds, 0, newBinds, 0, originalBinds.length);
+        System.arraycopy(modBindings, 0, newBinds, originalBinds.length, modBindings.length);
+
+        OmaloonMod.olLog("Time to combine arrays: @ms", Time.elapsed());
+        Core.keybinds.setDefaults(newBinds);
+        settings.load();
+    }
+
+    public static void onClientLoad(Runnable runnable){
+        Events.on(ClientLoadEvent.class, it -> runnable.run());
+    }
+    public static void onServerLoad(Runnable runnable){
+        Events.on(ServerLoadEvent.class, it -> runnable.run());
+    }
+    public static void onAnyLoad(Runnable runnable){
+        onClientLoad(runnable);
+        onServerLoad(runnable);
+    }
+}

src/omaloon/OmaloonMod.java

@@ -8,64 +8,67 @@
 import mindustry.game.*;
 import mindustry.mod.*;
 import mindustry.type.*;
-import ol.gen.OlCall;
+import ol.gen.*;
 import omaloon.content.*;
 import omaloon.core.*;
+import omaloon.core.extra.*;
+import omaloon.core.extra.RelatedApplicationListener.*;
 import omaloon.gen.*;
 import omaloon.graphics.*;
 import omaloon.net.*;
-import omaloon.ui.*;
 import omaloon.ui.dialogs.*;
 import omaloon.utils.*;
 import omaloon.world.blocks.environment.*;
-import omaloon.world.save.OlDelayedItemTransfer;
+import omaloon.world.save.*;
+import org.jetbrains.annotations.Nullable;
 
 import static arc.Core.app;
+import static omaloon.OlVars.*;
 import static omaloon.core.OlUI.*;
 
+@Nullable
 public class OmaloonMod extends Mod{
 
     /**
      * Buffer radius increase to take splashRadius into account, increase if necessary.
      */
     public static float shieldBuffer = 40f;
     public static SafeClearer safeClearer;
+
     public static OlUI ui;
+    public static OlControl control;
     public static EditorListener editorListener;
+    public static OlNetClient netClient;
 
     public OmaloonMod(){
-        super();
         OlCall.registerPackets();
         new OlDelayedItemTransfer();
-        if(!Vars.headless)
-            editorListener = new EditorListener();
 
-        ui = new OlUI(OlBinding.values());
+        appListener(new ApplicationListener(){
+            @Override
+            public void init(){
+                OlVars.init();
+            }
+        });
+        if(!Vars.headless){
+            editorListener = appListener(new EditorListener());
+            ui = appListener(new OlUI());
+            control = appListener(new OlControl());
+            netClient= RelatedApplicationListener.register(
+                new OlNetClient(),
+                RelativeOrder.before,
+                Vars.netClient
+            );
+        }
 
-        Events.on(EventType.ClientLoadEvent.class, e -> {
+        OlVars.onClientLoad(() -> {
             Vars.maps.all().removeAll(map -> {
                 if(map.mod == null || !map.mod.name.equals("omaloon")){
                     return false;
                 }
                 Mods.LoadedMod otherMod = Vars.mods.getMod("test-utils");
                 return otherMod == null || !otherMod.enabled();
             });
-            Core.app.addListener(new ApplicationListener(){
-                @Override
-                public void update(){
-                    if(Core.input.keyTap(OlBinding.switchDebugDraw)){
-                        DebugDraw.switchEnabled();
-                    }
-                }
-            });
-
-
-        });
-
-        if(!Vars.headless){
-            editorListener = new EditorListener();
-        }
-        Events.on(EventType.ClientLoadEvent.class, ignored -> {
             OlIcons.load();
             OlSettings.load();
             EventHints.addHints();
@@ -88,6 +91,7 @@ public void update(){
 
         Log.info("Loaded OmaloonMod constructor.");
     }
+
     public static void olLog(String string, Object... args){
         Log.infoTag("omaloon", Strings.format(string, args));
     }

src/omaloon/ai/drone/AttackDroneAI.java

@@ -1,17 +1,23 @@
 package omaloon.ai.drone;
 
+import arc.*;
 import arc.graphics.g2d.*;
 import arc.math.geom.*;
 import arc.util.*;
 import arclibrary.graphics.*;
+import mindustry.*;
+import mindustry.entities.*;
 import mindustry.gen.*;
 import mindustry.graphics.*;
+import mindustry.input.*;
+import mindustry.type.*;
 import mindustry.ui.*;
+import omaloon.*;
 import omaloon.ai.*;
 import omaloon.math.*;
 import omaloon.utils.*;
 
-import static mindustry.Vars.tilesize;
+import static mindustry.Vars.*;
 
 /**
  * @author Zelaux
@@ -124,7 +130,34 @@ public void updateMovement(){
     }
 
     private boolean isOwnerShooting(){
-        return owner.isShooting() || owner.controller() instanceof Player player && player.shooting;
+        if(owner.isShooting()) return true;
+        if(!(owner.controller() instanceof Player player)) return false;
+        if(player.shooting) return true;
+        if(player != Vars.player) return false;
+
+        MobileInput mobile = OmaloonMod.control.input.mobile;
+        if(mobile == null) return false;
+        if(!Core.settings.getBool("autotarget")) return false;
+        UnitType ownerType = owner.type;
+        float ownerRange = owner.range();
+//        if(!ownerType.canAttack) return false;
+        if(mobile.target == null){
+            mobile.target = Units.closestTarget(
+                owner.team, owner.x, owner.y,
+                ownerRange, u -> u.checkTarget(ownerType.targetAir, ownerType.targetGround), u -> ownerType.targetGround);
+
+            if(mobile.target == null) return false;
+        }
+
+        //using self unit bulletSpeed
+        float bulletSpeed = unit.type.weapons.first().bullet.speed;
+        Vec2 intercept = Predict.intercept(owner, mobile.target, bulletSpeed);
+
+//        player.shooting = !boosted;
+
+        owner.aim(player.mouseX = intercept.x, player.mouseY = intercept.y);
+
+        return true;
     }
 
     @Override
@@ -136,4 +169,10 @@ public Teamc target(float x, float y, float range, boolean air, boolean ground){
     public boolean shouldShoot(){
         return isOwnerShooting();
     }
+
+    public void beforeSync(){
+        if(owner.controller() != player) return;
+        if(owner.isShooting())return;
+        player.shooting=isOwnerShooting();//sets aim stuff
+    }
 }

src/omaloon/client/OlClientStuff.java

@@ -0,0 +1,9 @@
+package omaloon.client;
+
+import arc.*;
+import lombok.*;
+import mindustry.*;
+
+public class OlClientStuff{
+
+}

src/omaloon/core/EditorListener.java

@@ -11,7 +11,6 @@ public class EditorListener implements ApplicationListener{
     boolean isEditor;
 
     public EditorListener(){
-        if(Vars.platform instanceof ApplicationCore core) core.add(this);
         Events.on(StateChangeEvent.class, e -> {
             if(e.from == State.menu && e.to == State.playing && state.isEditor()){
                 if(true){

src/omaloon/core/OlControl.java

@@ -0,0 +1,24 @@
+package omaloon.core;
+
+import arc.*;
+import mindustry.*;
+import mindustry.game.EventType.*;
+import omaloon.ui.*;
+import omaloon.utils.*;
+
+
+public class OlControl implements ApplicationListener{
+    public OlInput input;
+
+    @Override
+    public void init(){
+        input = new OlInput(Vars.control.input);
+    }
+
+    @Override
+    public void update(){
+        if(Core.input.keyTap(OlBinding.switchDebugDraw)){
+            DebugDraw.switchEnabled();
+        }
+    }
+}

src/omaloon/core/OlInput.java

@@ -0,0 +1,29 @@
+package omaloon.core;
+
+import lombok.*;
+import mindustry.*;
+import mindustry.input.*;
+import org.jetbrains.annotations.*;
+
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class OlInput{
+
+    @NotNull
+    public final InputHandler any;
+    @Nullable
+    public final DesktopInput desktop;
+    @Nullable
+    public final MobileInput mobile;
+
+    public OlInput(@NonNull InputHandler any){
+        this(
+            any,
+            Vars.mobile ? null : (DesktopInput)any,
+            Vars.mobile ? (MobileInput)any : null
+        );
+    }
+
+    public static void makeLazy(){
+    }
+
+}

src/omaloon/core/OlNetClient.java

@@ -0,0 +1,27 @@
+package omaloon.core;
+
+import arc.*;
+import mindustry.*;
+import mindustry.gen.*;
+import omaloon.ai.drone.*;
+import omaloon.entities.abilities.*;
+
+public class OlNetClient implements ApplicationListener{
+    @Override
+    public void update(){
+        if(!Vars.mobile) return;
+        if(Vars.player == null) return;
+        Unit unit = Vars.player.unit();
+        if(unit == null) return;
+        if(!DroneAbility.isDroneOwner(unit.type)) return;
+        int[] indecies = DroneAbility.abilityIndecies(unit.type);
+        for(int i : indecies){
+            DroneAbility ability = (DroneAbility)unit.abilities[i];
+            for(Unit drone : ability.drones){
+                if(!(drone.controller() instanceof AttackDroneAI attackDroneAI)) continue;
+                attackDroneAI.beforeSync();
+
+            }
+        }
+    }
+}