it is done

core/src/mindustry/entities/effect/Decal.java

@@ -0,0 +1,36 @@
+package mindustry.entities.effect;
+
+import arc.graphics.g2d.Draw;
+import arc.math.Mathf;
+import mindustry.entities.EntityGroup;
+import mindustry.entities.type.TimedEntity;
+import mindustry.entities.traits.BelowLiquidTrait;
+import mindustry.entities.traits.DrawTrait;
+import mindustry.graphics.Pal;
+
+import static mindustry.Vars.groundEffectGroup;
+
+/**
+ * Class for creating block rubble on the ground.
+ */
+public abstract class Decal extends TimedEntity implements BelowLiquidTrait, DrawTrait{
+
+    @Override
+    public float lifetime(){
+        return 3600;
+    }
+
+    @Override
+    public void draw(){
+        Draw.color(Pal.rubble.r, Pal.rubble.g, Pal.rubble.b, 1f - Mathf.curve(fin(), 0.98f));
+        drawDecal();
+        Draw.color();
+    }
+
+    @Override
+    public EntityGroup targetGroup(){
+        return groundEffectGroup;
+    }
+
+    abstract void drawDecal();
+}

core/src/mindustry/entities/effect/Fire.java

@@ -0,0 +1,229 @@
+package mindustry.entities.effect;
+
+import arc.*;
+import mindustry.annotations.Annotations.*;
+import arc.struct.*;
+import arc.math.*;
+import arc.math.geom.*;
+import arc.util.*;
+import mindustry.content.*;
+import mindustry.entities.*;
+import mindustry.entities.traits.*;
+import mindustry.entities.type.*;
+import mindustry.game.EventType.*;
+import mindustry.game.*;
+import mindustry.gen.*;
+import mindustry.type.*;
+import mindustry.world.*;
+
+import java.io.*;
+
+import static mindustry.Vars.*;
+
+public class Fire extends TimedEntity implements SaveTrait, SyncTrait{
+    private static final IntMap<Fire> map = new IntMap<>();
+    private static final float baseLifetime = 1000f, spreadChance = 0.05f, fireballChance = 0.07f;
+
+    private int loadedPosition = -1;
+    private Tile tile;
+    private Block block;
+    private float baseFlammability = -1, puddleFlammability;
+    private float lifetime;
+
+    /** Deserialization use only! */
+    public Fire(){
+    }
+
+    @Remote
+    public static void onRemoveFire(int fid){
+        fireGroup.removeByID(fid);
+    }
+
+    /** Start a fire on the tile. If there already is a file there, refreshes its lifetime. */
+    public static void create(Tile tile){
+        if(net.client() || tile == null) return; //not clientside.
+
+        Fire fire = map.get(tile.pos());
+
+        if(fire == null){
+            fire = new Fire();
+            fire.tile = tile;
+            fire.lifetime = baseLifetime;
+            fire.set(tile.worldx(), tile.worldy());
+            fire.add();
+            map.put(tile.pos(), fire);
+        }else{
+            fire.lifetime = baseLifetime;
+            fire.time = 0f;
+        }
+    }
+
+    public static boolean has(int x, int y){
+        if(!Structs.inBounds(x, y, world.width(), world.height()) || !map.containsKey(Pos.get(x, y))){
+            return false;
+        }
+        Fire fire = map.get(Pos.get(x, y));
+        return fire.isAdded() && fire.fin() < 1f && fire.tile != null && fire.tile.x == x && fire.tile.y == y;
+    }
+
+    /**
+     * Attempts to extinguish a fire by shortening its life. If there is no fire here, does nothing.
+     */
+    public static void extinguish(Tile tile, float intensity){
+        if(tile != null && map.containsKey(tile.pos())){
+            Fire fire = map.get(tile.pos());
+            fire.time += intensity * Time.delta();
+            if(fire.time >= fire.lifetime()){
+                Events.fire(Trigger.fireExtinguish);
+            }
+        }
+    }
+
+    @Override
+    public TypeID getTypeID(){
+        return TypeIDs.fire;
+    }
+
+    @Override
+    public byte version(){
+        return 0;
+    }
+
+    @Override
+    public float lifetime(){
+        return lifetime;
+    }
+
+    @Override
+    public void update(){
+        if(Mathf.chance(0.1 * Time.delta())){
+            Effects.effect(Fx.fire, x + Mathf.range(4f), y + Mathf.range(4f));
+        }
+
+        if(Mathf.chance(0.05 * Time.delta())){
+            Effects.effect(Fx.fireSmoke, x + Mathf.range(4f), y + Mathf.range(4f));
+        }
+
+        if(Mathf.chance(0.001 * Time.delta())){
+            Sounds.fire.at(this);
+        }
+
+        time = Mathf.clamp(time + Time.delta(), 0, lifetime());
+        map.put(tile.pos(), this);
+
+        if(net.client()){
+            return;
+        }
+
+        if(time >= lifetime() || tile == null){
+            remove();
+            return;
+        }
+
+        TileEntity entity = tile.link().entity;
+        boolean damage = entity != null;
+
+        float flammability = baseFlammability + puddleFlammability;
+
+        if(!damage && flammability <= 0){
+            time += Time.delta() * 8;
+        }
+
+        if(baseFlammability < 0 || block != tile.block()){
+            baseFlammability = tile.block().getFlammability(tile);
+            block = tile.block();
+        }
+
+        if(damage){
+            lifetime += Mathf.clamp(flammability / 8f, 0f, 0.6f) * Time.delta();
+        }
+
+        if(flammability > 1f && Mathf.chance(spreadChance * Time.delta() * Mathf.clamp(flammability / 5f, 0.3f, 2f))){
+            Point2 p = Geometry.d4[Mathf.random(3)];
+            Tile other = world.tile(tile.x + p.x, tile.y + p.y);
+            create(other);
+
+            if(Mathf.chance(fireballChance * Time.delta() * Mathf.clamp(flammability / 10f))){
+                Call.createBullet(Bullets.fireball, Team.derelict, x, y, Mathf.random(360f), 1, 1);
+            }
+        }
+
+        if(Mathf.chance(0.1 * Time.delta())){
+            Puddle p = Puddle.getPuddle(tile);
+            if(p != null){
+                puddleFlammability = p.getFlammability() / 3f;
+            }else{
+                puddleFlammability = 0;
+            }
+
+            if(damage){
+                entity.damage(0.4f);
+            }
+            Damage.damageUnits(null, tile.worldx(), tile.worldy(), tilesize, 3f,
+            unit -> !unit.isFlying() && !unit.isImmune(StatusEffects.burning),
+            unit -> unit.applyEffect(StatusEffects.burning, 60 * 5));
+        }
+    }
+
+    @Override
+    public void writeSave(DataOutput stream) throws IOException{
+        stream.writeInt(tile.pos());
+        stream.writeFloat(lifetime);
+        stream.writeFloat(time);
+    }
+
+    @Override
+    public void readSave(DataInput stream, byte version) throws IOException{
+        this.loadedPosition = stream.readInt();
+        this.lifetime = stream.readFloat();
+        this.time = stream.readFloat();
+        add();
+    }
+
+    @Override
+    public void write(DataOutput data) throws IOException{
+        data.writeInt(tile.pos());
+        data.writeFloat(lifetime);
+    }
+
+    @Override
+    public void read(DataInput data) throws IOException{
+        int pos = data.readInt();
+        this.lifetime = data.readFloat();
+
+        x = Pos.x(pos) * tilesize;
+        y = Pos.y(pos) * tilesize;
+        tile = world.tile(pos);
+    }
+
+    @Override
+    public void reset(){
+        loadedPosition = -1;
+        tile = null;
+        baseFlammability = -1;
+        puddleFlammability = 0f;
+        incrementID();
+    }
+
+    @Override
+    public void added(){
+        if(loadedPosition != -1){
+            map.put(loadedPosition, this);
+            tile = world.tile(loadedPosition);
+            set(tile.worldx(), tile.worldy());
+        }
+    }
+
+    @Override
+    public void removed(){
+        if(tile != null){
+            Call.onRemoveFire(id);
+            map.remove(tile.pos());
+        }
+    }
+
+    @Override
+    public EntityGroup targetGroup(){
+        return fireGroup;
+    }
+}

