Merge pull request #24 from RKN-bot-discord/main

Big think

Author: 5GameMaker

src/main/java/castle/CastleCommandAI.java

@@ -16,7 +16,10 @@ public void updateUnit() {
         if (!hasCommand() && onEnemySide(unit)) {
              target = attackTarget = unit.closestEnemyCore();
 
-            if (unit.type.flying) moveTo(target, unit.type.range * 0.8f);
+            if (unit.type.flying){
+                if (unit.health>unit.type.health*0.5) moveTo(target, unit.type.range * 0.8f);
+                else moveTo(target, 0f);
+            }
             else pathfind(Pathfinder.fieldCore);
 
             if (!invalid(target) && unit.type.circleTarget)

src/main/java/castle/CastleGenerator.java

@@ -4,6 +4,7 @@
 import arc.math.Mathf;
 import arc.math.geom.Point2;
 import arc.struct.Seq;
+import arc.util.Time;
 import mindustry.content.*;
 import mindustry.game.Team;
 import mindustry.gen.Call;
@@ -14,15 +15,23 @@
 import mindustry.world.blocks.distribution.Sorter.SorterBuild;
 import mindustry.world.blocks.environment.SpawnBlock;
 import mindustry.world.blocks.storage.CoreBlock;
-import useful.Bundle;
-
+import mindustry.world.blocks.logic.LogicBlock.LogicBuild;
+import mindustry.world.blocks.logic.LogicBlock.LogicLink;
+import static mindustry.Vars.*;
+import castle.CastleRooms.BlockRoom;
+import castle.CastleRooms.EffectRoom;
+import castle.CastleRooms.MinerRoom;
+import castle.CastleRooms.Room;
+import castle.CastleRooms.UnitRoom;
 import static castle.CastleRooms.*;
 import static castle.CastleUtils.drill;
 import static castle.CastleUtils.refreshMeta;
 import static castle.CastleUtils.revealedUnits;
 import static castle.CastleUtils.shopFloor;
 import static castle.Main.*;
-import static mindustry.Vars.*;
+import useful.Bundle;
+
+
 
 public class CastleGenerator {
     public static final int unitLimitX = 5, unitLimitY = 3, effectLimitX = 4;
@@ -95,6 +104,38 @@ public static void generate() {
                         () -> new MinerRoom(drill, sorter.config(), CastleCosts.items.get(sorter.config())));
             }
 
+            if (tile.build instanceof LogicBuild logicBlock) {
+
+                var code = logicBlock.code;
+                var linksProcessor = logicBlock.links.copy();
+                var tileEdit = world.tile(x, y);
+                var tileNew = world.tile(x, world.height() - y);
+
+                tileEdit.setNet(tile.block(), tile.build.team(), 0);
+                tileNew.setNet(tile.block(), Team.blue, 180);
+
+                int yCoordinate = (int) tile.build.getY()/8;
+                Seq<LogicLink> mirroredLinks = new Seq<>();
+
+                for (LogicLink link : logicBlock.links) {
+                    int xLink = link.x;
+                    int yLink = world.height() - yCoordinate -(link.y - yCoordinate);
+                    LogicLink mirrored = new LogicLink(xLink, yLink, link.name, link.valid);
+                    mirroredLinks.add(mirrored);
+                }
+
+                if (tileEdit.build instanceof LogicBuild logicBlockEdit) {
+                    logicBlockEdit.updateCode(code);
+                    logicBlockEdit.links.set(linksProcessor);
+                    logicBlockEdit.updateTile();
+                }
+                if (tileNew.build instanceof LogicBuild newLogicBlock) {
+                    newLogicBlock.updateCode(code);
+                    newLogicBlock.links.set(mirroredLinks);
+                    newLogicBlock.updateTile();
+                }
+            }
+
             if (tile.overlay() instanceof SpawnBlock)
                 spawns.add(x, y);
         });
@@ -210,7 +251,7 @@ public void spawn(Player summonner, Team team, UnitType type) {
                 spawn = get(team).cpy().add(Mathf.range(tilesize), Mathf.range(tilesize));
             } while (!validFor(type, spawn));
             var prevLimit = state.rules.unitCap;
-            state.rules.unitCap = Integer.MAX_VALUE;
+            state.rules.unitCap = 500;
             var unit = type.spawn(team, spawn.x * tilesize, spawn.y * tilesize);
             state.rules.unitCap = prevLimit;
             Bundle.label(1f, unit.getX(), unit.getY(), "rooms.unit.bought", summonner.coloredName());

src/main/java/castle/CastleRooms.java

