Removed shadow/world padding

2018-11-12 13:17:43 -05:00
parent 832aac0e6e 92b68bdb8f
commit 9d142c5607
83 changed files with 1375 additions and 1454 deletions
@@ -70,7 +70,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
    public TargetTrait moveTarget;

    private float walktime;
-    private Queue<BuildRequest> placeQueue = new ThreadQueue<>();
+    private Queue<BuildRequest> placeQueue = new Queue<>();
    private Tile mining;
    private CarriableTrait carrying;
    private Trail trail = new Trail(12);
@@ -323,7 +323,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
        }

        if(floor.isLiquid){
-            Draw.tint(Color.WHITE, floor.liquidColor, Mathf.clamp(drownTime));
+            Draw.tint(Color.WHITE, floor.liquidColor, drownTime);
        }else{
            Draw.tint(Color.WHITE);
        }
@@ -421,55 +421,53 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra

    /**Draw all current build requests. Does not draw the beam effect, only the positions.*/
    public void drawBuildRequests(){
-        synchronized(getPlaceQueue()){
-            for(BuildRequest request : getPlaceQueue()){
-                if(getCurrentRequest() == request) continue;
+        for(BuildRequest request : getPlaceQueue()){
+            if(getCurrentRequest() == request) continue;

-                if(request.breaking){
-                    Block block = world.tile(request.x, request.y).target().block();
+            if(request.breaking){
+                Block block = world.tile(request.x, request.y).target().block();

-                    //draw removal request
-                    Lines.stroke(2f);
+                //draw removal request
+                Lines.stroke(2f);

-                    Draw.color(Palette.removeBack);
+                Draw.color(Palette.removeBack);

-                    float rad = Mathf.absin(Timers.time(), 7f, 1f) + block.size * tilesize / 2f - 1;
+                float rad = Mathf.absin(Timers.time(), 7f, 1f) + block.size * tilesize / 2f - 1;

-                    Lines.square(
-                            request.x * tilesize + block.offset(),
-                            request.y * tilesize + block.offset() - 1,
-                            rad);
+                Lines.square(
+                        request.x * tilesize + block.offset(),
+                        request.y * tilesize + block.offset() - 1,
+                        rad);

-                    Draw.color(Palette.remove);
+                Draw.color(Palette.remove);

-                    Lines.square(
-                            request.x * tilesize + block.offset(),
-                            request.y * tilesize + block.offset(),
-                            rad);
-                }else{
-                    //draw place request
-                    Lines.stroke(2f);
+                Lines.square(
+                        request.x * tilesize + block.offset(),
+                        request.y * tilesize + block.offset(),
+                        rad);
+            }else{
+                //draw place request
+                Lines.stroke(2f);

-                    Draw.color(Palette.accentBack);
+                Draw.color(Palette.accentBack);

-                    float rad = Mathf.absin(Timers.time(), 7f, 1f) - 2f + request.recipe.result.size * tilesize / 2f;
+                float rad = Mathf.absin(Timers.time(), 7f, 1f) - 2f + request.recipe.result.size * tilesize / 2f;

-                    Lines.square(
-                            request.x * tilesize + request.recipe.result.offset(),
-                            request.y * tilesize + request.recipe.result.offset() - 1,
-                            rad);
+                Lines.square(
+                        request.x * tilesize + request.recipe.result.offset(),
+                        request.y * tilesize + request.recipe.result.offset() - 1,
+                        rad);

-                    Draw.color(Palette.accent);
+                Draw.color(Palette.accent);

-                    Lines.square(
-                            request.x * tilesize + request.recipe.result.offset(),
-                            request.y * tilesize + request.recipe.result.offset(),
-                            rad);
-                }
+                Lines.square(
+                        request.x * tilesize + request.recipe.result.offset(),
+                        request.y * tilesize + request.recipe.result.offset(),
+                        rad);
            }
-
-            Draw.reset();
        }
+
+        Draw.reset();
    }

    //endregion
@@ -512,14 +510,14 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
            achievedFlight = true;
        }

-        if(boostHeat <= liftoffBoost + 0.05f && achievedFlight){
+        if(boostHeat <= liftoffBoost + 0.05f && achievedFlight && !mech.flying){
            if(tile != null){
                if(mech.shake > 1f){
                    Effects.shake(mech.shake, mech.shake, this);
                }
                Effects.effect(UnitFx.unitLand, tile.floor().minimapColor, x, y, tile.floor().isLiquid ? 1f : 0.5f);
            }
-            if(!mech.flying) mech.onLand(this);
+            mech.onLand(this);
            achievedFlight = false;
        }

@@ -259,27 +259,25 @@ public class TileEntity extends BaseEntity implements TargetTrait, HealthTrait{

    @Override
    public void update(){
-        synchronized(Tile.tileSetLock){
-            //TODO better smoke effect, this one is awful
-            if(health != 0 && health < tile.block().health && !(tile.block() instanceof Wall) &&
-                    Mathf.chance(0.009f * Timers.delta() * (1f - health / tile.block().health))){
+        //TODO better smoke effect, this one is awful
+        if(health != 0 && health < tile.block().health && !(tile.block() instanceof Wall) &&
+                Mathf.chance(0.009f * Timers.delta() * (1f - health / tile.block().health))){

-                Effects.effect(Fx.smoke, x + Mathf.range(4), y + Mathf.range(4));
-            }
+            Effects.effect(Fx.smoke, x + Mathf.range(4), y + Mathf.range(4));
+        }

-            timeScaleDuration -= Timers.delta();
-            if(timeScaleDuration <= 0f || !tile.block().canOverdrive){
-                timeScale = 1f;
-            }
+        timeScaleDuration -= Timers.delta();
+        if(timeScaleDuration <= 0f || !tile.block().canOverdrive){
+            timeScale = 1f;
+        }

-            if(health <= 0){
-                onDeath();
-            }
-            Block previous = tile.block();
-            tile.block().update(tile);
-            if(tile.block() == previous && cons != null){
-                cons.update(this);
-            }
+        if(health <= 0){
+            onDeath();
+        }
+        Block previous = tile.block();
+        tile.block().update(tile);
+        if(tile.block() == previous && cons != null){
+            cons.update(this);
        }
    }

@@ -278,7 +278,7 @@ public abstract class Unit extends DestructibleEntity implements SaveTrait, Targ

            drownTime = Mathf.clamp(drownTime);

-            if(drownTime >= 0.999f){
+            if(drownTime >= 0.999f && !Net.client()){
                damage(health + 1);
            }

@@ -88,14 +88,13 @@ public interface BuilderTrait extends Entity{
    }

    default void readBuilding(DataInput input, boolean applyChanges) throws IOException{
-        synchronized(getPlaceQueue()){
-            if(applyChanges) getPlaceQueue().clear();
+        if(applyChanges) getPlaceQueue().clear();

-            byte type = input.readByte();
-            if(type != -1){
-                int position = input.readInt();
-                float progress = input.readFloat();
-                BuildRequest request;
+        byte type = input.readByte();
+        if(type != -1){
+            int position = input.readInt();
+            float progress = input.readFloat();
+            BuildRequest request;

                if(type == 1){ //remove
                    request = new BuildRequest(Pos.x(position), Pos.y(position));
@@ -105,13 +104,12 @@ public interface BuilderTrait extends Entity{
                    request = new BuildRequest(Pos.x(position), Pos.y(position), rotation, content.recipe(recipe));
                }

-                request.progress = progress;
+            request.progress = progress;

-                if(applyChanges){
-                    getPlaceQueue().addLast(request);
-                }else if(isBuilding()){
-                    getCurrentRequest().progress = progress;
-                }
+            if(applyChanges){
+                getPlaceQueue().addLast(request);
+            }else if(isBuilding()){
+                getCurrentRequest().progress = progress;
            }
        }
    }
@@ -126,13 +124,11 @@ public interface BuilderTrait extends Entity{
     * Otherwise, a new place request is added to the queue.
     */
    default void replaceBuilding(int x, int y, int rotation, Recipe recipe){
-        synchronized(getPlaceQueue()){
-            for(BuildRequest request : getPlaceQueue()){
-                if(request.x == x && request.y == y){
-                    clearBuilding();
-                    addBuildRequest(request);
-                    return;
-                }
+        for(BuildRequest request : getPlaceQueue()){
+            if(request.x == x && request.y == y){
+                clearBuilding();
+                addBuildRequest(request);
+                return;
            }
        }

@@ -146,18 +142,16 @@ public interface BuilderTrait extends Entity{

    /**Add another build requests to the tail of the queue, if it doesn't exist there yet.*/
    default void addBuildRequest(BuildRequest place){
-        synchronized(getPlaceQueue()){
-            for(BuildRequest request : getPlaceQueue()){
-                if(request.x == place.x && request.y == place.y){
-                    return;
-                }
+        for(BuildRequest request : getPlaceQueue()){
+            if(request.x == place.x && request.y == place.y){
+                return;
            }
-            Tile tile = world.tile(place.x, place.y);
-            if(tile != null && tile.entity instanceof BuildEntity){
-                place.progress = tile.<BuildEntity>entity().progress;
-            }
-            getPlaceQueue().addLast(place);
        }
+        Tile tile = world.tile(place.x, place.y);
+        if(tile != null && tile.entity instanceof BuildEntity){
+            place.progress = tile.<BuildEntity>entity().progress;
+        }
+        getPlaceQueue().addLast(place);
    }

    /**
@@ -165,9 +159,7 @@ public interface BuilderTrait extends Entity{
     * May return null.
     */
    default BuildRequest getCurrentRequest(){
-        synchronized(getPlaceQueue()){
-            return getPlaceQueue().size == 0 ? null : getPlaceQueue().first();
-        }
+        return getPlaceQueue().size == 0 ? null : getPlaceQueue().first();
    }

    /**
@@ -279,18 +271,15 @@ public interface BuilderTrait extends Entity{
    /**Draw placement effects for an entity. This includes mining*/
    default void drawBuilding(Unit unit){
        BuildRequest request;
-
-        synchronized(getPlaceQueue()){
-            if(!isBuilding()){
-                if(getMineTile() != null){
-                    drawMining(unit);
-                }
-                return;
+        if(!isBuilding()){
+            if(getMineTile() != null){
+                drawMining(unit);
            }
-
-            request = getCurrentRequest();
+            return;
        }

+        request = getCurrentRequest();
+
        Tile tile = world.tile(request.x, request.y);

        if(unit.distanceTo(tile) > placeDistance){
@@ -28,10 +28,7 @@ import io.anuke.ucore.core.Effects;
 import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.entities.EntityGroup;
 import io.anuke.ucore.graphics.Draw;
-import io.anuke.ucore.util.Angles;
-import io.anuke.ucore.util.Geometry;
-import io.anuke.ucore.util.Mathf;
-import io.anuke.ucore.util.Timer;
+import io.anuke.ucore.util.*;

 import java.io.DataInput;
 import java.io.DataOutput;
@@ -316,8 +313,8 @@ public abstract class BaseUnit extends Unit implements ShooterTrait{
        if(target != null) behavior();

        if(!isWave && !isFlying()){
-            x = Mathf.clamp(x, 0, world.width() * tilesize);
-            y = Mathf.clamp(y, 0, world.height() * tilesize);
+            x = Mathf.clamp(x, tilesize/2f, world.width() * tilesize - tilesize/2f);
+            y = Mathf.clamp(y, tilesize/2f, world.height() * tilesize - tilesize/2f);
        }
    }

@@ -1,15 +1,21 @@
 package io.anuke.mindustry.entities.units.types;

 import com.badlogic.gdx.math.Vector2;
+import io.anuke.annotations.Annotations.Loc;
+import io.anuke.annotations.Annotations.Remote;
 import io.anuke.mindustry.Vars;
+import io.anuke.mindustry.content.fx.UnitFx;
+import io.anuke.mindustry.entities.Player;
 import io.anuke.mindustry.entities.Predict;
-import io.anuke.mindustry.entities.Unit;
 import io.anuke.mindustry.entities.traits.TargetTrait;
+import io.anuke.mindustry.entities.units.BaseUnit;
 import io.anuke.mindustry.entities.units.FlyingUnit;
 import io.anuke.mindustry.entities.units.UnitCommand;
 import io.anuke.mindustry.entities.units.UnitState;
+import io.anuke.mindustry.gen.Call;
 import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.type.AmmoType;
+import io.anuke.ucore.core.Effects;
 import io.anuke.ucore.util.Mathf;

 import java.io.DataInput;
@@ -22,7 +28,8 @@ import static io.anuke.mindustry.Vars.players;
 public class AlphaDrone extends FlyingUnit {
    static final float followDistance = 80f;

-    public Unit leader;
+    public Player leader;
+
    public final UnitState attack = new UnitState() {
        @Override
        public void update() {
@@ -32,15 +39,18 @@ public class AlphaDrone extends FlyingUnit {
            }
            TargetTrait last = target;
            target = leader;
+
            if(last == null){
-                circle(50f);
+                circle(leader.isShooting ? 60f : 0f);
            }
+
            target = last;
            if(distanceTo(leader) < followDistance){
                targetClosest();
            }else{
                target = null;
            }
+
            if(target != null){
                attack(50f);

@@ -51,9 +61,20 @@ public class AlphaDrone extends FlyingUnit {
                    getWeapon().update(AlphaDrone.this, to.x, to.y);
                }
            }
+
+            if(!leader.isShooting && distanceTo(leader) < 8f){
+                Call.onAlphaDroneFade(AlphaDrone.this);
+            }
        }
    };

+    @Remote(called = Loc.server)
+    public static void onAlphaDroneFade(BaseUnit drone){
+        if(drone == null) return;
+        drone.remove();
+        Effects.effect(UnitFx.pickup, drone);
+    }
+
    @Override
    public void onCommand(UnitCommand command){
        //nuh
@@ -40,12 +40,11 @@ import static io.anuke.mindustry.Vars.unitGroups;
 import static io.anuke.mindustry.Vars.world;

 public class Drone extends FlyingUnit implements BuilderTrait{
-    protected static float discoverRange = 120f;
    protected static int timerRepairEffect = timerIndex++;

    protected Item targetItem;
    protected Tile mineTile;
-    protected Queue<BuildRequest> placeQueue = new ThreadQueue<>();
+    protected Queue<BuildRequest> placeQueue = new Queue<>();
    protected boolean isBreaking;

    public final UnitState
@@ -250,14 +249,12 @@ public class Drone extends FlyingUnit implements BuilderTrait{
            for(BaseUnit unit : group.all()){
                if(unit instanceof Drone){
                    Drone drone = (Drone)unit;
-                    synchronized(drone.getPlaceQueue()){
-                        if(drone.isBuilding()){
-                            //stop building if opposite building begins.
-                            BuildRequest req = drone.getCurrentRequest();
-                            if(req.breaking != event.breaking && req.x == event.tile.x && req.y == event.tile.y){
-                                drone.clearBuilding();
-                                drone.setState(drone.repair);
-                            }
+                    if(drone.isBuilding()){
+                        //stop building if opposite building begins.
+                        BuildRequest req = drone.getCurrentRequest();
+                        if(req.breaking != event.breaking && req.x == event.tile.x && req.y == event.tile.y){
+                            drone.clearBuilding();
+                            drone.setState(drone.repair);
                        }
                    }

@@ -319,6 +316,10 @@ public class Drone extends FlyingUnit implements BuilderTrait{
            TileEntity entity = (TileEntity) target;
            entity.health += type.healSpeed * Timers.delta();
            entity.health = Mathf.clamp(entity.health, 0, entity.tile.block().health);
+
+            if(timer.get(timerRepairEffect, 30)){
+                Effects.effect(BlockFx.healBlockFull, Palette.heal, entity.x, entity.y, entity.tile.block().size);
+            }
        }

        updateBuilding(this);