core/src/mindustry/entities/effect/GroundEffectEntity.java

@@ -0,0 +1,90 @@
+package mindustry.entities.effect;
+
+import arc.math.Mathf;
+import arc.util.Time;
+import mindustry.Vars;
+import mindustry.entities.Effects;
+import mindustry.entities.Effects.Effect;
+import mindustry.entities.Effects.EffectRenderer;
+import mindustry.entities.type.EffectEntity;
+import mindustry.world.Tile;
+
+/**
+ * A ground effect contains an effect that is rendered on the ground layer as opposed to the top layer.
+ */
+public class GroundEffectEntity extends EffectEntity{
+    private boolean once;
+
+    @Override
+    public void update(){
+        GroundEffect effect = (GroundEffect)this.effect;
+
+        if(effect.isStatic){
+            time += Time.delta();
+
+            time = Mathf.clamp(time, 0, effect.staticLife);
+
+            if(!once && time >= lifetime()){
+                once = true;
+                time = 0f;
+                Tile tile = Vars.world.tileWorld(x, y);
+                if(tile != null && tile.floor().isLiquid){
+                    remove();
+                }
+            }else if(once && time >= effect.staticLife){
+                remove();
+            }
+        }else{
+            super.update();
+        }
+    }
+
+    @Override
+    public void draw(){
+        GroundEffect effect = (GroundEffect)this.effect;
+
+        if(once && effect.isStatic)
+            Effects.renderEffect(id, effect, color, lifetime(), rotation, x, y, data);
+        else
+            Effects.renderEffect(id, effect, color, time, rotation, x, y, data);
+    }
+
+    @Override
+    public void reset(){
+        super.reset();
+        once = false;
+    }
+
+    /**
+     * An effect that is rendered on the ground layer as opposed to the top layer.
+     */
+    public static class GroundEffect extends Effect{
+        /**
+         * How long this effect stays on the ground when static.
+         */
+        public final float staticLife;
+        /**
+         * If true, this effect will stop and lie on the ground for a specific duration,
+         * after its initial lifetime is over.
+         */
+        public final boolean isStatic;
+
+        public GroundEffect(float life, float staticLife, EffectRenderer draw){
+            super(life, draw);
+            this.staticLife = staticLife;
+            this.isStatic = true;
+        }
+
+        public GroundEffect(boolean isStatic, float life, EffectRenderer draw){
+            super(life, draw);
+            this.staticLife = 0f;
+            this.isStatic = isStatic;
+        }
+
+        public GroundEffect(float life, EffectRenderer draw){
+            super(life, draw);
+            this.staticLife = 0f;
+            this.isStatic = false;
+        }
+    }
+}