@@ -1,22 +1,34 @@
 package castle;
 
+import arc.math.geom.Point2;
+import arc.struct.Seq;
 import arc.math.Mathf;
 import arc.util.*;
 import castle.CastleCosts.*;
 import mindustry.Vars;
 import mindustry.content.*;
+import mindustry.world.*;
 import mindustry.game.Team;
 import mindustry.gen.*;
 import mindustry.type.*;
 import mindustry.world.*;
+import mindustry.gen.Player;
+import mindustry.type.UnitType;
 import mindustry.world.blocks.ConstructBlock;
 import mindustry.world.blocks.storage.CoreBlock;
-import useful.Bundle;
+import useful.Bundle; 
+import mindustry.Vars;
 
 import static castle.CastleUtils.boatSpawnX;
 import static castle.CastleUtils.boatSpawnY;
+import static castle.CastleUtils.landSpawnX;
+import static castle.CastleUtils.landSpawnY;
+import static castle.CastleUtils.airSpawnX;
+import static castle.CastleUtils.airSpawnY;
 import static castle.CastleUtils.generatePlatforms;
 import static castle.CastleUtils.platformSource;
+import static castle.CastleUtils.defenseCap;
+import static castle.CastleUtils.attackCap;
 import static castle.Main.*;
 
 public class CastleRooms {
@@ -180,44 +192,80 @@ public UnitRoom(UnitType type, UnitData data, boolean attack) {
             this.income = attack ? data.income() : -data.income();
         }
 
+        private boolean validFor(UnitType type, int x,int y) {
+
+            var tile = Vars.world.tile(x, y);
+            if (tile == null ||
+            (!type.flying && !tile.block().isAir()) ||
+            (type.naval && !tile.floor().isLiquid) )
+                return false;
+            return true;
+        }
+
+        private void spawnUnit(PlayerData data, float x, float y, UnitType type, boolean core_spawn) {
+            Unit unit = null;
+            var i = 0;
+            var y_coordinate = 0.0;
+            if (core_spawn == true){
+                y_coordinate = Math.round((data.team().team == Team.blue ? Vars.world.height() - y : y) * 8 + Mathf.range(48f));
+            }
+            else{
+                y_coordinate = y + Mathf.range(48f);
+            }
+            while(i < 10 && !validFor(type,Math.round((int)x),Math.round((int)y_coordinate/8))){
+                    if (core_spawn == true){ 
+                        y_coordinate = Math.round((data.team().team == Team.blue ? Vars.world.height() - y : y) * 8 + Mathf.range(48f));
+                    }
+                    else{
+                        y_coordinate = y + Mathf.range(48f);
+                    }
+                    i++;
+            }
+            unit = type.spawn(
+                data.player.team(),
+                x * 8 + 48f,Math.round(y_coordinate));
+            Bundle.label(1f, unit.getX(), unit.getY(), "rooms.unit.bought", data.player.coloredName());
+        }
+
+
         @Override
         public void buy(PlayerData data) {
             super.buy(data);
             data.income += income;
 
             if (attack) spawns.spawn(data.player, data.player.team(), type);
             else if ((boatSpawnX > 0 && boatSpawnY > 0) && type.naval) {
-                var prevLimit = Vars.state.rules.unitCap;
-                Vars.state.rules.unitCap = Integer.MAX_VALUE;
-                var unit = type.spawn(
-                    data.player.team(),
-                    boatSpawnX * 8f,
-                    (data.team().team == Team.blue ? Vars.world.height() - boatSpawnY : boatSpawnY) * 8f + Mathf.range(48f));
-                Bundle.label(1f, unit.getX(), unit.getY(), "rooms.unit.bought", data.player.coloredName());
-                Vars.state.rules.unitCap = prevLimit;
+                spawnUnit(data, boatSpawnX, boatSpawnY, type, true);
+            }
+            else if ((landSpawnX > 0 && landSpawnY > 0) && !type.naval && !type.flying) {
+                spawnUnit(data, landSpawnX, landSpawnY, type, true);
+            }
+            else if ((airSpawnX > 0 && airSpawnY > 0) && type.flying) {
+                spawnUnit(data, airSpawnX, airSpawnY, type, true);
             }
             else if (data.player.core() != null) {
                 var core = data.player.core();
-                var prevLimit = Vars.state.rules.unitCap;
-                Vars.state.rules.unitCap = Integer.MAX_VALUE;
-                var unit = type.spawn(data.player.team(), core.x + 48f, core.y + Mathf.range(48f));
-                Bundle.label(1f, unit.getX(), unit.getY(), "rooms.unit.bought", data.player.coloredName());
-                Vars.state.rules.unitCap = prevLimit;
-            }
+                spawnUnit(data, core.x/8, core.y, type, false);
+            };
         }
 
         @Override
         public boolean canBuy(PlayerData data) {
             if (!super.canBuy(data)) return false;
-
-            if (data.team().getUnitCount() >= Vars.state.rules.unitCap) {
-                Bundle.announce(data.player, "rooms.unit.limit");
-                return false;
+            if (attack){
+                if(data.team().getUnitCountAttack()>=attackCap) {
+                    Bundle.announce(data.player, "rooms.unit.limit");
+                    return false;
+                }
+            }
+            else{
+                if(data.team().getUnitCountDefense()>=defenseCap){ 
+                    Bundle.announce(data.player, "rooms.unit.limit");
+                    return false;
+                }
             }
-
             return true;
         }
-
         @Override
         public String toString() {
             return type.emoji() + " " + (attack ? "[accent]\uE865" : "[scarlet]\uE84D") +

src/main/java/castle/CastleUtils.java

@@ -1,12 +1,14 @@
 package castle;
 
+import arc.Core;
 import mindustry.Vars;
 import mindustry.content.Blocks;
 import mindustry.content.Items;
 import mindustry.content.Planets;
 import mindustry.game.*;
 import mindustry.game.MapObjectives.FlagObjective;
 import mindustry.gen.Teamc;
+import mindustry.gen.Building;
 import mindustry.type.Item;
 import mindustry.type.UnitType;
 import mindustry.type.unit.ErekirUnitType;
@@ -20,9 +22,13 @@
 import mindustry.world.blocks.units.UnitFactory;
 import mindustry.world.meta.BlockGroup;
 import mindustry.world.meta.Env;
+import mindustry.gen.Call;
+import arc.util.io.Writes;
 
 import static mindustry.Vars.*;
 
+import java.io.DataOutputStream;
+import arc.util.io.ReusableByteOutStream;
 import arc.struct.Seq;
 import arc.util.Log;
 import arc.util.Nullable;
@@ -39,6 +45,8 @@ public class CastleUtils {
     public static short landSpawnY = -1;
     public static short airSpawnX = -1;
     public static short airSpawnY = -1;
+    public static short defenseCap = 150;
+    public static short attackCap = 350;
 
     public static boolean any(String[] array, String value) {
         for (var test : array)
@@ -59,8 +67,6 @@ public static void refreshMeta() {
         generatePlatforms = true;
         platformSource.clear();
         shopFloor = Blocks.space.asFloor();
-        boatSpawnX = -1;
-        boatSpawnY = -1;
 
         for (var objective : state.rules.objectives.all) {
             if (objective instanceof FlagObjective flag) {
@@ -126,6 +132,24 @@ public static void refreshMeta() {
                         airSpawnY = -1;
                     }
                 }
+                if (flag.flag.startsWith("defenseCap ")) {
+                    try {
+                        String[] args = flag.flag.split(" ");
+                        defenseCap = Short.valueOf(args[1]);
+                    } catch (Exception error) {
+                        Log.warn("Failed to set Defense Cap!\n" + error);
+                        defenseCap = 150;
+                    }
+                }
+                if (flag.flag.startsWith("attackCap ")) {
+                    try {
+                        String[] args = flag.flag.split(" ");
+                        attackCap = Short.valueOf(args[1]);
+                    } catch (Exception error) {
+                        Log.warn("Failed to set Attack Cap!\n" + error);
+                        attackCap = 350;
+                    }
+                }
             }
         }
 
@@ -137,6 +161,26 @@ public static void refreshMeta() {
         }
     }
 
+    public static void syncBlock(Building block_sync, ReusableByteOutStream syncStream, DataOutputStream dataStream){
+        try{
+            final Building block = block_sync; 
+            Core.app.post(() -> {
+                        try {
+                            syncStream.reset();
+                            dataStream.writeInt(block.pos());
+                            dataStream.writeShort(block.block().id);
+                            block.writeAll(Writes.get(dataStream));
+                            dataStream.close();
+                            Call.blockSnapshot((short) 1, syncStream.toByteArray());
+                            syncStream.reset();
+                        } catch (Exception ohshit) {
+                            throw new RuntimeException(ohshit);
+            }});
+        }catch(Exception e){
+            e.printStackTrace();
+        }
+    }
+
     public static void applyRules(Rules rules) {
         rules.waveTimer = rules.waves = rules.waveSending = false;
         rules.pvp = rules.attackMode = rules.polygonCoreProtection = true;