Added mining

core/src/io/anuke/mindustry/ai/BlockIndexer.java

@@ -21,6 +21,8 @@ public class BlockIndexer {
     private ObjectMap<BlockFlag, ObjectSet<Tile>> enemyMap = new ObjectMap<>();
     /**Maps teams to a map of flagged tiles by type.*/
     private ObjectMap<BlockFlag, ObjectSet<Tile>> allyMap = new ObjectMap<>();
+    /**Empty map for invalid teams.*/
+    private ObjectMap<BlockFlag, ObjectSet<Tile>> emptyMap = new ObjectMap<>();
     /**Maps tile positions to their last known tile index data.*/
     private IntMap<TileIndex> typeMap = new IntMap<>();
     /**Empty array used for returning.*/
@@ -79,6 +81,7 @@ public class BlockIndexer {
     }
 
     private ObjectMap<BlockFlag, ObjectSet<Tile>> getMap(Team team){
+        if(!state.teams.has(team)) return emptyMap;
         return state.teams.get(team).ally ? allyMap : enemyMap;
     }
 

core/src/io/anuke/mindustry/content/Mechs.java

@@ -14,7 +14,7 @@ public class Mechs implements ContentList {
         }};
 
         standardShip = new Mech("standard-ship", true){{
-
+            drillPower = 1;
         }};
     }
 }

core/src/io/anuke/mindustry/entities/BlockBuilder.java

@@ -1,17 +1,24 @@
 package io.anuke.mindustry.entities;
 
+import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.utils.Queue;
 import io.anuke.mindustry.Vars;
+import io.anuke.mindustry.content.blocks.Blocks;
+import io.anuke.mindustry.content.fx.BlockFx;
+import io.anuke.mindustry.entities.effect.ItemTransfer;
 import io.anuke.mindustry.graphics.Palette;
+import io.anuke.mindustry.type.Item;
 import io.anuke.mindustry.type.Recipe;
 import io.anuke.mindustry.world.Build;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.types.BuildBlock;
 import io.anuke.mindustry.world.blocks.types.BuildBlock.BuildEntity;
+import io.anuke.ucore.core.Effects;
 import io.anuke.ucore.core.Timers;
 import io.anuke.ucore.graphics.Draw;
 import io.anuke.ucore.graphics.Fill;
 import io.anuke.ucore.graphics.Lines;
+import io.anuke.ucore.graphics.Shapes;
 import io.anuke.ucore.util.Angles;
 import io.anuke.ucore.util.Geometry;
 import io.anuke.ucore.util.Mathf;
@@ -19,13 +26,15 @@ import io.anuke.ucore.util.Translator;
 
 import java.util.Arrays;
 
+import static io.anuke.mindustry.Vars.tilesize;
 import static io.anuke.mindustry.Vars.world;
 
 /**Interface for units that build, break or mine things.*/
 public interface BlockBuilder {
-    //temporary static final values
+    //these are not instance variables!
     Translator[] tmptr = {new Translator(), new Translator(), new Translator(), new Translator()};
     float placeDistance = 200f;
+    float mineDistance = 70f;
 
     /**Returns the queue for storing build requests.*/
     Queue<BuildRequest> getPlaceQueue();
@@ -87,6 +96,8 @@ public interface BlockBuilder {
                 updateMining(unit);
             }
             return;
+        }else{
+            setMineTile(null);
         }
 
         Tile tile = world.tile(current.x, current.y);