core/src/mindustry/entities/effect/ItemTransfer.java

@@ -0,0 +1,119 @@
+package mindustry.entities.effect;
+
+import mindustry.annotations.Annotations.Loc;
+import mindustry.annotations.Annotations.Remote;
+import arc.graphics.g2d.*;
+import arc.math.Interpolation;
+import arc.math.Mathf;
+import arc.math.geom.Position;
+import arc.math.geom.Vector2;
+import arc.util.Time;
+import arc.util.pooling.Pools;
+import mindustry.entities.*;
+import mindustry.entities.type.TimedEntity;
+import mindustry.entities.traits.DrawTrait;
+import mindustry.entities.type.Unit;
+import mindustry.graphics.Pal;
+import mindustry.type.Item;
+import mindustry.world.Tile;
+
+import static mindustry.Vars.*;
+
+public class ItemTransfer extends TimedEntity implements DrawTrait{
+    private Vector2 from = new Vector2();
+    private Vector2 current = new Vector2();
+    private Vector2 tovec = new Vector2();
+    private Item item;
+    private float seed;
+    private Position to;
+    private Runnable done;
+
+    public ItemTransfer(){
+    }
+
+    @Remote(called = Loc.server, unreliable = true)
+    public static void transferItemEffect(Item item, float x, float y, Unit to){
+        if(to == null) return;
+        create(item, x, y, to, () -> {
+        });
+    }
+
+    @Remote(called = Loc.server, unreliable = true)
+    public static void transferItemToUnit(Item item, float x, float y, Unit to){
+        if(to == null) return;
+        create(item, x, y, to, () -> to.addItem(item));
+    }
+
+    @Remote(called = Loc.server)
+    public static void transferItemTo(Item item, int amount, float x, float y, Tile tile){
+        if(tile == null || tile.entity == null || tile.entity.items == null) return;
+        for(int i = 0; i < Mathf.clamp(amount / 3, 1, 8); i++){
+            Time.run(i * 3, () -> create(item, x, y, tile, () -> {}));
+        }
+        tile.entity.items.add(item, amount);
+    }
+
+    public static void create(Item item, float fromx, float fromy, Position to, Runnable done){
+        ItemTransfer tr = Pools.obtain(ItemTransfer.class, ItemTransfer::new);
+        tr.item = item;
+        tr.from.set(fromx, fromy);
+        tr.to = to;
+        tr.done = done;
+        tr.seed = Mathf.range(1f);
+        tr.add();
+    }
+
+    @Override
+    public float lifetime(){
+        return 60;
+    }
+
+    @Override
+    public void reset(){
+        super.reset();
+        item = null;
+        to = null;
+        done = null;
+        from.setZero();
+        current.setZero();
+        tovec.setZero();
+    }
+
+    @Override
+    public void removed(){
+        if(done != null){
+            done.run();
+        }
+        Pools.free(this);
+    }
+
+    @Override
+    public void update(){
+        if(to == null){
+            remove();
+            return;
+        }
+
+        super.update();
+        current.set(from).interpolate(tovec.set(to.getX(), to.getY()), fin(), Interpolation.pow3);
+        current.add(tovec.set(to.getX(), to.getY()).sub(from).nor().rotate90(1).scl(seed * fslope() * 10f));
+        set(current.x, current.y);
+    }
+
+    @Override
+    public void draw(){
+        Lines.stroke(fslope() * 2f, Pal.accent);
+
+        Lines.circle(x, y, fslope() * 2f);
+
+        Draw.color(item.color);
+        Fill.circle(x, y, fslope() * 1.5f);
+
+        Draw.reset();
+    }
+
+    @Override
+    public EntityGroup targetGroup(){
+        return effectGroup;
+    }
+}

