From 61a8a300d8e23e5f012aa5967c99b55f79568fd0 Mon Sep 17 00:00:00 2001 From: Sputnuc Date: Fri, 29 Aug 2025 14:43:00 +0500 Subject: [PATCH 1/4] =?UTF-8?q?=D0=94=D0=95=D0=91=D0=98=D0=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/hjsonpp/HjsonPlusPlusMod.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hjsonpp/HjsonPlusPlusMod.java b/src/hjsonpp/HjsonPlusPlusMod.java index 9125d83..66756fb 100644 --- a/src/hjsonpp/HjsonPlusPlusMod.java +++ b/src/hjsonpp/HjsonPlusPlusMod.java @@ -10,7 +10,7 @@ public HjsonPlusPlusMod(){ ClassMap.classes.put("TileGenerator", hjsonpp.expand.TileGenerator.class); ClassMap.classes.put("AdvancedCoreBlock", hjsonpp.expand.AdvancedCoreBlock.class); ClassMap.classes.put("GeneratorCoreBlock", hjsonpp.expand.GeneratorCoreBlock.class); - ClassMap.classes.put("ColliderCrafter", hjsonpp.expand.ColiderCrafter.class); + ClassMap.classes.put("ColiderCrafter", hjsonpp.expand.ColiderCrafter.class); ClassMap.classes.put("AccelTurret", hjsonpp.expand.AccelTurret.class); ClassMap.classes.put("OverHeatTurret", hjsonpp.expand.OverHeatTurret.class); ClassMap.classes.put("HealingWall", hjsonpp.expand.HealingWall.class); From bc4b46600859816d78c57360956b1539243df5de Mon Sep 17 00:00:00 2001 From: Sputnuc Date: Fri, 29 Aug 2025 14:46:43 +0500 Subject: [PATCH 2/4] =?UTF-8?q?=D0=9B=D1=8F=20=D0=BF=D0=B8=D0=B7=D0=B4?= =?UTF-8?q?=D0=B5=D1=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/hjsonpp/HjsonPlusPlusMod.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hjsonpp/HjsonPlusPlusMod.java b/src/hjsonpp/HjsonPlusPlusMod.java index 5f41b45..9e818b1 100644 --- a/src/hjsonpp/HjsonPlusPlusMod.java +++ b/src/hjsonpp/HjsonPlusPlusMod.java @@ -10,9 +10,9 @@ public HjsonPlusPlusMod(){ ClassMap.classes.put("TileGenerator", hjsonpp.expand.TileGenerator.class); ClassMap.classes.put("AdvancedCoreBlock", hjsonpp.expand.AdvancedCoreBlock.class); ClassMap.classes.put("GeneratorCoreBlock", hjsonpp.expand.GeneratorCoreBlock.class); - ClassMap.classes.put("ColiderCrafter", hjsonpp.expand.ColiderCrafter.class); + ClassMap.classes.put("ColliderCrafter", hjsonpp.expand.ColiderCrafter.class); ClassMap.classes.put("AccelTurret", hjsonpp.expand.AccelTurret.class); - ClassMap.classes.put("OverHeatTurret", hjsonpp.expand.OverHeatTurret.class); + ClassMap.classes.put("OverheatTurret", hjsonpp.expand.OverHeatTurret.class); //ClassMap.classes.put("HealingWall", hjsonpp.expand.HealingWall.class); ClassMap.classes.put("AdjustableShieldWall", hjsonpp.expand.AdjustableShieldWall.class); //ClassMap.classes.put("AdjustableBeamNode", hjsonpp.expand.AdjustableBeamNode.class); From 62e096901c3a941eaf31693e4f315037e9d916ae Mon Sep 17 00:00:00 2001 From: Sputnuc Date: Fri, 19 Sep 2025 19:59:31 +0500 Subject: [PATCH 3/4] AccelTurretUpdate --- src/hjsonpp/expand/AccelTurret.java | 115 ++++++++++++++++--- src/hjsonpp/expand/meta/AdditionalStats.java | 4 +- src/hjsonpp/util/Utilites.java | 19 +++ 3 files changed, 123 insertions(+), 15 deletions(-) create mode 100644 src/hjsonpp/util/Utilites.java diff --git a/src/hjsonpp/expand/AccelTurret.java b/src/hjsonpp/expand/AccelTurret.java index e1f8860..fe93afa 100644 --- a/src/hjsonpp/expand/AccelTurret.java +++ b/src/hjsonpp/expand/AccelTurret.java @@ -1,18 +1,34 @@ package hjsonpp.expand; + import arc.Core; +import arc.graphics.Color; import arc.math.*; import arc.util.*; +import arc.util.io.*; +import hjsonpp.expand.meta.AdditionalStats; +import hjsonpp.util.Utilites; +import mindustry.content.Fx; +import mindustry.entities.Effect; import mindustry.entities.bullet.BulletType; import mindustry.graphics.Pal; import mindustry.ui.Bar; import mindustry.world.blocks.defense.turrets.*; +import mindustry.world.consumers.ConsumeLiquidFilter; +import mindustry.world.meta.Stat; +import mindustry.world.meta.StatUnit; +import static mindustry.Vars.tilesize; -// thanks to Sputnuc for giving me this code public class AccelTurret extends ItemTurret { public float speedUpPerShoot = 2; public float maxAccel = 0.5f; public float cooldownSpeed = 1; + public boolean canOverheat = false; + public float overheatMultiplier = 1f; + public float maxOverheatThreshold = 800f; + public int overheatTime = 60; + public float overheatEffectChance = 0.05f; + public Effect overheatEffect = Fx.none; public AccelTurret(String name){ super(name); @@ -23,40 +39,92 @@ public void setBars(){ super.setBars(); addBar("speedingUp", (AccelTurretBuild entity) -> new Bar( - () -> Core.bundle.format("bar.speedingUp", Strings.autoFixed((entity.speedUp)* 100, 0)), + () -> Core.bundle.format("bar.speedingUp", Strings.autoFixed((entity.speedUp/maxAccel) * 100, 0)), () -> Pal.powerBar, () -> entity.speedUp / maxAccel ) ); + if(canOverheat) addBar("overheat", (AccelTurretBuild entity) -> + new Bar( + () -> Core.bundle.format("bar.overheat", Strings.autoFixed((entity.overheat/maxOverheatThreshold) * 100, 0)), + () -> entity.overheated ? Color.valueOf("f54c4c") : Utilites.lerpColor(Color.valueOf("f0f7c3"), Color.valueOf("eb8e4b"), entity.overheat / maxOverheatThreshold), + () -> entity.overheat / maxOverheatThreshold + ) + ); } + @Override - public void init(){ - super.init(); + public void setStats(){ + super.setStats(); + stats.remove(Stat.reload); + stats.add(AdditionalStats.reloadFrom, reload / 60f, StatUnit.seconds); + stats.add(AdditionalStats.reloadTo, (reload / (maxAccel + 1.0f)) / 60f, StatUnit.seconds); } public class AccelTurretBuild extends ItemTurretBuild { - public float speedUp = 0; + protected float overheat = 0; + protected float speedUp = 0; + protected float coolantSpeedMultiplier; + protected boolean overheated = false; @Override public void updateTile() { //coolDown progress - if (!isShooting() || !hasAmmo()){ - speedUp = Mathf.lerpDelta(speedUp, 0, cooldownSpeed / 20); + if (!isShooting() || !hasAmmo() || !isActive() || overheated && canOverheat){ + + if(speedUp > 0) { + speedUp -= delta() * cooldownSpeed; + + }else { + speedUp = 0; + }; + + if (overheat > 0) { + overheat -= delta() * 0.1f * cooldownSpeed; + overheat -= coolantSpeedMultiplier; + } + + if(overheated && Mathf.chance(overheatEffectChance)) overheatEffect.at(x + Mathf.range(size * tilesize / 2f), y + Mathf.range(size * tilesize / 2f)); } + checkOverheat(); super.updateTile(); } @Override + protected void updateCooling(){ + if(coolant != null && coolant.efficiency(this) > 0 && efficiency > 0){ + float capacity = coolant instanceof ConsumeLiquidFilter filter ? filter.getConsumed(this).heatCapacity : (coolant.consumes(liquids.current()) ? liquids.current().heatCapacity : 0.4f); + float amount = coolant.amount * coolant.efficiency(this); + coolant.update(this); + coolantSpeedMultiplier = amount * capacity * coolantMultiplier * ammoReloadMultiplier(); + if(Mathf.chance(0.06 * amount)){ + coolEffect.at(x + Mathf.range(size * tilesize / 2f), y + Mathf.range(size * tilesize / 2f)); + } + } + } + public void checkOverheat(){ + if(overheat >= maxOverheatThreshold && !overheated && canOverheat) overheated = true; + if(overheated) { + overheat -= (delta() / overheatTime) * coolantSpeedMultiplier; + if(overheat <= 0){ + overheat = 0; + overheated = false; + } + } + if (overheat < 0) overheat = 0; + } + @Override public void updateShooting(){ //override shooting method if (reloadCounter >= reload) { + if (!overheated || !canOverheat) { + BulletType type = peekAmmo(); - BulletType type = peekAmmo(); - - shoot(type); - reloadCounter = 0; + shoot(type); + reloadCounter = 0; + } } else { - reloadCounter += (1 + speedUp) * Time.delta * peekAmmo().reloadMultiplier * baseReloadSpeed(); + reloadCounter += (1 + speedUp) * edelta() * baseReloadSpeed(); } } @Override @@ -64,10 +132,29 @@ public void shoot(BulletType type){ //speedUp per shoot super.shoot(type); if (speedUp < maxAccel){ - speedUp += speedUpPerShoot * Time.delta; + speedUp += speedUpPerShoot * edelta(); + speedUp += coolantSpeedMultiplier * delta(); + if(speedUp>maxAccel) speedUp = maxAccel; }else { speedUp = maxAccel; } + if(canOverheat) overheat += delta() * speedUpPerShoot * overheatMultiplier; + } + @Override + public void write(Writes write){ + super.write(write); + write.f(speedUp); + write.f(overheat); + write.bool(overheated); + } + + @Override + public void read(Reads read, byte revision){ + super.read(read, revision); + speedUp = read.f();; + overheat = read.f(); + overheated = read.bool(); } } -} \ No newline at end of file +} + diff --git a/src/hjsonpp/expand/meta/AdditionalStats.java b/src/hjsonpp/expand/meta/AdditionalStats.java index 9c2555f..32bc7f5 100644 --- a/src/hjsonpp/expand/meta/AdditionalStats.java +++ b/src/hjsonpp/expand/meta/AdditionalStats.java @@ -6,5 +6,7 @@ public class AdditionalStats{ public static Stat healPercent = new Stat("heal-percent", StatCat.general), - produceChance = new Stat("produce-chance", StatCat.crafting); + produceChance = new Stat("produce-chance", StatCat.crafting), + reloadFrom = new Stat("expansion-reload-at-start", Stat.reload.category), + reloadTo = new Stat("expansion-reload-at-end", Stat.reload.category); } diff --git a/src/hjsonpp/util/Utilites.java b/src/hjsonpp/util/Utilites.java new file mode 100644 index 0000000..148b072 --- /dev/null +++ b/src/hjsonpp/util/Utilites.java @@ -0,0 +1,19 @@ +package hjsonpp.util; + +import arc.graphics.Color; +import arc.math.Mathf; + +public class Utilites { + public static Color lerpColor(Color color1, Color color2, float progress) { + progress = Mathf.clamp(progress, 0f, 1f); + + Color clr = new Color(); + + clr.r = Mathf.lerp(color1.r, color2.r, progress); + clr.g = Mathf.lerp(color1.g, color2.g, progress); + clr.b = Mathf.lerp(color1.b, color2.b, progress); + clr.a = Mathf.lerp(color1.a, color2.a, progress); + + return clr; + } +} From 18bc08b3651d75cd0121bf8c3a18befd13cc29da Mon Sep 17 00:00:00 2001 From: Sputnuc Date: Sat, 20 Sep 2025 00:37:18 +0500 Subject: [PATCH 4/4] =?UTF-8?q?=D0=AD=D1=82=D0=BE=20=D0=BD=D0=B0=D0=B4?= =?UTF-8?q?=D0=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/hjsonpp/expand/AccelTurret.java | 47 ++++++++++++++++++++++++----- 1 file changed, 40 insertions(+), 7 deletions(-) diff --git a/src/hjsonpp/expand/AccelTurret.java b/src/hjsonpp/expand/AccelTurret.java index fe93afa..8856197 100644 --- a/src/hjsonpp/expand/AccelTurret.java +++ b/src/hjsonpp/expand/AccelTurret.java @@ -65,18 +65,18 @@ public class AccelTurretBuild extends ItemTurretBuild { protected float overheat = 0; protected float speedUp = 0; protected float coolantSpeedMultiplier; + protected float overheatCoolantSpdMultiplier; protected boolean overheated = false; @Override public void updateTile() { - //coolDown progress + //cooldown progress if (!isShooting() || !hasAmmo() || !isActive() || overheated && canOverheat){ - if(speedUp > 0) { speedUp -= delta() * cooldownSpeed; }else { speedUp = 0; - }; + } if (overheat > 0) { overheat -= delta() * 0.1f * cooldownSpeed; @@ -84,13 +84,43 @@ public void updateTile() { } if(overheated && Mathf.chance(overheatEffectChance)) overheatEffect.at(x + Mathf.range(size * tilesize / 2f), y + Mathf.range(size * tilesize / 2f)); + } checkOverheat(); - super.updateTile(); + if(!overheated) { + super.updateTile(); + }else { + if(linearWarmup){ + shootWarmup = Mathf.approachDelta(shootWarmup, 0, shootWarmupSpeed); + }else{ + shootWarmup = Mathf.lerpDelta(shootWarmup, 0, shootWarmupSpeed); + } + + unit.tile(this); + unit.rotation(rotation); + unit.team(team); + speedUp = Mathf.approachDelta(speedUp, 0, cooldownSpeed * 2); + curRecoil = Mathf.approachDelta(curRecoil, 0, 1 / recoilTime); + recoilOffset.trns(rotation, -Mathf.pow(curRecoil, recoilPow) * recoil); + reloadCounter = Mathf.lerpDelta(reloadCounter, 0, 0.1f); + if(logicControlTime > 0){ + logicControlTime -= Time.delta; + } + } + } + + protected void updOverheatCooling(){ + if(overheated){ + if (coolant != null && coolant.efficiency(this) > 0 && efficiency > 0) { + coolant.update(this); + overheatCoolantSpdMultiplier = liquids.current() == null ? 0 : liquids.current().heatCapacity * coolantMultiplier; + } else overheatCoolantSpdMultiplier = 0; + } } + @Override protected void updateCooling(){ - if(coolant != null && coolant.efficiency(this) > 0 && efficiency > 0){ + if(reloadCounter < reload && coolant != null && coolant.efficiency(this) > 0 && efficiency > 0){ float capacity = coolant instanceof ConsumeLiquidFilter filter ? filter.getConsumed(this).heatCapacity : (coolant.consumes(liquids.current()) ? liquids.current().heatCapacity : 0.4f); float amount = coolant.amount * coolant.efficiency(this); coolant.update(this); @@ -100,10 +130,13 @@ protected void updateCooling(){ } } } + public void checkOverheat(){ if(overheat >= maxOverheatThreshold && !overheated && canOverheat) overheated = true; if(overheated) { - overheat -= (delta() / overheatTime) * coolantSpeedMultiplier; + overheat -= (delta() / overheatTime); + updOverheatCooling(); + overheat -= overheatCoolantSpdMultiplier; if(overheat <= 0){ overheat = 0; overheated = false; @@ -151,7 +184,7 @@ public void write(Writes write){ @Override public void read(Reads read, byte revision){ super.read(read, revision); - speedUp = read.f();; + speedUp = read.f(); overheat = read.f(); overheated = read.bool(); }