@@ -153,11 +164,39 @@ public interface BlockBuilder {
 
     /**Do not call directly.*/
     default void updateMining(Unit unit){
+        Tile tile = getMineTile();
 
+        if(tile.block() != Blocks.air || unit.distanceTo(tile.worldx(), tile.worldy()) > mineDistance || !unit.inventory.canAcceptItem(tile.floor().drops.item)){
+            setMineTile(null);
+        }else{
+            Item item = tile.floor().drops.item;
+            unit.rotation = Mathf.slerpDelta(unit.rotation, unit.angleTo(tile.worldx(), tile.worldy()), 0.4f);
+
+            if(unit.inventory.canAcceptItem(item) &&
+                    Mathf.chance(Timers.delta() * 0.05 / item.hardness)){
+                ItemTransfer.create(item,
+                        tile.worldx() + Mathf.range(tilesize/2f),
+                        tile.worldy() + Mathf.range(tilesize/2f),
+                        unit, () -> unit.inventory.addItem(item, 1));
+            }
+
+            if(Mathf.chance(0.06 * Timers.delta())){
+                Effects.effect(BlockFx.pulverizeSmall,
+                        tile.worldx() + Mathf.range(tilesize/2f),
+                        tile.worldy() + Mathf.range(tilesize/2f), 0f, item.color);
+            }
+        }
     }
 
     /**Draw placement effects for an entity.*/
     default void drawBuilding(Unit unit){
+        if(!isBuilding()){
+            if(getMineTile() != null){
+                drawMining(unit);
+            }
+            return;
+        }
+
         Tile tile = world.tile(getCurrentRequest().x, getCurrentRequest().y);
 
         Draw.color(unit.distanceTo(tile) > placeDistance || getCurrentRequest().remove ? Palette.remove : Palette.accent);
@@ -196,6 +235,28 @@ public interface BlockBuilder {
         Draw.color();
     }
 
+    /**Internal use only.*/
+    default void drawMining(Unit unit){
+        Tile tile = getMineTile();
+
+        float focusLen = 4f + Mathf.absin(Timers.time(), 1.1f, 0.5f);
+        float swingScl = 12f, swingMag = tilesize/8f;
+        float flashScl = 0.3f;
+
+        float px = unit.x + Angles.trnsx(unit.rotation, focusLen);
+        float py = unit.y + Angles.trnsy(unit.rotation, focusLen);
+
+        float ex = tile.worldx() + Mathf.sin(Timers.time() + 48, swingScl, swingMag);
+        float ey = tile.worldy() + Mathf.sin(Timers.time() + 48, swingScl + 2f, swingMag);
+
+        Draw.color(Color.LIGHT_GRAY, Color.WHITE, 1f-flashScl + Mathf.absin(Timers.time(), 0.5f, flashScl));
+        Shapes.laser("minelaser", "minelaser-end", px, py, ex, ey);
+
+        Draw.color(Palette.accent);
+        Lines.poly(tile.worldx(), tile.worldy(), 4, tilesize/2f * Mathf.sqrt2, Timers.time());
+        Draw.color();
+    }
+
     /**Class for storing build requests. Can be either a place or remove request.*/
     class BuildRequest {
         public final int x, y, rotation;

core/src/io/anuke/mindustry/entities/Player.java

@@ -263,7 +263,7 @@ public class Player extends Unit implements BlockBuilder {
 
 	@Override
 	public void drawOver(){
-	    if(!isShooting() && getCurrentRequest() != null && !dead) {
+	    if(!isShooting() && !dead) {
 	        drawBuilding(this);
         }
 

core/src/io/anuke/mindustry/input/AndroidInput.java

@@ -30,6 +30,7 @@ import io.anuke.ucore.graphics.Lines;
 import io.anuke.ucore.scene.Group;
 import io.anuke.ucore.scene.builders.imagebutton;
 import io.anuke.ucore.scene.builders.table;
+import io.anuke.ucore.util.Log;
 import io.anuke.ucore.util.Mathf;
 
 import static io.anuke.mindustry.Vars.*;
@@ -386,7 +387,9 @@ public class AndroidInput extends InputHandler implements GestureListener{
 
         //call tap events
         if(pointer == 0 && !selecting && mode == none){
-            tileTapped(cursor.target());
+            if(!tileTapped(cursor.target())){
+                tryBeginMine(cursor);
+            }
         }
 
 		return false;

core/src/io/anuke/mindustry/input/DesktopInput.java

@@ -161,7 +161,8 @@ public class DesktopInput extends InputHandler{
             }
 
             if(cursor.floor().drops != null && cursor.floor().drops.item.hardness <= player.mech.drillPower
-                    && cursor.block() == Blocks.air){
+                    && cursor.block() == Blocks.air && player.distanceTo(cursor.worldx(), cursor.worldy()) <= Player.mineDistance &&
+                    player.inventory.canAcceptItem(cursor.floor().drops.item)){
                 cursorType = drill;
             }
 

core/src/io/anuke/mindustry/input/InputHandler.java

@@ -123,8 +123,9 @@ public abstract class InputHandler extends InputAdapter{
 	/**Tries to begin mining a tile, returns true if successful.*/
 	boolean tryBeginMine(Tile tile){
 		if(tile.floor().drops != null && tile.floor().drops.item.hardness <= player.mech.drillPower
-				&& tile.block() == Blocks.air){
+				&& tile.block() == Blocks.air && player.distanceTo(tile.worldx(), tile.worldy()) <= Player.mineDistance){
-			player.setMineTile(tile);
+			//if a block is clicked twice, reset it
+			player.setMineTile(player.getMineTile() == tile ? null : tile);
 			return true;
 		}
 		return false;

core/src/io/anuke/mindustry/net/Packets.java

@@ -169,14 +169,19 @@ public class Packets {
 		public void write(ByteBuffer buffer) {
 			buffer.putShort((short)x);
 			buffer.putShort((short)y);
-			buffer.putInt(editlogs.size);
+
-			for(EditLog value : editlogs) {
+			if(editlogs != null) {
-				buffer.put((byte)value.playername.getBytes().length);
+                buffer.putInt(editlogs.size);
-				buffer.put(value.playername.getBytes());
+                for (EditLog value : editlogs) {
-				buffer.putInt(value.block.id);
+                    buffer.put((byte) value.playername.getBytes().length);
-				buffer.put((byte) value.rotation);
+                    buffer.put(value.playername.getBytes());
-				buffer.put((byte) value.action.ordinal());
+                    buffer.putInt(value.block.id);
-			}
+                    buffer.put((byte) value.rotation);
+                    buffer.put((byte) value.action.ordinal());
+                }
+            }else{
+			    buffer.putInt(0);
+            }
 		}
 
 		@Override