core/src/mindustry/entities/effect/Lightning.java

@@ -0,0 +1,160 @@
+package mindustry.entities.effect;
+
+import mindustry.annotations.Annotations.Loc;
+import mindustry.annotations.Annotations.Remote;
+import arc.struct.Array;
+import arc.struct.IntSet;
+import arc.graphics.Color;
+import arc.graphics.g2d.*;
+import arc.math.*;
+import arc.math.geom.*;
+import arc.util.pooling.Pools;
+import mindustry.content.Bullets;
+import mindustry.entities.EntityGroup;
+import mindustry.entities.Units;
+import mindustry.entities.type.Bullet;
+import mindustry.entities.type.TimedEntity;
+import mindustry.entities.traits.DrawTrait;
+import mindustry.entities.traits.TimeTrait;
+import mindustry.entities.type.Unit;
+import mindustry.game.Team;
+import mindustry.gen.Call;
+import mindustry.graphics.Pal;
+import mindustry.world.Tile;
+
+import static mindustry.Vars.*;
+
+public class Lightning extends TimedEntity implements DrawTrait, TimeTrait{
+    public static final float lifetime = 10f;
+
+    private static final RandomXS128 random = new RandomXS128();
+    private static final Rectangle rect = new Rectangle();
+    private static final Array<Unit> entities = new Array<>();
+    private static final IntSet hit = new IntSet();
+    private static final int maxChain = 8;
+    private static final float hitRange = 30f;
+    private static int lastSeed = 0;
+
+    private Array<Vector2> lines = new Array<>();
+    private Color color = Pal.lancerLaser;
+
+    /** For pooling use only. Do not call directly! */
+    public Lightning(){
+    }
+
+    /** Create a lighting branch at a location. Use Team.none to damage everyone. */
+    public static void create(Team team, Color color, float damage, float x, float y, float targetAngle, int length){
+        Call.createLighting(nextSeed(), team, color, damage, x, y, targetAngle, length);
+    }
+
+    public static int nextSeed(){
+        return lastSeed++;
+    }
+
+    /** Do not invoke! */
+    @Remote(called = Loc.server, unreliable = true)
+    public static void createLighting(int seed, Team team, Color color, float damage, float x, float y, float rotation, int length){
+
+        Lightning l = Pools.obtain(Lightning.class, Lightning::new);
+        Float dmg = damage;
+
+        l.x = x;
+        l.y = y;
+        l.color = color;
+        l.add();
+
+        random.setSeed(seed);
+        hit.clear();
+
+        boolean[] bhit = {false};
+
+        for(int i = 0; i < length / 2; i++){
+            Bullet.create(Bullets.damageLightning, l, team, x, y, 0f, 1f, 1f, dmg);
+            l.lines.add(new Vector2(x + Mathf.range(3f), y + Mathf.range(3f)));
+
+            if(l.lines.size > 1){
+                bhit[0] = false;
+                Position from = l.lines.get(l.lines.size - 2);
+                Position to   = l.lines.get(l.lines.size - 1);
+                world.raycastEach(world.toTile(from.getX()), world.toTile(from.getY()), world.toTile(to.getX()), world.toTile(to.getY()), (wx, wy) -> {
+
+                    Tile tile = world.ltile(wx, wy);
+                    if(tile != null && tile.block().insulated){
+                        bhit[0] = true;
+                        //snap it instead of removing
+                        l.lines.get(l.lines.size -1).set(wx * tilesize, wy * tilesize);
+                        return true;
+                    }
+                    return false;
+                });
+                if(bhit[0]) break;
+            }
+
+            rect.setSize(hitRange).setCenter(x, y);
+            entities.clear();
+            if(hit.size < maxChain){
+                Units.nearbyEnemies(team, rect, u -> {
+                    if(!hit.contains(u.getID())){
+                        entities.add(u);
+                    }
+                });
+            }
+
+            Unit furthest = Geometry.findFurthest(x, y, entities);
+
+            if(furthest != null){
+                hit.add(furthest.getID());
+                x = furthest.x;
+                y = furthest.y;
+            }else{
+                rotation += random.range(20f);
+
+                x += Angles.trnsx(rotation, hitRange / 2f);
+                y += Angles.trnsy(rotation, hitRange / 2f);
+            }
+        }
+    }
+
+    @Override
+    public float lifetime(){
+        return lifetime;
+    }
+
+    @Override
+    public void reset(){
+        super.reset();
+        color = Pal.lancerLaser;
+        lines.clear();
+    }
+
+    @Override
+    public void removed(){
+        super.removed();
+        Pools.free(this);
+    }
+
+    @Override
+    public void draw(){
+        Lines.stroke(3f * fout());
+        Draw.color(color, Color.white, fin());
+        Lines.beginLine();
+
+        Lines.linePoint(x, y);
+        for(Position p : lines){
+            Lines.linePoint(p.getX(), p.getY());
+        }
+        Lines.endLine();
+
+        int i = 0;
+
+        for(Position p : lines){
+            Fill.square(p.getX(), p.getY(), (5f - (float)i++ / lines.size * 2f) * fout(), 45);
+        }
+        Draw.reset();
+    }
+
+    @Override
+    public EntityGroup targetGroup(){
+        return bulletGroup;
+    }
+}

