Merge pull request #13 from buthed010203/patch-1

Java 16, Turret/unit range rework, Removed redundant casts

build.gradle

@@ -6,9 +6,6 @@ group pGroup
 
 version '1.0'
 
-sourceCompatibility = 8
-
-
 sourceSets.main {
     java.srcDir("src/")
     resources.srcDir("assets/")
@@ -31,6 +28,7 @@ jar {
 
 
 dependencies {
+    annotationProcessor 'com.github.Anuken:jabel:34e4c172e65b3928cd9eabe1993654ea79c409cd'
     compileOnly "com.github.Anuken.Arc:arc-core:$pMindustryVersion"
     compileOnly "com.github.Anuken.Mindustry:core:$pMindustryVersion"
     implementation 'org.hjson:hjson:3.0.0'
@@ -57,3 +55,15 @@ task dexify(type: Jar) {
 }
 
 task buildDex dependsOn "build", "dexify"
+
+tasks.withType(JavaCompile){
+    targetCompatibility = 8
+    sourceCompatibility = JavaVersion.VERSION_16
+    options.encoding = "UTF-8"
+    options.forkOptions.jvmArgs.addAll([
+        '--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED',
+        '--add-opens=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED'
+    ])
+    options.compilerArgs.addAll(['--release', '8'])
+    compileJava.options.fork = true
+}

src/UnitInfo/SVars.java

@@ -1,14 +1,13 @@
 package UnitInfo;
 
-import UnitInfo.core.HudUi;
-import UnitInfo.core.PlayerParser;
-import UnitInfo.core.Setting;
-import arc.Core;
-import arc.files.Fi;
-import arc.struct.Seq;
+import UnitInfo.core.*;
+import arc.files.*;
+import arc.struct.*;
+
+import static mindustry.Vars.*;
 
 public class SVars {
-    public static Fi modRoot = Core.settings.getDataDirectory().child("mods/UnitInfo");
+    public static Fi modRoot = modDirectory.child("UnitInfo");
     public static Seq<PlayerParser.PlayerInfo> playerInfos = new Seq<>();
 
     public static Setting settingAdder = new Setting();

src/UnitInfo/core/BarInfo.java

@@ -30,9 +30,9 @@ import static mindustry.Vars.content;
 import static mindustry.Vars.state;
 
 public class BarInfo {
-    static Seq<String> strings = new Seq<>(new String[]{"","","","","",""});
-    static Seq<Float> numbers = new Seq<>(new Float[]{0f,0f,0f,0f,0f,0f});
-    static Seq<Color> colors = new Seq<>(new Color[]{Color.clear,Color.clear,Color.clear,Color.clear,Color.clear,Color.clear});
+    static Seq<String> strings = Seq.with("","","","","","");
+    static Seq<Float> numbers = Seq.with(0f,0f,0f,0f,0f,0f);
+    static Seq<Color> colors = Seq.with(Color.clear,Color.clear,Color.clear,Color.clear,Color.clear,Color.clear);
 
     public static String format(float number){
         if(number >= 10000) return UI.formatAmount((long)number);
@@ -48,46 +48,44 @@ public class BarInfo {
         }
         
         
-        if(target instanceof Healthc) {
-            strings.set(0, Core.bundle.format("shar-stat.health", Strings.fixed(((Healthc)target).health(), 1)));
+        if(target instanceof Healthc healthc){
+            strings.set(0, Core.bundle.format("shar-stat.health", Strings.fixed(healthc.health(), 1)));
             colors.set(0, Pal.health);
-            numbers.set(0, ((Healthc) target).healthf());
+            numbers.set(0, healthc.healthf());
         }
 
         
-        if(target instanceof Turret.TurretBuild){
-            strings.set(1, Core.bundle.format("shar-stat.reload", Strings.fixed((((Turret.TurretBuild)target).reload / ((Turret)((Turret.TurretBuild)target).block).reloadTime) * 100f, 1)));
-            colors.set(1, Pal.accent.cpy().lerp(Color.orange, Mathf.clamp(((Turret.TurretBuild)target).reload / ((Turret)((Turret.TurretBuild)target).block).reloadTime)));
-            numbers.set(1, ((Turret.TurretBuild)target).reload / ((Turret)((Turret.TurretBuild)target).block).reloadTime);
+        if(target instanceof Turret.TurretBuild turret){
+            strings.set(1, Core.bundle.format("shar-stat.reload", Strings.fixed((turret.reload / ((Turret)turret.block).reloadTime) * 100f, 1)));
+            colors.set(1, Pal.accent.cpy().lerp(Color.orange, Mathf.clamp((turret.reload / ((Turret)turret.block).reloadTime))));
+            numbers.set(1, turret.reload / ((Turret)turret.block).reloadTime);
         }
-        else if(target instanceof Unit && ((Unit) target).type != null){
-            float max1 = ((ShieldRegenFieldAbility)content.units().copy().filter(ut -> ut.abilities.find(abil -> abil instanceof ShieldRegenFieldAbility) != null).sort(ut -> ((ShieldRegenFieldAbility)ut.abilities.find(abil -> abil instanceof ShieldRegenFieldAbility)).max).peek().abilities.find(abil -> abil instanceof ShieldRegenFieldAbility)).max;
+        else if(target instanceof Unit unit && unit.type != null){
+            float max1 = ((ShieldRegenFieldAbility)content.units().copy().filter(ut -> ut.abilities.contains(abil -> abil instanceof ShieldRegenFieldAbility)).sort(ut -> ((ShieldRegenFieldAbility)ut.abilities.find(abil -> abil instanceof ShieldRegenFieldAbility)).max).peek().abilities.find(abil -> abil instanceof ShieldRegenFieldAbility)).max;
             float max2 = 0f;
-            if(((Unit)target).type().abilities.find(abil -> abil instanceof ForceFieldAbility) != null) max2 = ((ForceFieldAbility) ((Unit)target).type().abilities.find(abil -> abil instanceof ForceFieldAbility)).max;
-            strings.set(1, Core.bundle.format("shar-stat.shield", format(((Shieldc)target).shield())));
+            ForceFieldAbility ffa;
+            if((ffa = (ForceFieldAbility) unit.type().abilities.find(abil -> abil instanceof ForceFieldAbility)) != null) max2 = ffa.max;
+            strings.set(1, Core.bundle.format("shar-stat.shield", format(unit.shield())));
             colors.set(1, Pal.surge);
-            numbers.set(1, ((Unit)target).shield() / Math.max(max1, max2));
+            numbers.set(1, unit.shield() / Math.max(max1, max2));
         }
-        else if(target instanceof ConstructBlock.ConstructBuild){
-            ConstructBlock.ConstructBuild construct = (ConstructBlock.ConstructBuild) target;
+        else if(target instanceof ConstructBlock.ConstructBuild build){
+            ConstructBlock.ConstructBuild construct = build;
             strings.set(1, Core.bundle.format("shar-stat.progress", Strings.fixed(construct.progress * 100, 1)));
             colors.set(1, Pal.darkerMetal);
             numbers.set(1, construct.progress);
         }
-        else if(target instanceof UnitFactory.UnitFactoryBuild){
-            UnitFactory.UnitFactoryBuild factory = (UnitFactory.UnitFactoryBuild) target;
-            strings.set(1, Core.bundle.format("shar-stat.progress", Strings.fixed(factory.fraction() * 100f, 1)));
+        else if(target instanceof UnitFactory.UnitFactoryBuild build){
+            strings.set(1, Core.bundle.format("shar-stat.progress", Strings.fixed(build.fraction() * 100f, 1)));
             colors.set(1, Pal.darkerMetal);
-            numbers.set(1, factory.fraction());
+            numbers.set(1, build.fraction());
         }
-        else if(target instanceof Reconstructor.ReconstructorBuild){
-            Reconstructor.ReconstructorBuild reconstruct = (Reconstructor.ReconstructorBuild) target;
+        else if(target instanceof Reconstructor.ReconstructorBuild reconstruct){
             strings.set(1, Core.bundle.format("shar-stat.progress", Strings.fixed(reconstruct.fraction() * 100, 1)));
             colors.set(1, Pal.darkerMetal);
             numbers.set(1, reconstruct.fraction());
         }
-        else if(target instanceof ForceProjector.ForceBuild){
-            ForceProjector.ForceBuild force = (ForceProjector.ForceBuild) target;
+        else if(target instanceof ForceProjector.ForceBuild force){
             ForceProjector forceBlock = (ForceProjector) force.block;
             float max = forceBlock.shieldHealth + forceBlock.phaseShieldBoost * force.phaseHeat;
             strings.set(1, Core.bundle.format("shar-stat.shield", format(max-force.buildup), max));
@@ -96,96 +94,89 @@ public class BarInfo {
 
         }
         
-        if(target instanceof ItemTurret.ItemTurretBuild) {
-            ItemTurret.ItemTurretBuild turretBuild = (ItemTurret.ItemTurretBuild) target;
+        if(target instanceof ItemTurret.ItemTurretBuild turretBuild) {
             strings.set(2, bundle.format("shar-stat.itemAmmo", format(turretBuild.totalAmmo), format(((ItemTurret)turretBuild.block).maxAmmo)));
             colors.set(2, turretBuild.hasAmmo() ? ((ItemTurret)turretBuild.block).ammoTypes.findKey(turretBuild.peekAmmo(), true).color : Pal.ammo);
             numbers.set(2, turretBuild.totalAmmo / (((ItemTurret)turretBuild.block).maxAmmo * 1f));
         }
-        else if(target instanceof LiquidTurret.LiquidTurretBuild){
-            LiquidTurret.LiquidTurretBuild turretBuild = (LiquidTurret.LiquidTurretBuild)target;
+        else if(target instanceof LiquidTurret.LiquidTurretBuild turretBuild){
             strings.set(2, bundle.format("shar-stat.liquidAmmo", format(turretBuild.liquids.get(turretBuild.liquids.current())), format(turretBuild.block.liquidCapacity)));
             colors.set(2, turretBuild.liquids.current().color);
             numbers.set(2, turretBuild.liquids.get(turretBuild.liquids.current()) / turretBuild.block.liquidCapacity);
         }
-        else if(target instanceof PowerTurret.PowerTurretBuild){
-            PowerTurret.PowerTurretBuild entity = (PowerTurret.PowerTurretBuild)target;
+        else if(target instanceof PowerTurret.PowerTurretBuild entity){
             float max = entity.block.consumes.getPower().usage;
             float v = entity.power.status * entity.power.graph.getLastScaledPowerIn();
             strings.set(2, bundle.format("shar-stat.power", format(Math.min(v,max) * 60), format(max * 60)));
             colors.set(2, Pal.powerBar);
             numbers.set(2, v/max);
         }
-        else if(target instanceof Building && ((Building)target).block.hasItems) {
-            if(target instanceof CoreBlock.CoreBuild){
-                CoreBlock.CoreBuild core = (CoreBlock.CoreBuild)target;
-                strings.set(2, bundle.format("shar-stat.itemCapacity", format(((Building) target).items.total()), format(core.storageCapacity * content.items().count(UnlockableContent::unlockedNow))));
-                numbers.set(2, ((Building)target).items.total() / (core.storageCapacity * content.items().count(UnlockableContent::unlockedNow) * 1f));
+        else if(target instanceof Building b && b.block.hasItems) {
+            if(target instanceof CoreBlock.CoreBuild cb){
+                strings.set(2, bundle.format("shar-stat.itemCapacity", format(((Building) target).items.total()), format(cb.storageCapacity * content.items().count(UnlockableContent::unlockedNow))));
+                numbers.set(2, cb.items.total() / (cb.storageCapacity * content.items().count(UnlockableContent::unlockedNow) * 1f));
             }
-            else if(target instanceof StorageBlock.StorageBuild && !((StorageBlock.StorageBuild)target).canPickup()){
+            else if(target instanceof StorageBlock.StorageBuild sb && !sb.canPickup()){
                 for(int i = 0; i < 4; i++) {
-                    Building build = ((Building) target).nearby(i);
-                    if(build instanceof CoreBlock.CoreBuild){
-                        strings.set(2, bundle.format("shar-stat.itemCapacity", format(((Building) target).items.total()), format(((CoreBlock.CoreBuild) build).storageCapacity * content.items().count(UnlockableContent::unlockedNow))));
-                        numbers.set(2, ((Building)target).items.total() / (((CoreBlock.CoreBuild) build).storageCapacity * content.items().count(UnlockableContent::unlockedNow) * 1f));
+                    Building build = sb.nearby(i);
+                    if(build instanceof CoreBlock.CoreBuild cb){
+                        strings.set(2, bundle.format("shar-stat.itemCapacity", format(sb.items.total()), format(cb.storageCapacity * content.items().count(UnlockableContent::unlockedNow))));
+                        numbers.set(2, sb.items.total() / (cb.storageCapacity * content.items().count(UnlockableContent::unlockedNow) * 1f));
                         break;
                     }
                 }
             }
             else {
-                strings.set(2, bundle.format("shar-stat.itemCapacity", format(((Building)target).items.total()), format(((Building)target).block.itemCapacity)));
-                numbers.set(2, ((Building)target).items.total() / (((Building)target).block.itemCapacity * 1f));
+                strings.set(2, bundle.format("shar-stat.itemCapacity", format(b.items.total()), format(b.block.itemCapacity)));
+                numbers.set(2, b.items.total() / (((Building)target).block.itemCapacity * 1f));
             }
             colors.set(2, Pal.items);
         }
-        else if(target instanceof Unit && ((Unit)target).type() != null) {
-            strings.set(2, bundle.format("shar-stat.itemCapacity", format(((Unit)target).stack().amount), format(((Unit)target).type().itemCapacity)));
-            if(((Unit)target).stack().amount > 0 && ((Unit)target).stack().item != null) colors.set(2, ((Unit)target).stack().item.color.cpy().lerp(Color.white, 0.15f));
-            numbers.set(2, ((Unit)target).stack().amount / (((Unit)target).type().itemCapacity * 1f));
+        else if(target instanceof Unit unit && unit.type() != null) {
+            strings.set(2, bundle.format("shar-stat.itemCapacity", format(unit.stack().amount), format(unit.type().itemCapacity)));
+            if(unit.stack().amount > 0 && unit.stack().item != null) colors.set(2, unit.stack().item.color.cpy().lerp(Color.white, 0.15f));
+            numbers.set(2, unit.stack().amount / (unit.type().itemCapacity * 1f));
         }
 
 
-        if(target instanceof Turret.TurretBuild){
-            Turret turret = (Turret)((Turret.TurretBuild)target).block;
+        if(target instanceof Turret.TurretBuild t){
+            Turret turret = (Turret)t.block;
             if(turret.chargeTime > 0f) {
                 strings.set(3, Core.bundle.format("shar-stat.charge", format((SVars.hud.charge / turret.chargeTime) * 100)));
                 colors.set(3, Pal.surge.cpy().lerp(Pal.accent, SVars.hud.charge / turret.chargeTime));
                 numbers.set(3, SVars.hud.charge / turret.chargeTime);
             }
         }
-        else if(target instanceof Unit && ((Unit) target).type != null) {
-            strings.set(3, Core.bundle.format("shar-stat.commandUnits", format(Groups.unit.count(u -> u.controller() instanceof FormationAI && ((FormationAI)u.controller()).leader == target)), format(((Unit)target).type().commandLimit)));
-            colors.set(3, Pal.powerBar.cpy().lerp(Pal.surge.cpy().mul(Pal.lighterOrange), Mathf.absin(Time.time, 7f / (1f + Mathf.clamp(Groups.unit.count(u -> u.controller() instanceof FormationAI && ((FormationAI)u.controller()).leader == target) / (((Unit)target).type().commandLimit * 1f))), 1f)));
-            numbers.set(3, Groups.unit.count(u -> u.controller() instanceof FormationAI && ((FormationAI)u.controller()).leader == target) / (((Unit)target).type().commandLimit * 1f));
+        else if(target instanceof Unit unit && unit.type != null) {
+            strings.set(3, Core.bundle.format("shar-stat.commandUnits", format(Groups.unit.count(u -> u.controller() instanceof FormationAI && ((FormationAI)u.controller()).leader == target)), format(unit.type().commandLimit)));
+            colors.set(3, Pal.powerBar.cpy().lerp(Pal.surge.cpy().mul(Pal.lighterOrange), Mathf.absin(Time.time, 7f / (1f + Mathf.clamp(Groups.unit.count(u -> u.controller() instanceof FormationAI && ((FormationAI)u.controller()).leader == target) / (unit.type().commandLimit * 1f))), 1f)));
+            numbers.set(3, Groups.unit.count(u -> u.controller() instanceof FormationAI && ((FormationAI)u.controller()).leader == target) / (unit.type().commandLimit * 1f));
         }
-        else if(target instanceof UnitFactory.UnitFactoryBuild){
-            UnitFactory.UnitFactoryBuild factory = (UnitFactory.UnitFactoryBuild) target;
+        else if(target instanceof UnitFactory.UnitFactoryBuild factory){
             strings.set(3, factory.unit() == null ? "[lightgray]" + Iconc.cancel :
                     Core.bundle.format("bar.unitcap", Fonts.getUnicodeStr(factory.unit().name), format(factory.team.data().countType(factory.unit())), format(Units.getCap(factory.team))));
             colors.set(3, Pal.power);
             numbers.set(3, factory.unit() == null ? 0f : (float)factory.team.data().countType(factory.unit()) / Units.getCap(factory.team));
         }
 
-        if(target instanceof Unit && target instanceof Payloadc && ((Unit) target).type != null){
-            strings.set(4, Core.bundle.format("shar-stat.payloadCapacity", format(Mathf.round(Mathf.sqrt(((Payloadc)target).payloadUsed()))), format(Mathf.round(Mathf.sqrt(((Unit)target).type().payloadCapacity)))));
+        if(target instanceof Unit unit && target instanceof Payloadc pay && unit.type != null){
+            strings.set(4, Core.bundle.format("shar-stat.payloadCapacity", format(Mathf.round(Mathf.sqrt(pay.payloadUsed()))), format(Mathf.round(Mathf.sqrt(unit.type().payloadCapacity)))));
             colors.set(4, Pal.items);
-            numbers.set(4, ((Payloadc)target).payloadUsed() / ((Unit)target).type().payloadCapacity);
+            numbers.set(4, pay.payloadUsed() / unit.type().payloadCapacity);
         }
-        else if(target instanceof Building && ((Building) target).block.hasLiquids){
-            Building build = (Building) target;
+        else if(target instanceof Building build && build.block.hasLiquids){
             strings.set(4, Core.bundle.format("shar-stat.liquidCapacity", format(build.liquids.currentAmount()), format(build.block.liquidCapacity)));
             colors.set(4, build.liquids.current().color);
             numbers.set(4, build.liquids.currentAmount()/build.block.liquidCapacity);
         }
 
 
-        if(target instanceof Unit && state.rules.unitAmmo && ((Unit) target).type != null){
-            strings.set(5, Core.bundle.format("shar-stat.ammos", format(((Unit)target).ammo()), format(((Unit)target).type().ammoCapacity)));
-            colors.set(5, ((Unit)target).type().ammoType.color);
-            numbers.set(5, ((Unit)target).ammof());
+        if(target instanceof Unit unit && state.rules.unitAmmo && unit.type != null){
+            strings.set(5, Core.bundle.format("shar-stat.ammos", format(unit.ammo()), format(unit.type().ammoCapacity)));
+            colors.set(5, unit.type().ammoType.color);
+            numbers.set(5, unit.ammof());
         }
-        else if(target instanceof Building && ((Building) target).block.hasPower && ((Building) target).block.consumes.hasPower()){
-            Building build = (Building) target;
+        else if(target instanceof Building build && build.block.hasPower && build.block.consumes.hasPower()){
             ConsumePower cons = build.block.consumes.getPower();
             if(cons.buffered) strings.set(5, Core.bundle.format("shar-stat.powerCapacity", format(build.power.status * cons.capacity * 60f), format(cons.capacity * 60f)));
             else strings.set(5, Core.bundle.format("shar-stat.powerUsage", format(build.power.status * cons.usage * 60f), format(cons.usage * 60f)));

src/UnitInfo/core/Main.java

@@ -1,35 +1,21 @@
 package UnitInfo.core;
 
-import UnitInfo.ui.FreeBar;
-import arc.Core;
-import arc.Events;
-import arc.graphics.Color;
-import arc.graphics.g2d.Draw;
-import arc.graphics.g2d.Fill;
-import arc.graphics.g2d.Lines;
-import arc.math.Angles;
-import arc.math.Mathf;
-import arc.math.geom.Position;
-import arc.scene.ui.layout.Scl;
-import arc.util.Align;
-import arc.util.Time;
-import arc.util.Tmp;
-import mindustry.Vars;
-import mindustry.content.Fx;
+import UnitInfo.ui.*;
+import arc.*;
+import arc.graphics.*;
+import arc.graphics.g2d.*;
+import arc.math.*;
+import arc.scene.ui.layout.*;
+import arc.util.*;
+import mindustry.*;
+import mindustry.content.*;
 import mindustry.game.EventType.*;
-import mindustry.game.Team;
-import mindustry.gen.Building;
-import mindustry.gen.Groups;
-import mindustry.gen.Teamc;
-import mindustry.gen.Unit;
-import mindustry.graphics.Drawf;
-import mindustry.graphics.Layer;
-import mindustry.graphics.Pal;
-import mindustry.mod.Mod;
-import mindustry.type.UnitType;
-import mindustry.ui.Fonts;
-import mindustry.world.Block;
-import mindustry.world.blocks.ConstructBlock;
+import mindustry.game.*;
+import mindustry.gen.*;
+import mindustry.graphics.*;
+import mindustry.mod.*;
+import mindustry.ui.*;
+import mindustry.world.*;
 import mindustry.world.blocks.defense.turrets.*;
 
 import static UnitInfo.SVars.*;
@@ -37,7 +23,6 @@ import static arc.Core.*;
 import static mindustry.Vars.*;
 
 public class Main extends Mod {
-
     @Override
     public void init(){
         Events.on(ClientLoadEvent.class, e -> {
@@ -111,68 +96,40 @@ public class Main extends Mod {
                 Draw.reset();
             });
 
+            // Turret Ranges
             if(settings.getBool("rangeNearby") && player != null) {
-                Groups.all.each(entityc -> entityc instanceof Teamc && (entityc instanceof Building || (settings.getBool("unitRange") && entityc instanceof Unit)), entityc -> { //only turret and unit are allowed
-                    boolean h = false;
-                    float range = 0;
-                    if(entityc instanceof Turret.TurretBuild) { //if it's turret and can target player and
-                        Turret turret = (Turret) ((Turret.TurretBuild) entityc).block;
-                        if((entityc instanceof PowerTurret.PowerTurretBuild)) { //can shoot to player or
-                            if(((PowerTurret.PowerTurretBuild) entityc).power().graph.getLastScaledPowerIn() > 0f) {
-                                if(player.unit().isGrounded() && turret.targetGround) h = true;
-                                if(player.unit().isFlying() && turret.targetAir) h = true;
-                            }
-                        }else if(((Turret.TurretBuild) entityc).hasAmmo()) {
-                            if(player.unit().isGrounded() && turret.targetGround) h = true;
-                            if(player.unit().isFlying() && turret.targetAir) h = true;
-                        }
-                        range = turret.range;
-                    }
-                    if(entityc instanceof TractorBeamTurret.TractorBeamBuild) { //if it's parallax and can target player or
-                        TractorBeamTurret turret = (TractorBeamTurret) ((TractorBeamTurret.TractorBeamBuild) entityc).block;
-                        if(((TractorBeamTurret.TractorBeamBuild) entityc).power().graph.getLastScaledPowerIn() > 0f) {
-                            if(player.unit().isGrounded() && turret.targetGround) h = true;
-                            if(player.unit().isFlying() && turret.targetAir) h = true;
-                        }
-                        range = turret.range;
-                    }
-                    if(entityc instanceof ConstructBlock.ConstructBuild) { //if it's not constructed yet but can target player later or
-                        if (((ConstructBlock.ConstructBuild) entityc).current instanceof Turret) {
-                            Turret turret = (Turret) ((ConstructBlock.ConstructBuild) entityc).current;
-                            if (player.unit().isGrounded() && turret.targetGround) h = true;
-                            if (player.unit().isFlying() && turret.targetAir) h = true;
-                            range = turret.range;
-                        } else if (((ConstructBlock.ConstructBuild) entityc).current instanceof TractorBeamTurret) {
-                            TractorBeamTurret turret = (TractorBeamTurret) ((ConstructBlock.ConstructBuild) entityc).current;
-                            if (player.unit().isGrounded() && turret.targetGround) h = true;
-                            if (player.unit().isFlying() && turret.targetAir) h = true;
-                            range = turret.range;
-                        }
-                    }
-                    if(entityc instanceof Unit) {  //if it's just unit and can target player,
-                        UnitType type = ((Unit) entityc).type;
-                        if (player.unit().isGrounded() && type.targetGround) h = true;
-                        if (player.unit().isFlying() && type.targetAir) h = true;
-                        range = ((Unit) entityc).range();
-                    }
+                Team team = player.team();
+                Unit unit = player.unit();
+                Groups.build.each(e -> {
+                    if (e.team == team) return; // Don't draw own turrets
+                    if (!(e instanceof BaseTurret.BaseTurretBuild )) return; // Not a turret
+                    if ((e instanceof Turret.TurretBuild t && !t.hasAmmo()) || !e.cons.valid()) return; // No ammo
 
-                    //draw range.
-                    if(Vars.player.dst((Position) entityc) <= range + settings.getInt("rangeRadius") * tilesize && //out of range is not allowed
-                        (settings.getBool("allTeamRange") || //derelict or player team are not allowed without setting
-                            (((Teamc) entityc).team() != player.team() && ((Teamc) entityc).team() != Team.derelict))){
-                    if (h) {
-                        if(entityc instanceof ConstructBlock.ConstructBuild){
-                            Lines.stroke(3f, Tmp.c1.set(Pal.gray).a(((ConstructBlock.ConstructBuild) entityc).progress));
-                            Lines.dashCircle(((Teamc) entityc).x(), ((Teamc) entityc).y(), range);
-                            Lines.stroke(1f, Tmp.c1.set(((Teamc) entityc).team().color).a(((ConstructBlock.ConstructBuild) entityc).progress));
-                            Lines.dashCircle(((Teamc) entityc).x(), ((Teamc) entityc).y(), range);
-                            Draw.reset();
-                        }
-                        else Drawf.dashCircle(((Teamc) entityc).x(), ((Teamc) entityc).y(), range, ((Teamc) entityc).team().color);
-                    }else if (settings.getBool("allTargetRange"))
-                        Drawf.dashCircle(((Teamc) entityc).x(), ((Teamc) entityc).y(), range, Color.gray);
+                    boolean canHit = e.block instanceof Turret t ? unit.isFlying() ? t.targetAir : t.targetGround :
+                        e.block instanceof TractorBeamTurret tu && (unit.isFlying() ? tu.targetAir : tu.targetGround);
+                    float range = ((BaseTurret.BaseTurretBuild) e).range();
+
+
+                    if(Vars.player.dst(e) <= range + settings.getInt("rangeRadius") * tilesize + e.block.offset) {
+                        if (canHit || settings.getBool("allTargetRange"))
+                            Drawf.dashCircle(e.x, e.y, range, canHit ? e.team.color : Team.derelict.color);
                     }
                 });
+
+                // Unit Ranges (Only works when turret ranges are enabled)
+                if (!settings.getBool("unitRange")) {
+                    Groups.unit.each(u -> {
+                        if (u.team == team) return; // Don't draw own units
+
+                        boolean canHit = unit.isFlying() ? u.type.targetAir : u.type.targetGround;
+                        float range = u.range();
+
+                        if(Vars.player.dst(u) <= range + settings.getInt("rangeRadius") * tilesize) { // TODO: Store value of rangeRadius as an int, should increase performance
+                            if (canHit || settings.getBool("allTargetRange")) // Same as above
+                                Drawf.dashCircle(u.x, u.y, range, canHit ? u.team.color : Team.derelict.color);
+                        }
+                    });
+                }
             }
         });
     }

src/UnitInfo/core/Setting.java

@@ -2,21 +2,20 @@ package UnitInfo.core;
 
 import arc.*;
 import arc.graphics.*;
-import arc.scene.event.Touchable;
+import arc.scene.event.*;
 import arc.scene.ui.*;
 import arc.scene.ui.layout.*;
-import arc.struct.Seq;
+import arc.struct.*;
 import arc.util.*;
 import mindustry.*;
-import mindustry.core.Version;
+import mindustry.core.*;
 import mindustry.gen.*;
-import mindustry.ui.Styles;
+import mindustry.ui.*;
 import mindustry.ui.dialogs.*;
 
-import java.util.Iterator;
+import java.util.*;
 
-import static arc.Core.bundle;
-import static arc.Core.settings;
+import static arc.Core.*;
 import static mindustry.Vars.*;
 
 public class Setting {
@@ -78,9 +77,7 @@ public class Setting {
 
                 box.update(() -> box.setChecked(settings.getBool(name)));
 
-                box.changed(() -> {
-                    settings.put(name, box.isChecked());
-                });
+                box.changed(() -> settings.put(name, box.isChecked()));
 
                 box.left();
                 table.add(box).left().padTop(3f);
@@ -232,17 +229,17 @@ public class Setting {
             public Table rebuild() {
                 table.clearChildren();
 
-                Iterator var1 = list.iterator();
+                Iterator<SettingsMenuDialog.SettingsTable.Setting> var1 = list.iterator();
 
                 while(var1.hasNext()) {
-                    SettingsMenuDialog.SettingsTable.Setting setting = (SettingsMenuDialog.SettingsTable.Setting)var1.next();
+                    SettingsMenuDialog.SettingsTable.Setting setting = var1.next();
                     setting.add(table);
                 }
                 table.button(Core.bundle.get("settings.reset", "Reset to Defaults"), () -> {
-                    Iterator var2 = list.iterator();
+                    Iterator<SettingsMenuDialog.SettingsTable.Setting> var2 = list.iterator();
 
                     while(var2.hasNext()) {
-                        SettingsMenuDialog.SettingsTable.Setting setting = (SettingsMenuDialog.SettingsTable.Setting)var1.next();
+                        SettingsMenuDialog.SettingsTable.Setting setting = var1.next();
                         if (setting.name != null && setting.title != null) {
                             Core.settings.put(setting.name, Core.settings.getDefault(setting.name));
                         }