diff --git a/core/src/io/anuke/mindustry/entities/Unit.java b/core/src/io/anuke/mindustry/entities/Unit.java index 53619b7fdd..016925e73f 100644 --- a/core/src/io/anuke/mindustry/entities/Unit.java +++ b/core/src/io/anuke/mindustry/entities/Unit.java @@ -228,7 +228,9 @@ public abstract class Unit extends DestructibleEntity implements SaveTrait, Targ x += velocity.x / getMass() * Timers.delta(); y += velocity.y / getMass() * Timers.delta(); - elevation = Mathf.lerpDelta(elevation, tile.elevation, 0.04f); + if(tile != null){ + elevation = Mathf.lerpDelta(elevation, tile.elevation, 0.04f); + } }else{ boolean onLiquid = floor.isLiquid; diff --git a/core/src/io/anuke/mindustry/input/InputHandler.java b/core/src/io/anuke/mindustry/input/InputHandler.java index 68e048cf3e..689a637db1 100644 --- a/core/src/io/anuke/mindustry/input/InputHandler.java +++ b/core/src/io/anuke/mindustry/input/InputHandler.java @@ -101,8 +101,7 @@ public abstract class InputHandler extends InputAdapter{ boolean tileTapped(Tile tile){ tile = tile.target(); - boolean consumed = false; - boolean showedInventory = false; + boolean consumed = false, showedInventory = false, showedConsume = false; //check if tapped block is configurable if(tile.block().configurable && tile.getTeam() == player.getTeam()){ @@ -129,16 +128,28 @@ public abstract class InputHandler extends InputAdapter{ //consume tap event if necessary if(tile.getTeam() == player.getTeam() && tile.block().consumesTap){ consumed = true; - }else if(tile.getTeam() == player.getTeam() && tile.block().synthetic() && tile.block().hasItems && tile.entity.items.total() > 0 && !consumed){ - frag.inv.showFor(tile); - consumed = true; - showedInventory = true; + }else if(tile.getTeam() == player.getTeam() && tile.block().synthetic() && !consumed) { + if(tile.block().hasItems && tile.entity.items.total() > 0) { + frag.inv.showFor(tile); + consumed = true; + showedInventory = true; + } + + if(tile.block().consumes.hasAny()){ + frag.consume.show(tile); + consumed = true; + showedConsume = true; + } } if(!showedInventory){ frag.inv.hide(); } + if(!showedConsume){ + frag.consume.hide(); + } + return consumed; } @@ -166,7 +177,8 @@ public abstract class InputHandler extends InputAdapter{ } boolean canMine(Tile tile){ - return tile.floor().drops != null && tile.floor().drops.item.hardness <= player.mech.drillPower + return !ui.hasMouse() + && tile.floor().drops != null && tile.floor().drops.item.hardness <= player.mech.drillPower && !tile.floor().playerUnmineable && player.inventory.canAcceptItem(tile.floor().drops.item) && Units.getClosestEnemy(player.getTeam(), tile.worldx(), tile.worldy(), 40f, e -> true) == null //don't being mining when an enemy is near diff --git a/core/src/io/anuke/mindustry/ui/fragments/BlockConsumeFragment.java b/core/src/io/anuke/mindustry/ui/fragments/BlockConsumeFragment.java new file mode 100644 index 0000000000..93f260d0a2 --- /dev/null +++ b/core/src/io/anuke/mindustry/ui/fragments/BlockConsumeFragment.java @@ -0,0 +1,91 @@ +package io.anuke.mindustry.ui.fragments; + +import com.badlogic.gdx.Gdx; +import com.badlogic.gdx.math.Vector2; +import com.badlogic.gdx.utils.Align; +import com.badlogic.gdx.utils.ObjectSet; +import io.anuke.mindustry.core.GameState.State; +import io.anuke.mindustry.entities.TileEntity; +import io.anuke.mindustry.world.Block; +import io.anuke.mindustry.world.Tile; +import io.anuke.mindustry.world.consumers.Consume; +import io.anuke.ucore.core.Graphics; +import io.anuke.ucore.scene.Group; +import io.anuke.ucore.scene.ui.layout.Table; + +import static io.anuke.mindustry.Vars.state; +import static io.anuke.mindustry.Vars.tilesize; + +public class BlockConsumeFragment extends Fragment { + private Table table; + private boolean visible; + + @Override + public void build(Group parent) { + table = new Table(); + table.setVisible(() -> !state.is(State.menu) && visible); + table.setTransform(true); + parent.setTransform(true); + parent.addChild(table); + } + + public void show(Tile tile){ + ObjectSet consumers = new ObjectSet<>(); + TileEntity entity = tile.entity; + Block block = tile.block(); + + //table.background("clear"); + rebuild(block, entity); + visible = true; + + table.update(() -> { + + if(tile.entity == null){ + hide(); + return; + } + + boolean rebuild = false; + + for(Consume c : block.consumes.array()){ + boolean valid = c.isOptional() || c.valid(block, entity); + + if(consumers.contains(c) == valid){ + if(valid){ + consumers.remove(c); + }else{ + consumers.add(c); + } + rebuild = true; + } + } + + if(rebuild){ + rebuild(block, entity); + } + + Vector2 v = Graphics.screen(tile.drawx() - tile.block().size * tilesize/2f, tile.drawy() + tile.block().size * tilesize/2f); + table.pack(); + table.setPosition(v.x, v.y, Align.topRight); + }); + + table.act(Gdx.graphics.getDeltaTime()); + } + + public void hide(){ + table.clear(); + table.update(() -> {}); + visible = false; + } + + private void rebuild(Block block, TileEntity entity){ + table.clearChildren(); + + for(Consume c : block.consumes.array()){ + if(!c.isOptional() && !c.valid(block, entity)){ + c.build(table); + table.row(); + } + } + } +} diff --git a/core/src/io/anuke/mindustry/ui/fragments/OverlayFragment.java b/core/src/io/anuke/mindustry/ui/fragments/OverlayFragment.java index 08cfff42c6..060467f109 100644 --- a/core/src/io/anuke/mindustry/ui/fragments/OverlayFragment.java +++ b/core/src/io/anuke/mindustry/ui/fragments/OverlayFragment.java @@ -7,6 +7,7 @@ import io.anuke.ucore.scene.Group; public class OverlayFragment extends Fragment{ public final BlockInventoryFragment inv; public final BlockConfigFragment config; + public final BlockConsumeFragment consume; private Group group = new Group(); private InputHandler input; @@ -16,6 +17,7 @@ public class OverlayFragment extends Fragment{ inv = new BlockInventoryFragment(input); config = new BlockConfigFragment(input); + consume = new BlockConsumeFragment(); } @Override @@ -25,6 +27,7 @@ public class OverlayFragment extends Fragment{ inv.build(group); config.build(group); + consume.build(group); input.buildUI(group); } diff --git a/core/src/io/anuke/mindustry/world/consumers/Consume.java b/core/src/io/anuke/mindustry/world/consumers/Consume.java index 6e3cbabb0e..352f0c8cfb 100644 --- a/core/src/io/anuke/mindustry/world/consumers/Consume.java +++ b/core/src/io/anuke/mindustry/world/consumers/Consume.java @@ -1,8 +1,12 @@ package io.anuke.mindustry.world.consumers; +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.utils.reflect.ClassReflection; import io.anuke.mindustry.entities.TileEntity; import io.anuke.mindustry.world.Block; import io.anuke.mindustry.world.meta.BlockStats; +import io.anuke.ucore.scene.ui.Tooltip; +import io.anuke.ucore.scene.ui.layout.Table; public abstract class Consume { private boolean optional; @@ -26,8 +30,22 @@ public abstract class Consume { return update; } - public void draw(TileEntity entity){ + public void build(Table table){ + Table t = new Table("clear"); + t.margin(4); + buildTooltip(t); + table.table("clear", out -> { + out.addImage(getIcon()).size(10*4).color(Color.RED); + }).size(10*4).get().addListener(new Tooltip<>(t)); + } + + public void buildTooltip(Table table){ + table.add("no " + ClassReflection.getSimpleName(getClass()).replace("Consume", "")); + } + + public String getIcon(){ + return "icon-power"; } public abstract void update(Block block, TileEntity entity); diff --git a/core/src/io/anuke/mindustry/world/consumers/Consumers.java b/core/src/io/anuke/mindustry/world/consumers/Consumers.java index 6873f3f7be..8bb729054f 100644 --- a/core/src/io/anuke/mindustry/world/consumers/Consumers.java +++ b/core/src/io/anuke/mindustry/world/consumers/Consumers.java @@ -8,10 +8,12 @@ import io.anuke.mindustry.type.ItemStack; import io.anuke.mindustry.type.Liquid; import io.anuke.mindustry.world.Block; import io.anuke.ucore.function.Consumer; +import io.anuke.ucore.util.ThreadArray; public class Consumers { private ObjectMap, Consume> map = new ObjectMap<>(); private ObjectSet> required = new ObjectSet<>(); + private ThreadArray results = new ThreadArray<>(); public void require(Class type){ required.add(type); @@ -23,6 +25,10 @@ public class Consumers { throw new RuntimeException("Missing required consumer of type \"" + ClassReflection.getSimpleName(c) + "\" in block \"" + block.name + "\"!"); } } + + for(Consume cons : map.values()){ + results.add(cons); + } } public ConsumePower power(float amount){ @@ -93,6 +99,10 @@ public class Consumers { return map.values(); } + public ThreadArray array() { + return results; + } + public boolean hasAny(){ return map.size > 0; }