core/src/mindustry/entities/effect/Puddle.java

@@ -0,0 +1,322 @@
+package mindustry.entities.effect;
+
+import mindustry.annotations.Annotations.*;
+import arc.struct.*;
+import arc.graphics.*;
+import arc.graphics.g2d.*;
+import arc.math.*;
+import arc.math.geom.*;
+import arc.util.*;
+import arc.util.pooling.Pool.*;
+import arc.util.pooling.*;
+import mindustry.content.*;
+import mindustry.entities.*;
+import mindustry.entities.traits.*;
+import mindustry.entities.type.*;
+import mindustry.game.*;
+import mindustry.gen.*;
+import mindustry.type.*;
+import mindustry.world.*;
+
+import java.io.*;
+
+import static mindustry.Vars.*;
+
+public class Puddle extends SolidEntity implements SaveTrait, Poolable, DrawTrait, SyncTrait{
+    private static final IntMap<Puddle> map = new IntMap<>();
+    private static final float maxLiquid = 70f;
+    private static final int maxGeneration = 2;
+    private static final Color tmp = new Color();
+    private static final Rectangle rect = new Rectangle();
+    private static final Rectangle rect2 = new Rectangle();
+    private static int seeds;
+
+    private int loadedPosition = -1;
+
+    private float updateTime;
+    private float lastRipple;
+    private Tile tile;
+    private Liquid liquid;
+    private float amount, targetAmount;
+    private float accepting;
+    private byte generation;
+
+    /** Deserialization use only! */
+    public Puddle(){
+    }
+
+    /** Deposists a puddle between tile and source. */
+    public static void deposit(Tile tile, Tile source, Liquid liquid, float amount){
+        deposit(tile, source, liquid, amount, 0);
+    }
+
+    /** Deposists a puddle at a tile. */
+    public static void deposit(Tile tile, Liquid liquid, float amount){
+        deposit(tile, tile, liquid, amount, 0);
+    }
+
+    /** Returns the puddle on the specified tile. May return null. */
+    public static Puddle getPuddle(Tile tile){
+        return map.get(tile.pos());
+    }
+
+    private static void deposit(Tile tile, Tile source, Liquid liquid, float amount, int generation){
+        if(tile == null) return;
+
+        if(tile.floor().isLiquid && !canStayOn(liquid, tile.floor().liquidDrop)){
+            reactPuddle(tile.floor().liquidDrop, liquid, amount, tile,
+            (tile.worldx() + source.worldx()) / 2f, (tile.worldy() + source.worldy()) / 2f);
+
+            Puddle p = map.get(tile.pos());
+
+            if(generation == 0 && p != null && p.lastRipple <= Time.time() - 40f){
+                Effects.effect(Fx.ripple, tile.floor().liquidDrop.color,
+                (tile.worldx() + source.worldx()) / 2f, (tile.worldy() + source.worldy()) / 2f);
+                p.lastRipple = Time.time();
+            }
+            return;
+        }
+
+        Puddle p = map.get(tile.pos());
+        if(p == null){
+            if(net.client()) return; //not clientside.
+
+            Puddle puddle = Pools.obtain(Puddle.class, Puddle::new);
+            puddle.tile = tile;
+            puddle.liquid = liquid;
+            puddle.amount = amount;
+            puddle.generation = (byte)generation;
+            puddle.set((tile.worldx() + source.worldx()) / 2f, (tile.worldy() + source.worldy()) / 2f);
+            puddle.add();
+            map.put(tile.pos(), puddle);
+        }else if(p.liquid == liquid){
+            p.accepting = Math.max(amount, p.accepting);
+
+            if(generation == 0 && p.lastRipple <= Time.time() - 40f && p.amount >= maxLiquid / 2f){
+                Effects.effect(Fx.ripple, p.liquid.color, (tile.worldx() + source.worldx()) / 2f, (tile.worldy() + source.worldy()) / 2f);
+                p.lastRipple = Time.time();
+            }
+        }else{
+            p.amount += reactPuddle(p.liquid, liquid, amount, p.tile, p.x, p.y);
+        }
+    }
+
+    /**
+     * Returns whether the first liquid can 'stay' on the second one.
+     * Currently, the only place where this can happen is oil on water.
+     */
+    private static boolean canStayOn(Liquid liquid, Liquid other){
+        return liquid == Liquids.oil && other == Liquids.water;
+    }
+
+    /** Reacts two liquids together at a location. */
+    private static float reactPuddle(Liquid dest, Liquid liquid, float amount, Tile tile, float x, float y){
+        if((dest.flammability > 0.3f && liquid.temperature > 0.7f) ||
+        (liquid.flammability > 0.3f && dest.temperature > 0.7f)){ //flammable liquid + hot liquid
+            Fire.create(tile);
+            if(Mathf.chance(0.006 * amount)){
+                Call.createBullet(Bullets.fireball, Team.derelict, x, y, Mathf.random(360f), 1f, 1f);
+            }
+        }else if(dest.temperature > 0.7f && liquid.temperature < 0.55f){ //cold liquid poured onto hot puddle
+            if(Mathf.chance(0.5f * amount)){
+                Effects.effect(Fx.steam, x, y);
+            }
+            return -0.1f * amount;
+        }else if(liquid.temperature > 0.7f && dest.temperature < 0.55f){ //hot liquid poured onto cold puddle
+            if(Mathf.chance(0.8f * amount)){
+                Effects.effect(Fx.steam, x, y);
+            }
+            return -0.4f * amount;
+        }
+        return 0f;
+    }
+
+    @Remote(called = Loc.server)
+    public static void onPuddleRemoved(int puddleid){
+        puddleGroup.removeByID(puddleid);
+    }
+
+    public float getFlammability(){
+        return liquid.flammability * amount;
+    }
+
+    @Override
+    public TypeID getTypeID(){
+        return TypeIDs.puddle;
+    }
+
+    @Override
+    public byte version(){
+        return 0;
+    }
+
+    @Override
+    public void hitbox(Rectangle rectangle){
+        rectangle.setCenter(x, y).setSize(tilesize);
+    }
+
+    @Override
+    public void hitboxTile(Rectangle rectangle){
+        rectangle.setCenter(x, y).setSize(0f);
+    }
+
+    @Override
+    public void update(){
+
+        //no updating happens clientside
+        if(net.client()){
+            amount = Mathf.lerpDelta(amount, targetAmount, 0.15f);
+        }else{
+            //update code
+            float addSpeed = accepting > 0 ? 3f : 0f;
+
+            amount -= Time.delta() * (1f - liquid.viscosity) / (5f + addSpeed);
+
+            amount += accepting;
+            accepting = 0f;
+
+            if(amount >= maxLiquid / 1.5f && generation < maxGeneration){
+                float deposited = Math.min((amount - maxLiquid / 1.5f) / 4f, 0.3f) * Time.delta();
+                for(Point2 point : Geometry.d4){
+                    Tile other = world.tile(tile.x + point.x, tile.y + point.y);
+                    if(other != null && other.block() == Blocks.air){
+                        deposit(other, tile, liquid, deposited, generation + 1);
+                        amount -= deposited / 2f; //tweak to speed up/slow down puddle propagation
+                    }
+                }
+            }
+
+            amount = Mathf.clamp(amount, 0, maxLiquid);
+
+            if(amount <= 0f){
+                Call.onPuddleRemoved(getID());
+            }
+        }
+
+        //effects-only code
+        if(amount >= maxLiquid / 2f && updateTime <= 0f){
+            Units.nearby(rect.setSize(Mathf.clamp(amount / (maxLiquid / 1.5f)) * 10f).setCenter(x, y), unit -> {
+                if(unit.isFlying()) return;
+
+                unit.hitbox(rect2);
+                if(!rect.overlaps(rect2)) return;
+
+                unit.applyEffect(liquid.effect, 60 * 2);
+
+                if(unit.velocity().len() > 0.1){
+                    Effects.effect(Fx.ripple, liquid.color, unit.x, unit.y);
+                }
+            });
+
+            if(liquid.temperature > 0.7f && (tile.link().entity != null) && Mathf.chance(0.3 * Time.delta())){
+                Fire.create(tile);
+            }
+
+            updateTime = 20f;
+        }
+
+        updateTime -= Time.delta();
+    }
+
+    @Override
+    public void draw(){
+        seeds = id;
+        boolean onLiquid = tile.floor().isLiquid;
+        float f = Mathf.clamp(amount / (maxLiquid / 1.5f));
+        float smag = onLiquid ? 0.8f : 0f;
+        float sscl = 20f;
+
+        Draw.color(tmp.set(liquid.color).shiftValue(-0.05f));
+        Fill.circle(x + Mathf.sin(Time.time() + seeds * 532, sscl, smag), y + Mathf.sin(Time.time() + seeds * 53, sscl, smag), f * 8f);
+        Angles.randLenVectors(id, 3, f * 6f, (ex, ey) -> {
+            Fill.circle(x + ex + Mathf.sin(Time.time() + seeds * 532, sscl, smag),
+            y + ey + Mathf.sin(Time.time() + seeds * 53, sscl, smag), f * 5f);
+            seeds++;
+        });
+        Draw.color();
+
+        if(liquid.lightColor.a > 0.001f && f > 0){
+            Color color = liquid.lightColor;
+            float opacity = color.a * f;
+            renderer.lights.add(tile.drawx(), tile.drawy(),  30f * f, color, opacity * 0.8f);
+        }
+    }
+
+    @Override
+    public float drawSize(){
+        return 20;
+    }
+
+    @Override
+    public void writeSave(DataOutput stream) throws IOException{
+        stream.writeInt(tile.pos());
+        stream.writeFloat(x);
+        stream.writeFloat(y);
+        stream.writeByte(liquid.id);
+        stream.writeFloat(amount);
+        stream.writeByte(generation);
+    }
+
+    @Override
+    public void readSave(DataInput stream, byte version) throws IOException{
+        this.loadedPosition = stream.readInt();
+        this.x = stream.readFloat();
+        this.y = stream.readFloat();
+        this.liquid = content.liquid(stream.readByte());
+        this.amount = stream.readFloat();
+        this.generation = stream.readByte();
+        add();
+    }
+
+    @Override
+    public void reset(){
+        loadedPosition = -1;
+        tile = null;
+        liquid = null;
+        amount = 0;
+        generation = 0;
+        accepting = 0;
+    }
+
+    @Override
+    public void added(){
+        if(loadedPosition != -1){
+            map.put(loadedPosition, this);
+            tile = world.tile(loadedPosition);
+        }
+    }
+
+    @Override
+    public void removed(){
+        if(tile != null){
+            map.remove(tile.pos());
+        }
+        reset();
+    }
+
+    @Override
+    public void write(DataOutput data) throws IOException{
+        data.writeFloat(x);
+        data.writeFloat(y);
+        data.writeByte(liquid.id);
+        data.writeShort((short)(amount * 4));
+        data.writeInt(tile.pos());
+    }
+
+    @Override
+    public void read(DataInput data) throws IOException{
+        x = data.readFloat();
+        y = data.readFloat();
+        liquid = content.liquid(data.readByte());
+        targetAmount = data.readShort() / 4f;
+        int pos = data.readInt();
+        tile = world.tile(pos);
+
+        map.put(pos, this);
+    }
+
+    @Override
+    public EntityGroup targetGroup(){
+        return puddleGroup;
+    }
+}

core/src/mindustry/entities/effect/RubbleDecal.java

@@ -0,0 +1,41 @@
+package mindustry.entities.effect;
+
+import arc.Core;
+import arc.graphics.g2d.Draw;
+import arc.graphics.g2d.TextureRegion;
+import arc.math.Mathf;
+
+import static mindustry.Vars.headless;
+
+public class RubbleDecal extends Decal{
+    private TextureRegion region;
+
+    /** Creates a rubble effect at a position. Provide a block size to use. */
+    public static void create(float x, float y, int size){
+        if(headless) return;
+
+        RubbleDecal decal = new RubbleDecal();
+        decal.region = Core.atlas.find("rubble-" + size + "-" + Mathf.randomSeed(decal.id, 0, 1));
+
+        if(!Core.atlas.isFound(decal.region)){
+            return;
+        }
+
+        decal.set(x, y);
+        decal.add();
+    }
+
+    @Override
+    public float lifetime(){
+        return 8200f;
+    }
+
+    @Override
+    public void drawDecal(){
+        if(!Core.atlas.isFound(region)){
+            remove();
+            return;
+        }
+        Draw.rect(region, x, y, Mathf.randomSeed(id, 0, 4) * 90);
+    }
+}

core/src/mindustry/entities/effect/ScorchDecal.java

@@ -0,0 +1,49 @@
+package mindustry.entities.effect;
+
+import arc.Core;
+import arc.graphics.g2d.Draw;
+import arc.graphics.g2d.TextureRegion;
+import arc.math.Angles;
+import arc.math.Mathf;
+import mindustry.world.Tile;
+
+import static mindustry.Vars.headless;
+import static mindustry.Vars.world;
+
+public class ScorchDecal extends Decal{
+    private static final int scorches = 5;
+    private static final TextureRegion[] regions = new TextureRegion[scorches];
+
+    public static void create(float x, float y){
+        if(headless) return;
+
+        if(regions[0] == null || regions[0].getTexture().isDisposed()){
+            for(int i = 0; i < regions.length; i++){
+                regions[i] = Core.atlas.find("scorch" + (i + 1));
+            }
+        }
+
+        Tile tile = world.tileWorld(x, y);
+
+        if(tile == null || tile.floor().liquidDrop != null) return;
+
+        ScorchDecal decal = new ScorchDecal();
+        decal.set(x, y);
+        decal.add();
+    }
+
+    @Override
+    public void drawDecal(){
+        for(int i = 0; i < 3; i++){
+            TextureRegion region = regions[Mathf.randomSeed(id - i, 0, scorches - 1)];
+            float rotation = Mathf.randomSeed(id + i, 0, 360);
+            float space = 1.5f + Mathf.randomSeed(id + i + 1, 0, 20) / 10f;
+            Draw.rect(region,
+            x + Angles.trnsx(rotation, space),
+            y + Angles.trnsy(rotation, space) + region.getHeight() / 2f * Draw.scl,
+            region.getWidth() * Draw.scl,
+            region.getHeight() * Draw.scl,
+            region.getWidth() / 2f * Draw.scl, 0, rotation - 90);
+        }
+    }
+}