ctrl-shift-f

build.gradle

@@ -169,7 +169,9 @@ project(":core"){
         if(!comp) println("Note: Compiling release build.")
 
         if(new File(projectDir.parent, '../Arc').exists() && comp){
+            println(project(":Arc:extensions").subprojects)
             compile project(":Arc:core")
+            compile project(":Arc:extensions:freetype")
         }else{
             //TODO compile arc from jitpack
             //compile 'com.github.Anuken.Arc:arc:-SNAPSHOT'

core/src/io/anuke/mindustry/Mindustry.java

@@ -3,10 +3,8 @@ package io.anuke.mindustry;
 import io.anuke.arc.ApplicationListener;
 import io.anuke.arc.Core;
 import io.anuke.arc.Events;
-import io.anuke.arc.Settings;
+import io.anuke.arc.util.Log;
-import io.anuke.arc.utils.Log;
+import io.anuke.arc.util.Time;
-import io.anuke.arc.utils.Time;
-import io.anuke.arc.utils.TimeUtils;
 import io.anuke.mindustry.core.*;
 import io.anuke.mindustry.game.EventType.GameLoadEvent;
 import io.anuke.mindustry.io.BundleLoader;
@@ -47,7 +45,7 @@ public class Mindustry implements ApplicationListener{
 
     @Override
     public void update(){
-        lastFrameTime = TimeUtils.millis();
+        lastFrameTime = Time.millis();
 
         //TODO ??render it all??
 
@@ -55,7 +53,7 @@ public class Mindustry implements ApplicationListener{
 
         if(fpsCap <= 120){
             long target = 1000/fpsCap;
-            long elapsed = TimeUtils.timeSinceMillis(lastFrameTime);
+            long elapsed = Time.timeSinceMillis(lastFrameTime);
             if(elapsed < target){
                 try{
                     Thread.sleep(target - elapsed);

core/src/io/anuke/mindustry/Vars.java

@@ -17,7 +17,7 @@ import io.anuke.mindustry.game.Version;
 import io.anuke.mindustry.gen.Serialization;
 import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.world.blocks.defense.ForceProjector.ShieldEntity;
-import io.anuke.arc.core.Settings;
+import io.anuke.arc.Settings;
 import io.anuke.arc.entities.Entities;
 import io.anuke.arc.entities.EntityGroup;
 import io.anuke.arc.entities.impl.EffectEntity;

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

@@ -1,7 +1,12 @@
 package io.anuke.mindustry.ai;
 
-import io.anuke.arc.math.Vector2;
+import io.anuke.arc.Events;
-import io.anuke.arc.utils.*;
+import io.anuke.arc.collection.*;
+import io.anuke.arc.function.Predicate;
+import io.anuke.arc.math.Mathf;
+import io.anuke.arc.math.geom.Geometry;
+import io.anuke.arc.math.geom.Vector2;
+import io.anuke.arc.util.Bits;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.entities.TileEntity;
 import io.anuke.mindustry.game.EventType.TileChangeEvent;
@@ -11,12 +16,6 @@ import io.anuke.mindustry.game.Teams.TeamData;
 import io.anuke.mindustry.type.Item;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.meta.BlockFlag;
-import io.anuke.arc.core.Events;
-import io.anuke.arc.function.Predicate;
-import io.anuke.arc.util.EnumSet;
-import io.anuke.arc.util.Geometry;
-import io.anuke.arc.util.Mathf;
-import io.anuke.arc.util.ThreadArray;
 
 import static io.anuke.mindustry.Vars.*;
 
@@ -47,7 +46,7 @@ public class BlockIndexer{
     /**Empty set used for returning.*/
     private ObjectSet<Tile> emptySet = new ObjectSet<>();
     /**Array used for returning and reusing.*/
-    private Array<Tile> returnArray = new ThreadArray<>();
+    private Array<Tile> returnArray = new Array<>();
 
     public BlockIndexer(){
         Events.on(TileChangeEvent.class, event -> {

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

@@ -1,9 +1,9 @@
 package io.anuke.mindustry.ai;
 
 import io.anuke.arc.math.GridPoint2;
-import io.anuke.arc.utils.IntArray;
+import io.anuke.arc.util.IntArray;
-import io.anuke.arc.utils.Queue;
+import io.anuke.arc.util.Queue;
-import io.anuke.arc.utils.TimeUtils;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.game.EventType.TileChangeEvent;
 import io.anuke.mindustry.game.EventType.WorldLoadEvent;
 import io.anuke.mindustry.game.Team;
@@ -11,8 +11,8 @@ import io.anuke.mindustry.game.Teams.TeamData;
 import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.meta.BlockFlag;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Events;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.util.Geometry;
 import io.anuke.arc.util.Structs;
 
@@ -20,7 +20,7 @@ import static io.anuke.mindustry.Vars.state;
 import static io.anuke.mindustry.Vars.world;
 
 public class Pathfinder{
-    private long maxUpdate = TimeUtils.millisToNanos(4);
+    private long maxUpdate = Time.millisToNanos(4);
     private PathData[] paths;
     private IntArray blocked = new IntArray();
 
@@ -105,7 +105,7 @@ public class Pathfinder{
             //increment search, clear frontier
             path.search++;
             path.frontier.clear();
-            path.lastSearchTime = TimeUtils.millis();
+            path.lastSearchTime = Time.millis();
 
             //add all targets to the frontier
             for(Tile other : world.indexer.getEnemy(team, BlockFlag.target)){
@@ -144,9 +144,9 @@ public class Pathfinder{
     private void updateFrontier(Team team, long nsToRun){
         PathData path = paths[team.ordinal()];
 
-        long start = TimeUtils.nanoTime();
+        long start = Time.nanoTime();
 
-        while(path.frontier.size > 0 && (nsToRun < 0 || TimeUtils.timeSinceNanos(start) <= nsToRun)){
+        while(path.frontier.size > 0 && (nsToRun < 0 || Time.timeSinceNanos(start) <= nsToRun)){
             Tile tile = path.frontier.removeLast();
             float cost = path.weights[tile.x][tile.y];
 

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

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.ai;
 
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.entities.units.BaseUnit;
 import io.anuke.mindustry.entities.units.Squad;
@@ -9,9 +9,9 @@ import io.anuke.mindustry.game.SpawnGroup;
 import io.anuke.mindustry.game.Team;
 import io.anuke.mindustry.game.Waves;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Events;
 import io.anuke.arc.util.GridBits;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Structs;
 
 import java.io.DataInput;

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

@@ -17,12 +17,12 @@ import io.anuke.mindustry.maps.TutorialSector;
 import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.type.ContentType;
 import io.anuke.mindustry.type.Mech;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Core;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Graphics;
+import io.anuke.arc.Graphics;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.graphics.Draw;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.unitGroups;
 
@@ -137,7 +137,7 @@ public class Mechs implements ContentList{
 
                     rect.setSize(healRange*2f).setCenter(player.x, player.y);
                     Units.getNearby(player.getTeam(), rect, unit -> {
-                        if(unit.distanceTo(player) <= healRange){
+                        if(unit.dst(player) <= healRange){
                             if(unit.health < unit.maxHealth()){
                                 Effects.effect(UnitFx.heal, unit);
                                 wasHealed = true;
@@ -184,7 +184,7 @@ public class Mechs implements ContentList{
             @Override
             public void load(){
                 super.load();
-                armorRegion = Draw.region(name + "-armor");
+                armorRegion = Core.atlas.find(name + "-armor");
             }
 
             @Override
@@ -246,7 +246,7 @@ public class Mechs implements ContentList{
             @Override
             public void load(){
                 super.load();
-                shield = Draw.region(name + "-shield");
+                shield = Core.atlas.find(name + "-shield");
             }
 
             @Override

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

@@ -6,9 +6,9 @@ import io.anuke.mindustry.entities.Unit;
 import io.anuke.mindustry.game.ContentList;
 import io.anuke.mindustry.type.ContentType;
 import io.anuke.mindustry.type.StatusEffect;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class StatusEffects implements ContentList{
     public static StatusEffect none, burning, freezing, wet, melting, tarred, overdrive, shielded, shocked;

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

@@ -1,7 +1,7 @@
 package io.anuke.mindustry.content;
 
 import io.anuke.arc.graphics.Color;
-import io.anuke.arc.utils.ObjectSet;
+import io.anuke.arc.collection.ObjectSet;
 import io.anuke.mindustry.entities.units.UnitType;
 import io.anuke.mindustry.entities.units.types.*;
 import io.anuke.mindustry.game.ContentList;

core/src/io/anuke/mindustry/content/blocks/Blocks.java

@@ -10,10 +10,10 @@ import io.anuke.mindustry.type.ItemStack;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.*;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Lines;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class Blocks extends BlockList implements ContentList{
     public static Block air, blockpart, spawn, space, metalfloor, deepwater, water, lava, tar, stone,

core/src/io/anuke/mindustry/content/blocks/DebugBlocks.java

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.content.blocks;
 
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
 import io.anuke.annotations.Annotations.Loc;
 import io.anuke.annotations.Annotations.Remote;
 import io.anuke.mindustry.content.Liquids;

core/src/io/anuke/mindustry/content/blocks/OreBlocks.java

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.content.blocks;
 
-import io.anuke.arc.utils.ObjectMap;
+import io.anuke.arc.collection.ObjectMap;
 import io.anuke.mindustry.type.Item;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.blocks.Floor;

core/src/io/anuke/mindustry/content/blocks/TurretBlocks.java

@@ -10,7 +10,7 @@ import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.blocks.defense.turrets.*;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class TurretBlocks extends BlockList implements ContentList{
     public static Block duo, /*scatter,*/
@@ -46,7 +46,7 @@ public class TurretBlocks extends BlockList implements ContentList{
             @Override
             public void load(){
                 super.load();
-                shootRegion = Draw.region(name + "-shoot");
+                shootRegion = Core.atlas.find(name + "-shoot");
             }
 
             {
@@ -137,8 +137,8 @@ public class TurretBlocks extends BlockList implements ContentList{
             @Override
             public void load() {
                 super.load();
-                panels[0] = Draw.region(name + "-panel-left");
+                panels[0] = Core.atlas.find(name + "-panel-left");
-                panels[1] = Draw.region(name + "-panel-right");
+                panels[1] = Core.atlas.find(name + "-panel-right");
             }
 
             {

core/src/io/anuke/mindustry/content/bullets/FlakBullets.java

@@ -7,7 +7,7 @@ import io.anuke.mindustry.entities.bullet.FlakBulletType;
 import io.anuke.mindustry.entities.effect.Lightning;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.game.ContentList;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class FlakBullets extends BulletList implements ContentList{
     public static BulletType plastic, explosive, surge;

core/src/io/anuke/mindustry/content/bullets/MissileBullets.java

@@ -8,8 +8,8 @@ import io.anuke.mindustry.entities.bullet.MissileBulletType;
 import io.anuke.mindustry.entities.effect.Lightning;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.game.ContentList;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class MissileBullets extends BulletList implements ContentList{
     public static BulletType explosive, incindiary, surge, javelin, swarm;

core/src/io/anuke/mindustry/content/bullets/TurretBullets.java

@@ -18,11 +18,11 @@ import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.BuildBlock;
 import io.anuke.mindustry.world.blocks.distribution.MassDriver.DriverBulletData;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.graphics.*;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.content;
 import static io.anuke.mindustry.Vars.world;
@@ -367,9 +367,9 @@ public class TurretBullets extends BulletList implements ContentList{
                     return;
                 }
 
-                float baseDst = data.from.distanceTo(data.to);
+                float baseDst = data.from.dst(data.to);
-                float dst1 = b.distanceTo(data.from);
+                float dst1 = b.dst(data.from);
-                float dst2 = b.distanceTo(data.to);
+                float dst2 = b.dst(data.to);
 
                 boolean intersect = false;
 

core/src/io/anuke/mindustry/content/bullets/WeaponBullets.java

@@ -12,7 +12,7 @@ import io.anuke.mindustry.entities.effect.Fire;
 import io.anuke.mindustry.entities.effect.Puddle;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.world;
 

core/src/io/anuke/mindustry/content/fx/BlockFx.java

@@ -4,13 +4,13 @@ import io.anuke.arc.graphics.Color;
 import io.anuke.mindustry.entities.effect.GroundEffectEntity.GroundEffect;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.game.ContentList;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Hue;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Tmp;
 
 import static io.anuke.mindustry.Vars.tilesize;

core/src/io/anuke/mindustry/content/fx/BulletFx.java

@@ -3,12 +3,12 @@ package io.anuke.mindustry.content.fx;
 import io.anuke.arc.graphics.Color;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.game.ContentList;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class BulletFx extends FxList implements ContentList{
     public static Effect hitBulletSmall, hitFuse, hitBulletBig, hitFlameSmall, hitLiquid, hitLaser, hitLancer, hitMeltdown, despawn, flakExplosion, blastExplosion, plasticExplosion,

core/src/io/anuke/mindustry/content/fx/EnvironmentFx.java

@@ -1,15 +1,14 @@
 package io.anuke.mindustry.content.fx;
 
+import io.anuke.arc.entities.Effects.Effect;
 import io.anuke.arc.graphics.Color;
+import io.anuke.arc.graphics.g2d.Draw;
+import io.anuke.arc.graphics.g2d.Fill;
+import io.anuke.arc.math.Mathf;
 import io.anuke.mindustry.content.Liquids;
 import io.anuke.mindustry.game.ContentList;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.type.Item;
-import io.anuke.arc.core.Effects.Effect;
-import io.anuke.arc.graphics.Draw;
-import io.anuke.arc.graphics.Fill;
-import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
 
 public class EnvironmentFx extends FxList implements ContentList{
     public static Effect burning, fire, smoke, steam, fireballsmoke, ballfire, freezing, melting, wet, oily, overdriven, dropItem;

core/src/io/anuke/mindustry/content/fx/ExplosionFx.java

@@ -3,12 +3,12 @@ package io.anuke.mindustry.content.fx;
 import io.anuke.arc.graphics.Color;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.game.ContentList;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class ExplosionFx extends FxList implements ContentList{
     public static Effect shockwave, bigShockwave, nuclearShockwave, explosion, blockExplosion, blockExplosionSmoke;

core/src/io/anuke/mindustry/content/fx/Fx.java

@@ -3,7 +3,7 @@ package io.anuke.mindustry.content.fx;
 import io.anuke.arc.graphics.Color;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.game.ContentList;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Lines;

core/src/io/anuke/mindustry/content/fx/ShootFx.java

@@ -4,13 +4,13 @@ import io.anuke.arc.graphics.Color;
 import io.anuke.mindustry.entities.effect.GroundEffectEntity.GroundEffect;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.game.ContentList;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.graphics.Shapes;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class ShootFx extends FxList implements ContentList{
     public static Effect shootSmall, shootHeal, shootSmallSmoke, shootBig, shootBig2, shootBigSmoke, shootBigSmoke2, shootSmallFlame, shootLiquid, shellEjectSmall, shellEjectMedium, shellEjectBig, lancerLaserShoot, lancerLaserShootSmoke, lancerLaserCharge, lancerLaserChargeBegin, lightningCharge, lightningShoot;

core/src/io/anuke/mindustry/content/fx/UnitFx.java

@@ -3,12 +3,12 @@ package io.anuke.mindustry.content.fx;
 import io.anuke.mindustry.entities.effect.GroundEffectEntity.GroundEffect;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.game.ContentList;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class UnitFx extends FxList implements ContentList{
     public static Effect vtolHover, unitDrop, unitPickup, unitLand, pickup, healWave, heal, landShock;

core/src/io/anuke/mindustry/core/ContentLoader.java

@@ -4,7 +4,7 @@ import io.anuke.arc.collection.Array;
 import io.anuke.arc.collection.ObjectMap;
 import io.anuke.arc.collection.ObjectSet;
 import io.anuke.arc.function.Consumer;
-import io.anuke.arc.utils.Log;
+import io.anuke.arc.util.Log;
 import io.anuke.mindustry.content.*;
 import io.anuke.mindustry.content.blocks.*;
 import io.anuke.mindustry.content.bullets.*;

core/src/io/anuke/mindustry/core/Control.java

@@ -3,15 +3,14 @@ package io.anuke.mindustry.core;
 import io.anuke.arc.ApplicationListener;
 import io.anuke.arc.Core;
 import io.anuke.arc.Events;
-import io.anuke.arc.Settings;
 import io.anuke.arc.entities.Effects;
 import io.anuke.arc.entities.EntityQuery;
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.graphics.g2d.TextureAtlas;
 import io.anuke.arc.input.KeyCode;
-import io.anuke.arc.utils.Interval;
+import io.anuke.arc.util.Interval;
-import io.anuke.arc.utils.Strings;
+import io.anuke.arc.util.Strings;
-import io.anuke.arc.utils.Time;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.content.Mechs;
 import io.anuke.mindustry.core.GameState.State;
 import io.anuke.mindustry.entities.Player;
@@ -95,7 +94,7 @@ public class Control implements ApplicationListener{
             state.set(State.playing);
         });
 
-        Events.on(WorldLoadGraphicsEvent.class, event -> {
+        Events.on(WorldLoadEvent.class, event -> {
             if(mobile){
                 Core.app.post(() -> Core.camera.position.set(players[0]));
             }
@@ -146,8 +145,6 @@ public class Control implements ApplicationListener{
                 }
             }
         });
-
-        Events.on(WorldLoadEvent.class, event -> threads.runGraphics(() -> Events.fire(new WorldLoadGraphicsEvent())));
     }
 
     public void addPlayer(int index){

core/src/io/anuke/mindustry/core/GameState.java

@@ -5,7 +5,7 @@ import io.anuke.mindustry.game.EventType.StateChangeEvent;
 import io.anuke.mindustry.game.GameMode;
 import io.anuke.mindustry.game.Teams;
 import io.anuke.mindustry.net.Net;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Events;
 
 import static io.anuke.mindustry.Vars.unitGroups;
 import static io.anuke.mindustry.Vars.waveTeam;

core/src/io/anuke/mindustry/core/Logic.java

@@ -1,8 +1,14 @@
 package io.anuke.mindustry.core;
 
-import io.anuke.arc.utils.Array;
 import io.anuke.annotations.Annotations.Loc;
 import io.anuke.annotations.Annotations.Remote;
+import io.anuke.arc.ApplicationListener;
+import io.anuke.arc.Events;
+import io.anuke.arc.entities.Entities;
+import io.anuke.arc.entities.EntityGroup;
+import io.anuke.arc.entities.EntityQuery;
+import io.anuke.arc.collection.Array;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.Vars;
 import io.anuke.mindustry.core.GameState.State;
 import io.anuke.mindustry.entities.TileEntity;
@@ -16,12 +22,6 @@ import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.type.ItemStack;
 import io.anuke.mindustry.type.Recipe;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Events;
-import io.anuke.arc.core.Timers;
-import io.anuke.arc.entities.Entities;
-import io.anuke.arc.entities.EntityGroup;
-import io.anuke.arc.entities.EntityQuery;
-import io.anuke.arc.modules.Module;
 
 import static io.anuke.mindustry.Vars.*;
 
@@ -33,7 +33,7 @@ import static io.anuke.mindustry.Vars.*;
  * <p>
  * This class should <i>not</i> call any outside methods to change state of modules, but instead fire events.
  */
-public class Logic extends Module{
+public class Logic implements ApplicationListener{
 
     public Logic(){
         Events.on(TileChangeEvent.class, event -> {
@@ -141,7 +141,7 @@ public class Logic extends Module{
 
     @Remote(called = Loc.both)
     public static void onGameOver(Team winner){
-        threads.runGraphics(() -> ui.restart.show(winner));
+        ui.restart.show(winner);
         netClient.setQuiet();
     }
 

core/src/io/anuke/mindustry/core/NetClient.java

@@ -1,14 +1,21 @@
 package io.anuke.mindustry.core;
 
-import io.anuke.arc.Core;
-import io.anuke.arc.graphics.Color;
-import io.anuke.arc.utils.Base64Coder;
-import io.anuke.arc.utils.IntSet;
-import io.anuke.arc.utils.TimeUtils;
 import io.anuke.annotations.Annotations.Loc;
 import io.anuke.annotations.Annotations.PacketPriority;
 import io.anuke.annotations.Annotations.Remote;
 import io.anuke.annotations.Annotations.Variant;
+import io.anuke.arc.ApplicationListener;
+import io.anuke.arc.Core;
+import io.anuke.arc.collection.IntSet;
+import io.anuke.arc.entities.Entities;
+import io.anuke.arc.entities.EntityGroup;
+import io.anuke.arc.graphics.Color;
+import io.anuke.arc.util.Interval;
+import io.anuke.arc.util.io.ReusableByteArrayInputStream;
+import io.anuke.arc.math.Mathf;
+import io.anuke.arc.util.Log;
+import io.anuke.arc.util.Time;
+import io.anuke.arc.util.serialization.Base64Coder;
 import io.anuke.mindustry.Vars;
 import io.anuke.mindustry.core.GameState.State;
 import io.anuke.mindustry.entities.Player;
@@ -25,16 +32,6 @@ import io.anuke.mindustry.net.Packets.*;
 import io.anuke.mindustry.net.ValidateException;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.modules.ItemModule;
-import io.anuke.arc.core.Core;
-import io.anuke.arc.core.Settings;
-import io.anuke.arc.core.Timers;
-import io.anuke.arc.entities.Entities;
-import io.anuke.arc.entities.EntityGroup;
-import io.anuke.arc.io.ReusableByteArrayInputStream;
-import io.anuke.arc.modules.Module;
-import io.anuke.arc.util.Log;
-import io.anuke.arc.util.Mathf;
-import io.anuke.arc.util.Timer;
 
 import java.io.DataInputStream;
 import java.io.IOException;
@@ -43,12 +40,12 @@ import java.util.zip.InflaterInputStream;
 
 import static io.anuke.mindustry.Vars.*;
 
-public class NetClient extends Module{
+public class NetClient implements ApplicationListener{
     private final static float dataTimeout = 60 * 18;
     private final static float playerSyncTime = 2;
     public final static float viewScale = 2f;
 
-    private Timer timer = new Timer(5);
+    private Interval timer = new Interval(5);
     /**Whether the client is currently connecting.*/
     private boolean connecting = false;
     /**If true, no message will be shown on disconnect.*/
@@ -422,13 +419,13 @@ public class NetClient extends Module{
                 requests[i] = player.getPlaceQueue().get(i);
             }
 
-            Call.onClientShapshot(lastSent++, TimeUtils.millis(), player.x, player.y,
+            Call.onClientShapshot(lastSent++, Time.millis(), player.x, player.y,
                 player.pointerX, player.pointerY, player.rotation, player.baseRotation,
                 player.getVelocity().x, player.getVelocity().y,
                 player.getMineTile(),
                 player.isBoosting, player.isShooting, requests,
                 Core.camera.position.x, Core.camera.position.y,
-                Core.camera.viewportWidth * Core.camera.zoom * viewScale, Core.camera.viewportHeight * Core.camera.zoom * viewScale);
+                Core.camera.width * viewScale, Core.camera.height * viewScale);
         }
 
         if(timer.get(1, 60)){
@@ -443,7 +440,7 @@ public class NetClient extends Module{
             byte[] bytes = new byte[8];
             new Random().nextBytes(bytes);
             String result = new String(Base64Coder.encode(bytes));
-            Core.settings.putString("usid-" + ip, result);
+            Core.settings.put("usid-" + ip, result);
             Core.settings.save();
             return result;
         }

core/src/io/anuke/mindustry/core/NetServer.java

@@ -1,15 +1,26 @@
 package io.anuke.mindustry.core;
 
-import io.anuke.arc.graphics.Color;
-import io.anuke.arc.graphics.Colors;
-import io.anuke.arc.math.Rectangle;
-import io.anuke.arc.math.Vector2;
-import io.anuke.arc.utils.Array;
-import io.anuke.arc.utils.IntMap;
-import io.anuke.arc.utils.ObjectSet;
-import io.anuke.arc.utils.TimeUtils;
 import io.anuke.annotations.Annotations.Loc;
 import io.anuke.annotations.Annotations.Remote;
+import io.anuke.arc.ApplicationListener;
+import io.anuke.arc.Events;
+import io.anuke.arc.collection.Array;
+import io.anuke.arc.collection.IntMap;
+import io.anuke.arc.collection.ObjectSet;
+import io.anuke.arc.entities.Entities;
+import io.anuke.arc.entities.EntityGroup;
+import io.anuke.arc.entities.EntityQuery;
+import io.anuke.arc.entities.trait.Entity;
+import io.anuke.arc.graphics.Color;
+import io.anuke.arc.graphics.Colors;
+import io.anuke.arc.math.Mathf;
+import io.anuke.arc.math.geom.Rectangle;
+import io.anuke.arc.math.geom.Vector2;
+import io.anuke.arc.util.Log;
+import io.anuke.arc.util.Structs;
+import io.anuke.arc.util.Time;
+import io.anuke.arc.util.io.ByteBufferOutput;
+import io.anuke.arc.util.io.CountableByteArrayOutputStream;
 import io.anuke.mindustry.content.Mechs;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.core.GameState.State;
@@ -21,22 +32,13 @@ import io.anuke.mindustry.game.Team;
 import io.anuke.mindustry.game.Version;
 import io.anuke.mindustry.gen.Call;
 import io.anuke.mindustry.gen.RemoteReadServer;
-import io.anuke.mindustry.net.*;
+import io.anuke.mindustry.net.Administration;
 import io.anuke.mindustry.net.Administration.PlayerInfo;
+import io.anuke.mindustry.net.Net;
+import io.anuke.mindustry.net.NetConnection;
+import io.anuke.mindustry.net.NetworkIO;
 import io.anuke.mindustry.net.Packets.*;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Events;
-import io.anuke.arc.core.Timers;
-import io.anuke.arc.entities.Entities;
-import io.anuke.arc.entities.EntityGroup;
-import io.anuke.arc.entities.EntityQuery;
-import io.anuke.arc.entities.trait.Entity;
-import io.anuke.arc.io.ByteBufferOutput;
-import io.anuke.arc.io.CountableByteArrayOutputStream;
-import io.anuke.arc.modules.Module;
-import io.anuke.arc.util.Structs;
-import io.anuke.arc.util.Log;
-import io.anuke.arc.util.Mathf;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -48,7 +50,7 @@ import java.util.zip.DeflaterOutputStream;
 
 import static io.anuke.mindustry.Vars.*;
 
-public class NetServer extends Module{
+public class NetServer implements ApplicationListener{
     public final static int maxSnapshotSize = 2047;
 
     public final static boolean debugSnapshots = false;
@@ -122,7 +124,7 @@ public class NetServer extends Module{
                 return;
             }
 
-            if(TimeUtils.millis() - info.lastKicked < kickDuration){
+            if(Time.millis() - info.lastKicked < kickDuration){
                 kick(id, KickReason.recentKick);
                 return;
             }
@@ -311,14 +313,14 @@ public class NetServer extends Module{
 
         boolean verifyPosition = !player.isDead() && netServer.admins.getStrict() && headless && player.getCarrier() == null;
 
-        if(connection.lastRecievedClientTime == 0) connection.lastRecievedClientTime = TimeUtils.millis() - 16;
+        if(connection.lastRecievedClientTime == 0) connection.lastRecievedClientTime = Time.millis() - 16;
 
         connection.viewX = viewX;
         connection.viewY = viewY;
         connection.viewWidth = viewWidth;
         connection.viewHeight = viewHeight;
 
-        long elapsed = TimeUtils.timeSinceMillis(connection.lastRecievedClientTime);
+        long elapsed = Time.timeSinceMillis(connection.lastRecievedClientTime);
 
         float maxSpeed = boosting && !player.mech.flying ? player.mech.boostSpeed : player.mech.speed;
         float maxMove = elapsed / 1000f * 60f * Math.min(compound(maxSpeed, player.mech.drag) * 1.25f, player.mech.maxSpeed * 1.1f);
@@ -370,7 +372,7 @@ public class NetServer extends Module{
         player.getVelocity().set(xVelocity, yVelocity); //only for visual calculation purposes, doesn't actually update the player
 
         connection.lastRecievedClientSnapshot = snapshotID;
-        connection.lastRecievedClientTime = TimeUtils.millis();
+        connection.lastRecievedClientTime = Time.millis();
     }
 
     @Remote(targets = Loc.client, called = Loc.server)
@@ -436,7 +438,7 @@ public class NetServer extends Module{
 
         if(!headless && !closing && Net.server() && state.is(State.menu)){
             closing = true;
-            threads.runGraphics(() -> ui.loadfrag.show("$text.server.closing"));
+            ui.loadfrag.show("$text.server.closing");
             Time.runTask(5f, () -> {
                 Net.closeServer();
                 ui.loadfrag.hide();
@@ -469,7 +471,7 @@ public class NetServer extends Module{
         if(player != null && (reason == KickReason.kick || reason == KickReason.banned) && player.uuid != null){
             PlayerInfo info = admins.getInfo(player.uuid);
             info.timesKicked++;
-            info.lastKicked = TimeUtils.millis();
+            info.lastKicked = Time.millis();
         }
 
         Call.onKick(connection, reason);
@@ -498,7 +500,7 @@ public class NetServer extends Module{
         }
 
         //write timestamp
-        dataStream.writeLong(TimeUtils.millis());
+        dataStream.writeLong(Time.millis());
 
         int totalGroups = 0;
 

core/src/io/anuke/mindustry/core/Platform.java

@@ -1,15 +1,13 @@
 package io.anuke.mindustry.core;
 
 import io.anuke.arc.Core;
-import io.anuke.arc.Input.Keys;
 import io.anuke.arc.files.FileHandle;
-import io.anuke.arc.utils.Base64Coder;
-import io.anuke.arc.core.Core;
-import io.anuke.arc.core.Settings;
-import io.anuke.arc.core.Timers;
 import io.anuke.arc.function.Consumer;
+import io.anuke.arc.input.KeyCode;
 import io.anuke.arc.scene.ui.Dialog;
 import io.anuke.arc.scene.ui.TextField;
+import io.anuke.arc.util.Time;
+import io.anuke.arc.util.serialization.Base64Coder;
 
 import java.util.Random;
 
@@ -44,7 +42,7 @@ public abstract class Platform {
 
             TextField to = dialog.content().addField(field.getText(), t-> {}).pad(15).width(250f).get();
             to.setMaxLength(maxLength);
-            to.keyDown(Keys.ENTER, () -> dialog.content().find("okb").fireClick());
+            to.keyDown(KeyCode.ENTER, () -> dialog.content().find("okb").fireClick());
 
             use[0] = to;
 
@@ -81,7 +79,7 @@ public abstract class Platform {
             byte[] result = new byte[8];
             new Random().nextBytes(result);
             uuid = new String(Base64Coder.encode(result));
-            Core.settings.putString("uuid", uuid);
+            Core.settings.put("uuid", uuid);
             Core.settings.save();
             return uuid;
         }

core/src/io/anuke/mindustry/core/Renderer.java

@@ -8,9 +8,9 @@ import io.anuke.arc.graphics.PixmapIO;
 import io.anuke.arc.graphics.g2d.SpriteBatch;
 import io.anuke.arc.math.Rectangle;
 import io.anuke.arc.math.Vector2;
-import io.anuke.arc.utils.BufferUtils;
+import io.anuke.arc.util.BufferUtils;
-import io.anuke.arc.utils.ScreenUtils;
+import io.anuke.arc.util.ScreenUtils;
-import io.anuke.arc.utils.TimeUtils;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.content.fx.Fx;
 import io.anuke.mindustry.core.GameState.State;
 import io.anuke.mindustry.entities.Player;
@@ -23,10 +23,8 @@ import io.anuke.mindustry.entities.units.BaseUnit;
 import io.anuke.mindustry.game.Team;
 import io.anuke.mindustry.graphics.*;
 import io.anuke.mindustry.world.blocks.defense.ForceProjector.ShieldEntity;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Graphics;
-import io.anuke.arc.core.Graphics;
-import io.anuke.arc.core.Settings;
 import io.anuke.arc.entities.EntityDraw;
 import io.anuke.arc.entities.EntityGroup;
 import io.anuke.arc.entities.impl.EffectEntity;
@@ -40,7 +38,7 @@ import io.anuke.arc.graphics.Surface;
 import io.anuke.arc.modules.RendererModule;
 import io.anuke.arc.scene.utils.Cursors;
 import io.anuke.arc.util.Bundles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Pooling;
 import io.anuke.arc.util.Translator;
 
@@ -415,7 +413,7 @@ public class Renderer extends RendererModule{
         Pixmap fullPixmap = new Pixmap(w, h, Pixmap.Format.RGBA8888);
 
         BufferUtils.copy(lines, 0, fullPixmap.getPixels(), lines.length);
-        FileHandle file = screenshotDirectory.child("screenshot-" + TimeUtils.millis() + ".png");
+        FileHandle file = screenshotDirectory.child("screenshot-" + Time.millis() + ".png");
         PixmapIO.writePNG(file, fullPixmap);
         fullPixmap.dispose();
 

core/src/io/anuke/mindustry/core/UI.java

@@ -1,24 +1,16 @@
 package io.anuke.mindustry.core;
 
+import io.anuke.arc.ApplicationListener;
 import io.anuke.arc.Core;
-import io.anuke.arc.Input.Keys;
+import io.anuke.arc.Events;
+import io.anuke.arc.Graphics;
+import io.anuke.arc.function.Consumer;
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.graphics.Colors;
 import io.anuke.arc.graphics.g2d.BitmapFont;
-import io.anuke.arc.graphics.g2d.freetype.FreeTypeFontGenerator;
+import io.anuke.arc.graphics.g2d.Draw;
-import io.anuke.arc.graphics.g2d.freetype.FreeTypeFontGenerator.FreeTypeFontParameter;
+import io.anuke.arc.input.KeyCode;
 import io.anuke.arc.math.Interpolation;
-import io.anuke.arc.utils.Align;
-import io.anuke.mindustry.editor.MapEditorDialog;
-import io.anuke.mindustry.game.EventType.ResizeEvent;
-import io.anuke.mindustry.graphics.Palette;
-import io.anuke.mindustry.input.InputHandler;
-import io.anuke.mindustry.ui.dialogs.*;
-import io.anuke.mindustry.ui.fragments.*;
-import io.anuke.arc.core.*;
-import io.anuke.arc.function.Consumer;
-import io.anuke.arc.graphics.Draw;
-import io.anuke.arc.modules.SceneModule;
 import io.anuke.arc.scene.Group;
 import io.anuke.arc.scene.Skin;
 import io.anuke.arc.scene.actions.Actions;
@@ -28,12 +20,21 @@ import io.anuke.arc.scene.ui.TextField.TextFieldFilter;
 import io.anuke.arc.scene.ui.TooltipManager;
 import io.anuke.arc.scene.ui.layout.Table;
 import io.anuke.arc.scene.ui.layout.Unit;
+import io.anuke.arc.util.Align;
 import io.anuke.arc.util.Strings;
+import io.anuke.arc.util.Time;
+import io.anuke.arc.freetype.*;
+import io.anuke.mindustry.editor.MapEditorDialog;
+import io.anuke.mindustry.game.EventType.ResizeEvent;
+import io.anuke.mindustry.graphics.Palette;
+import io.anuke.mindustry.input.InputHandler;
+import io.anuke.mindustry.ui.dialogs.*;
+import io.anuke.mindustry.ui.fragments.*;
 
-import static io.anuke.mindustry.Vars.*;
 import static io.anuke.arc.scene.actions.Actions.*;
+import static io.anuke.mindustry.Vars.*;
 
-public class UI extends SceneModule{
+public class UI implements ApplicationListener{
     private FreeTypeFontGenerator generator;
 
     public final MenuFragment menufrag = new MenuFragment();
@@ -172,10 +173,10 @@ public class UI extends SceneModule{
         sectors = new SectorsDialog();
         missions = new MissionDialog();
 
-        Group group = Core.scene.getRoot();
+        Group group = Core.scene.root;
 
         backfrag.build(group);
-        control.input(0).getFrag().build(Core.scene.getRoot());
+        control.input(0).getFrag().build(group);
         hudfrag.build(group);
         menufrag.build(group);
         chatfrag.container().build(group);
@@ -215,9 +216,9 @@ public class UI extends SceneModule{
     public void loadLogic(String text, Runnable call){
         loadfrag.show(text);
         Time.runTask(7f, () ->
-            threads.run(() -> {
+            Core.app.post(() -> {
                 call.run();
-                threads.runGraphics(loadfrag::hide);
+                loadfrag.hide();
             }));
     }
 
@@ -292,8 +293,8 @@ public class UI extends SceneModule{
             dialog.hide();
             confirmed.run();
         });
-        dialog.keyDown(Keys.ESCAPE, dialog::hide);
+        dialog.keyDown(KeyCode.ESCAPE, dialog::hide);
-        dialog.keyDown(Keys.BACK, dialog::hide);
+        dialog.keyDown(KeyCode.BACK, dialog::hide);
         dialog.show();
     }
 

core/src/io/anuke/mindustry/core/World.java

@@ -1,8 +1,16 @@
 package io.anuke.mindustry.core;
 
-import io.anuke.arc.math.GridPoint2;
+import io.anuke.arc.ApplicationListener;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.Core;
-import io.anuke.arc.utils.ObjectMap;
+import io.anuke.arc.Events;
+import io.anuke.arc.collection.Array;
+import io.anuke.arc.collection.ObjectMap;
+import io.anuke.arc.entities.EntityQuery;
+import io.anuke.arc.math.Mathf;
+import io.anuke.arc.math.geom.GridPoint2;
+import io.anuke.arc.util.Log;
+import io.anuke.arc.util.Structs;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.ai.BlockIndexer;
 import io.anuke.mindustry.ai.Pathfinder;
 import io.anuke.mindustry.ai.WaveSpawner;
@@ -18,15 +26,10 @@ import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Pos;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.OreBlock;
-import io.anuke.arc.core.Events;
-import io.anuke.arc.core.Timers;
-import io.anuke.arc.entities.EntityQuery;
-import io.anuke.arc.modules.Module;
-import io.anuke.arc.util.*;
 
 import static io.anuke.mindustry.Vars.*;
 
-public class World extends Module{
+public class World implements ApplicationListener{
     public final Maps maps = new Maps();
     public final Sectors sectors = new Sectors();
     public final WorldGenerator generator = new WorldGenerator();
@@ -38,7 +41,7 @@ public class World extends Module{
     private Sector currentSector;
     private Tile[][] tiles;
 
-    private Array<Tile> tempTiles = new ThreadArray<>();
+    private Array<Tile> tempTiles = new Array<>();
     private boolean generating, invalidMap;
 
     public World(){
@@ -121,11 +124,11 @@ public class World extends Module{
     }
 
     public Tile tileWorld(float x, float y){
-        return tile(Mathf.scl2(x, tilesize), Mathf.scl2(y, tilesize));
+        return tile(Math.round(x / tilesize), Math.round(y / tilesize));
     }
 
     public int toTile(float coord){
-        return Mathf.scl2(coord, tilesize);
+        return Math.round(coord / tilesize);
     }
 
     public Tile[][] getTiles(){
@@ -335,8 +338,8 @@ public class World extends Module{
      * Raycast, but with world coordinates.
      */
     public GridPoint2 raycastWorld(float x, float y, float x2, float y2){
-        return raycast(Mathf.scl2(x, tilesize), Mathf.scl2(y, tilesize),
+        return raycast(Math.round(x / tilesize), Math.round(y / tilesize),
-                Mathf.scl2(x2, tilesize), Mathf.scl2(y2, tilesize));
+                Math.round(x2 / tilesize), Math.round(y2 / tilesize));
     }
 
     /**

core/src/io/anuke/mindustry/editor/DrawOperation.java

@@ -1,7 +1,7 @@
 package io.anuke.mindustry.editor;
 
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.IntSet;
+import io.anuke.arc.util.IntSet;
 import io.anuke.mindustry.maps.MapTileData;
 import io.anuke.mindustry.maps.MapTileData.TileDataMarker;
 import io.anuke.arc.util.Bits;

core/src/io/anuke/mindustry/editor/EditorTool.java

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.editor;
 
-import io.anuke.arc.utils.IntArray;
+import io.anuke.arc.util.IntArray;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.maps.MapTileData;
 import io.anuke.mindustry.maps.MapTileData.DataPosition;

core/src/io/anuke/mindustry/editor/MapEditor.java

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.editor;
 
-import io.anuke.arc.utils.ObjectMap;
+import io.anuke.arc.collection.ObjectMap;
 import io.anuke.mindustry.Vars;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.editor.DrawOperation.TileOperation;
@@ -12,7 +12,7 @@ import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.blocks.Floor;
 import io.anuke.arc.util.Structs;
 import io.anuke.arc.util.Bits;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import static io.anuke.mindustry.Vars.content;
 public class MapEditor{
     public static final int[] brushSizes = {1, 2, 3, 4, 5, 9, 15};

core/src/io/anuke/mindustry/editor/MapEditorDialog.java

@@ -7,9 +7,9 @@ import io.anuke.arc.graphics.Pixmap;
 import io.anuke.arc.graphics.g2d.Batch;
 import io.anuke.arc.graphics.g2d.TextureRegion;
 import io.anuke.arc.math.Vector2;
-import io.anuke.arc.utils.Align;
+import io.anuke.arc.util.Align;
-import io.anuke.arc.utils.Disposable;
+import io.anuke.arc.util.Disposable;
-import io.anuke.arc.utils.ObjectMap;
+import io.anuke.arc.collection.ObjectMap;
 import io.anuke.mindustry.Vars;
 import io.anuke.mindustry.content.blocks.StorageBlocks;
 import io.anuke.mindustry.core.Platform;
@@ -21,10 +21,9 @@ import io.anuke.mindustry.maps.MapTileData;
 import io.anuke.mindustry.type.Recipe;
 import io.anuke.mindustry.ui.dialogs.FloatingDialog;
 import io.anuke.mindustry.world.Block;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Graphics;
-import io.anuke.arc.core.Graphics;
+import io.anuke.arc.Inputs;
-import io.anuke.arc.core.Inputs;
+import io.anuke.arc.Timers;
-import io.anuke.arc.core.Timers;
 import io.anuke.arc.function.Consumer;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.input.Input;
@@ -36,7 +35,7 @@ import io.anuke.arc.scene.ui.layout.Unit;
 import io.anuke.arc.scene.utils.UIUtils;
 import io.anuke.arc.util.Bundles;
 import io.anuke.arc.util.Log;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Strings;
 
 import java.io.DataInputStream;
@@ -476,35 +475,35 @@ public class MapEditorDialog extends Dialog implements Disposable{
     private void doInput(){
         //tool select
         for(int i = 0; i < EditorTool.values().length; i++){
-            if(Inputs.keyTap(Input.valueOf("NUM_" + (i + 1)))){
+            if(Core.input.keyTap(Input.valueOf("NUM_" + (i + 1)))){
                 view.setTool(EditorTool.values()[i]);
                 break;
             }
         }
 
-        if(Inputs.keyTap(Input.R)){
+        if(Core.input.keyTap(Input.R)){
             editor.setDrawRotation((editor.getDrawRotation() + 1) % 4);
         }
 
-        if(Inputs.keyTap(Input.E)){
+        if(Core.input.keyTap(Input.E)){
             editor.setDrawRotation(Mathf.mod((editor.getDrawRotation() + 1), 4));
         }
 
         //ctrl keys (undo, redo, save)
         if(UIUtils.ctrl()){
-            if(Inputs.keyTap(Input.Z)){
+            if(Core.input.keyTap(Input.Z)){
                 view.undo();
             }
 
-            if(Inputs.keyTap(Input.Y)){
+            if(Core.input.keyTap(Input.Y)){
                 view.redo();
             }
 
-            if(Inputs.keyTap(Input.S)){
+            if(Core.input.keyTap(Input.S)){
                 save();
             }
 
-            if(Inputs.keyTap(Input.G)){
+            if(Core.input.keyTap(Input.G)){
                 view.setGrid(!view.isGrid());
             }
         }
@@ -539,7 +538,7 @@ public class MapEditorDialog extends Dialog implements Disposable{
                 continue;
             }
 
-            if(regions.length == 0 || regions[0] == Draw.region("jjfgj")) continue;
+            if(regions.length == 0 || regions[0] == Core.atlas.find("jjfgj")) continue;
 
             Stack stack = new Stack();
 

core/src/io/anuke/mindustry/editor/MapInfoDialog.java

@@ -1,9 +1,9 @@
 package io.anuke.mindustry.editor;
 
-import io.anuke.arc.utils.ObjectMap;
+import io.anuke.arc.collection.ObjectMap;
 import io.anuke.mindustry.core.Platform;
 import io.anuke.mindustry.ui.dialogs.FloatingDialog;
-import io.anuke.arc.core.Settings;
+import io.anuke.arc.Settings;
 import io.anuke.arc.scene.ui.TextArea;
 import io.anuke.arc.scene.ui.TextField;
 

core/src/io/anuke/mindustry/editor/MapLoadDialog.java

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.editor;
 
-import io.anuke.arc.utils.Scaling;
+import io.anuke.arc.util.Scaling;
 import io.anuke.mindustry.maps.Map;
 import io.anuke.mindustry.ui.BorderImage;
 import io.anuke.mindustry.ui.dialogs.FloatingDialog;

core/src/io/anuke/mindustry/editor/MapRenderer.java

@@ -3,14 +3,14 @@ package io.anuke.mindustry.editor;
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.graphics.g2d.TextureRegion;
 import io.anuke.arc.math.GridPoint2;
-import io.anuke.arc.utils.Disposable;
+import io.anuke.arc.util.Disposable;
-import io.anuke.arc.utils.IntSet;
+import io.anuke.arc.util.IntSet;
-import io.anuke.arc.utils.IntSet.IntSetIterator;
+import io.anuke.arc.util.IntSet.IntSetIterator;
 import io.anuke.mindustry.game.Team;
 import io.anuke.mindustry.maps.MapTileData.DataPosition;
 import io.anuke.mindustry.world.Block;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Core;
-import io.anuke.arc.core.Graphics;
+import io.anuke.arc.Graphics;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.IndexedRenderer;
 import io.anuke.arc.util.Structs;
@@ -142,14 +142,14 @@ public class MapRenderer implements Disposable{
 
         if(wall.update || wall.destructible){
             mesh.setColor(team.color);
-            region = Draw.region("block-border");
+            region = Core.atlas.find("block-border");
         }else if(elev > 0 && check){
             mesh.setColor(tmpColor.fromHsv((360f * elev / 127f * 4f) % 360f, 0.5f + (elev / 4f) % 0.5f, 1f));
-            region = Draw.region("block-elevation");
+            region = Core.atlas.find("block-elevation");
         }else if(elev == -1){
-            region = Draw.region("block-slope");
+            region = Core.atlas.find("block-slope");
         }else{
-            region = Draw.region("clear");
+            region = Core.atlas.find("clear");
         }
 
         mesh.draw((wx % chunksize) + (wy % chunksize) * chunksize + chunksize * chunksize, region,

core/src/io/anuke/mindustry/editor/MapResizeDialog.java

@@ -6,7 +6,7 @@ import io.anuke.arc.function.BiConsumer;
 import io.anuke.arc.scene.ui.ButtonGroup;
 import io.anuke.arc.scene.ui.TextButton;
 import io.anuke.arc.scene.ui.layout.Table;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class MapResizeDialog extends FloatingDialog{
     int[] validMapSizes = {200, 300, 400, 500};

core/src/io/anuke/mindustry/editor/MapView.java

@@ -9,13 +9,13 @@ import io.anuke.arc.math.Bresenham2;
 import io.anuke.arc.math.GridPoint2;
 import io.anuke.arc.math.Rectangle;
 import io.anuke.arc.math.Vector2;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
 import io.anuke.mindustry.editor.DrawOperation.TileOperation;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.ui.GridImage;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Core;
-import io.anuke.arc.core.Graphics;
+import io.anuke.arc.Graphics;
-import io.anuke.arc.core.Inputs;
+import io.anuke.arc.Inputs;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.scene.Element;
@@ -25,7 +25,7 @@ import io.anuke.arc.scene.event.Touchable;
 import io.anuke.arc.scene.ui.TextField;
 import io.anuke.arc.scene.ui.layout.Unit;
 import io.anuke.arc.util.Geometry;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Tmp;
 
 import static io.anuke.mindustry.Vars.mobile;
@@ -60,7 +60,7 @@ public class MapView extends Element implements GestureListener{
             brushPolygons[i] = Geometry.pixelCircle(size, (index, x, y) -> Vector2.dst(x, y, index, index) <= index - 0.5f);
         }
 
-        Inputs.addProcessor(0, new GestureDetector(20, 0.5f, 2, 0.15f, this));
+        Core.input.addProcessor(0, new GestureDetector(20, 0.5f, 2, 0.15f, this));
         setTouchable(Touchable.enabled);
 
         addListener(new InputListener(){
@@ -214,16 +214,16 @@ public class MapView extends Element implements GestureListener{
         super.act(delta);
 
         if(Core.scene.getKeyboardFocus() == null || !(Core.scene.getKeyboardFocus() instanceof TextField) &&
-                !Inputs.keyDown(io.anuke.arc.input.Input.CONTROL_LEFT)){
+                !Core.input.keyDown(io.anuke.arc.input.Input.CONTROL_LEFT)){
-            float ax = Inputs.getAxis("move_x");
+            float ax = Core.input.getAxis("move_x");
-            float ay = Inputs.getAxis("move_y");
+            float ay = Core.input.getAxis("move_y");
             offsetx -= ax * 15f / zoom;
             offsety -= ay * 15f / zoom;
         }
 
         if(ui.editor.hasPane()) return;
 
-        zoom += Inputs.scroll() / 10f * zoom;
+        zoom += Core.input.scroll() / 10f * zoom;
         clampZoom();
     }
 

core/src/io/anuke/mindustry/editor/OperationStack.java

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.editor;
 
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
 
 public class OperationStack{
     private final static int maxSize = 10;

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

@@ -13,12 +13,12 @@ import io.anuke.mindustry.game.Team;
 import io.anuke.mindustry.gen.Call;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.function.Consumer;
 import io.anuke.arc.function.Predicate;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Physics;
 import io.anuke.arc.util.Translator;
 
@@ -160,7 +160,7 @@ public class Damage{
     /**Damages all entities and blocks in a radius that are enemies of the team.*/
     public static void damage(Team team, float x, float y, float radius, float damage){
         Consumer<Unit> cons = entity -> {
-            if(entity.team == team || entity.distanceTo(x, y) > radius){
+            if(entity.team == team || entity.dst(x, y) > radius){
                 return;
             }
             float amount = calculateDamage(x, y, entity.x, entity.y, radius, damage);

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

@@ -1,13 +1,26 @@
 package io.anuke.mindustry.entities;
 
-import io.anuke.arc.graphics.Color;
-import io.anuke.arc.graphics.g2d.GlyphLayout;
-import io.anuke.arc.graphics.g2d.TextureRegion;
-import io.anuke.arc.math.Rectangle;
-import io.anuke.arc.math.Vector2;
-import io.anuke.arc.utils.Queue;
 import io.anuke.annotations.Annotations.Loc;
 import io.anuke.annotations.Annotations.Remote;
+import io.anuke.arc.Core;
+import io.anuke.arc.Graphics;
+import io.anuke.arc.collection.Queue;
+import io.anuke.arc.entities.Effects;
+import io.anuke.arc.entities.EntityGroup;
+import io.anuke.arc.entities.EntityQuery;
+import io.anuke.arc.graphics.Color;
+import io.anuke.arc.graphics.g2d.Draw;
+import io.anuke.arc.graphics.g2d.GlyphLayout;
+import io.anuke.arc.graphics.g2d.Lines;
+import io.anuke.arc.graphics.g2d.TextureRegion;
+import io.anuke.arc.math.Mathf;
+import io.anuke.arc.math.geom.Geometry;
+import io.anuke.arc.math.geom.Rectangle;
+import io.anuke.arc.math.geom.Vector2;
+import io.anuke.arc.util.Bits;
+import io.anuke.arc.util.Interval;
+import io.anuke.arc.util.Time;
+import io.anuke.arc.util.Timer;
 import io.anuke.mindustry.content.Mechs;
 import io.anuke.mindustry.content.fx.UnitFx;
 import io.anuke.mindustry.entities.effect.ScorchDecal;
@@ -16,6 +29,7 @@ import io.anuke.mindustry.game.Team;
 import io.anuke.mindustry.gen.Call;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.graphics.Trail;
+import io.anuke.mindustry.input.Binding;
 import io.anuke.mindustry.io.TypeIO;
 import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.net.NetConnection;
@@ -24,13 +38,6 @@ import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.Floor;
 import io.anuke.mindustry.world.blocks.storage.CoreBlock.CoreEntity;
-import io.anuke.arc.core.*;
-import io.anuke.arc.entities.EntityGroup;
-import io.anuke.arc.entities.EntityQuery;
-import io.anuke.arc.graphics.Draw;
-import io.anuke.arc.graphics.Hue;
-import io.anuke.arc.graphics.Lines;
-import io.anuke.arc.util.*;
 
 import java.io.DataInput;
 import java.io.DataOutput;
@@ -63,7 +70,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
     public NetConnection con;
     public int playerIndex = 0;
     public boolean isLocal = false;
-    public Timer timer = new Timer(4);
+    public Interval timer = new Interval(4);
     public TargetTrait target;
     public TargetTrait moveTarget;
 
@@ -72,7 +79,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
     private Tile mining;
     private CarriableTrait carrying;
     private Trail trail = new Trail(12);
-    private Vector2 movement = new Translator();
+    private Vector2 movement = new Vector2();
     private boolean moved;
 
     //endregion
@@ -112,7 +119,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
     }
 
     @Override
-    public Timer getTimer(){
+    public Interval getTimer(){
         return timer;
     }
 
@@ -559,7 +566,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
     protected void updateMech(){
         Tile tile = world.tileWorld(x, y);
 
-        isBoosting = Inputs.keyDown("dash") && !mech.flying;
+        isBoosting = Core.input.keyDown("dash") && !mech.flying;
 
         //if player is in solid block
         if(tile != null && tile.solid()){
@@ -579,7 +586,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
         }
 
         //drop from carrier on key press
-        if(!ui.chatfrag.chatOpen() && Inputs.keyTap("drop_unit")){
+        if(!ui.chatfrag.chatOpen() && Core.input.keyTap("drop_unit")){
             if(!mech.flying){
                 if(getCarrier() != null){
                     Call.dropSelf(this);
@@ -599,9 +606,9 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
 
         String section = control.input(playerIndex).section;
 
-        float xa = Inputs.getAxis(section, "move_x");
+        float xa = Core.input.axis(section, "move_x");
-        float ya = Inputs.getAxis(section, "move_y");
+        float ya = Core.input.axis(section, "move_y");
-        if(!Inputs.keyDown("gridMode")){
+        if(!Core.input.keyDown(Binding.gridMode)){
             movement.y += ya * speed;
             movement.x += xa * speed;
         }
@@ -619,7 +626,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
             }
             float prex = x, prey = y;
             updateVelocityStatus();
-            moved = distanceTo(prex, prey) > 0.001f;
+            moved = dst(prex, prey) > 0.001f;
         }else{
             velocity.setZero();
             x = Mathf.lerpDelta(x, getCarrier().getX(), 0.1f);
@@ -647,7 +654,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
 
     protected void updateFlying(){
         if(Units.invalidateTarget(target, this) && !(target instanceof TileEntity && ((TileEntity) target).damaged() && target.getTeam() == team &&
-        mech.canHeal && distanceTo(target) < getWeapon().getAmmo().getRange())){
+        mech.canHeal && dst(target) < getWeapon().getAmmo().getRange())){
             target = null;
         }
 
@@ -664,7 +671,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
                 velocity.setAngle(Mathf.slerpDelta(velocity.angle(), angleTo(moveTarget), 0.1f));
             }
 
-            if(distanceTo(moveTarget) < 2f){
+            if(dst(moveTarget) < 2f){
                 if(moveTarget instanceof CarriableTrait){
                     carry((CarriableTrait) moveTarget);
                 }else if(tapping){
@@ -687,7 +694,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
         movement.set(targetX - x, targetY - y).limit(isBoosting && !mech.flying ? mech.boostSpeed : mech.speed);
         movement.setAngle(Mathf.slerp(movement.angle(), velocity.angle(), 0.05f));
 
-        if(distanceTo(targetX, targetY) < attractDst){
+        if(dst(targetX, targetY) < attractDst){
             movement.setZero();
         }
 
@@ -699,7 +706,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
         rect.width += expansion * 2f;
         rect.height += expansion * 2f;
 
-        isBoosting = EntityQuery.collisions().overlapsTile(rect) || distanceTo(targetX, targetY) > 85f;
+        isBoosting = EntityQuery.collisions().overlapsTile(rect) || dst(targetX, targetY) > 85f;
 
         velocity.add(movement.scl(Time.delta()));
 
@@ -711,7 +718,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
 
         float lx = x, ly = y;
         updateVelocityStatus();
-        moved = distanceTo(lx, ly) > 0.001f && !isCarried();
+        moved = dst(lx, ly) > 0.001f && !isCarried();
 
         if(mech.flying){
             //hovering effect
@@ -731,7 +738,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
 
                         if(mech.canHeal && target == null){
                             target = Geometry.findClosest(x, y, world.indexer.getDamaged(Team.blue));
-                            if(target != null && distanceTo(target) > getWeapon().getAmmo().getRange()){
+                            if(target != null && dst(target) > getWeapon().getAmmo().getRange()){
                                 target = null;
                             }else if(target != null){
                                 target = ((Tile) target).entity;
@@ -743,7 +750,7 @@ public class Player extends Unit implements BuilderTrait, CarryTrait, ShooterTra
                         }
                     }
                 }else if(target.isValid() || (target instanceof TileEntity && ((TileEntity) target).damaged() && target.getTeam() == team &&
-                mech.canHeal && distanceTo(target) < getWeapon().getAmmo().getRange())){
+                mech.canHeal && dst(target) < getWeapon().getAmmo().getRange())){
                     //rotate toward and shoot the target
                     if(mech.turnCursor){
                         rotation = Mathf.slerpDelta(rotation, angleTo(target), 0.2f);

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

@@ -2,7 +2,7 @@ package io.anuke.mindustry.entities;
 
 import io.anuke.arc.math.Vector2;
 import io.anuke.mindustry.entities.traits.TargetTrait;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 /**
  * Class for predicting shoot angles based on velocities of targets.

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

@@ -1,12 +1,12 @@
 package io.anuke.mindustry.entities;
 
 import io.anuke.arc.graphics.Color;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
 import io.anuke.mindustry.content.StatusEffects;
 import io.anuke.mindustry.entities.traits.Saveable;
 import io.anuke.mindustry.type.ContentType;
 import io.anuke.mindustry.type.StatusEffect;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.util.Pooling;
 import io.anuke.arc.util.ThreadArray;
 import io.anuke.arc.util.Tmp;

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

@@ -1,11 +1,18 @@
 package io.anuke.mindustry.entities;
 
-import io.anuke.arc.math.GridPoint2;
-import io.anuke.arc.math.Vector2;
-import io.anuke.arc.utils.Array;
-import io.anuke.arc.utils.ObjectSet;
 import io.anuke.annotations.Annotations.Loc;
 import io.anuke.annotations.Annotations.Remote;
+import io.anuke.arc.collection.Array;
+import io.anuke.arc.collection.ObjectSet;
+import io.anuke.arc.entities.Effects;
+import io.anuke.arc.entities.EntityGroup;
+import io.anuke.arc.entities.impl.BaseEntity;
+import io.anuke.arc.entities.trait.HealthTrait;
+import io.anuke.arc.math.Mathf;
+import io.anuke.arc.math.geom.GridPoint2;
+import io.anuke.arc.math.geom.Vector2;
+import io.anuke.arc.util.Interval;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.content.fx.Fx;
 import io.anuke.mindustry.entities.bullet.Bullet;
 import io.anuke.mindustry.entities.traits.TargetTrait;
@@ -20,13 +27,6 @@ import io.anuke.mindustry.world.modules.ConsumeModule;
 import io.anuke.mindustry.world.modules.ItemModule;
 import io.anuke.mindustry.world.modules.LiquidModule;
 import io.anuke.mindustry.world.modules.PowerModule;
-import io.anuke.arc.core.Effects;
-import io.anuke.arc.core.Timers;
-import io.anuke.arc.entities.EntityGroup;
-import io.anuke.arc.entities.impl.BaseEntity;
-import io.anuke.arc.entities.trait.HealthTrait;
-import io.anuke.arc.util.Mathf;
-import io.anuke.arc.util.Timer;
 
 import java.io.DataInput;
 import java.io.DataOutput;
@@ -42,7 +42,7 @@ public class TileEntity extends BaseEntity implements TargetTrait, HealthTrait{
     public static int sleepingEntities = 0;
 
     public Tile tile;
-    public Timer timer;
+    public Interval timer;
     public float health;
     public float timeScale = 1f, timeScaleDuration;
 
@@ -78,7 +78,7 @@ public class TileEntity extends BaseEntity implements TargetTrait, HealthTrait{
 
         health = tile.block().health;
 
-        timer = new Timer(tile.block().timers);
+        timer = new Interval(tile.block().timers);
 
         if(added){
             add();

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

@@ -1,9 +1,20 @@
 package io.anuke.mindustry.entities;
 
+import io.anuke.arc.Core;
+import io.anuke.arc.entities.Effects;
+import io.anuke.arc.entities.impl.DestructibleEntity;
+import io.anuke.arc.entities.trait.DamageTrait;
+import io.anuke.arc.entities.trait.DrawTrait;
+import io.anuke.arc.entities.trait.SolidTrait;
 import io.anuke.arc.graphics.Color;
+import io.anuke.arc.graphics.g2d.Draw;
+import io.anuke.arc.graphics.g2d.Fill;
 import io.anuke.arc.graphics.g2d.TextureRegion;
-import io.anuke.arc.math.Rectangle;
+import io.anuke.arc.math.Mathf;
-import io.anuke.arc.math.Vector2;
+import io.anuke.arc.math.geom.Geometry;
+import io.anuke.arc.math.geom.Rectangle;
+import io.anuke.arc.math.geom.Vector2;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.entities.traits.*;
 import io.anuke.mindustry.game.Team;
@@ -15,16 +26,6 @@ import io.anuke.mindustry.type.Weapon;
 import io.anuke.mindustry.world.Pos;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.Floor;
-import io.anuke.arc.core.Effects;
-import io.anuke.arc.core.Timers;
-import io.anuke.arc.entities.impl.DestructibleEntity;
-import io.anuke.arc.entities.trait.DamageTrait;
-import io.anuke.arc.entities.trait.DrawTrait;
-import io.anuke.arc.entities.trait.SolidTrait;
-import io.anuke.arc.graphics.Draw;
-import io.anuke.arc.graphics.Fill;
-import io.anuke.arc.util.Geometry;
-import io.anuke.arc.util.Mathf;
 
 import java.io.DataInput;
 import java.io.DataOutput;
@@ -194,7 +195,7 @@ public abstract class Unit extends DestructibleEntity implements SaveTrait, Targ
 
         Units.getNearby(queryRect, t -> {
             if(t == this || t.getCarrier() == this || getCarrier() == t || t.isFlying() != isFlying()) return;
-            float dst = distanceTo(t);
+            float dst = dst(t);
             moveVector.set(x, y).sub(t.getX(), t.getY()).setLength(1f * (1f - (dst / queryRect.getWidth())));
             applyImpulse(moveVector.x, moveVector.y);
         });
@@ -324,7 +325,7 @@ public abstract class Unit extends DestructibleEntity implements SaveTrait, Targ
     }
 
     public TextureRegion getPowerCellRegion(){
-        return Draw.region("power-cell");
+        return Core.atlas.find("power-cell");
     }
 
     public void drawAll(){

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

@@ -1,18 +1,18 @@
 package io.anuke.mindustry.entities;
 
-import io.anuke.arc.math.Rectangle;
+import io.anuke.arc.collection.EnumSet;
-import io.anuke.arc.math.Vector2;
+import io.anuke.arc.entities.EntityGroup;
+import io.anuke.arc.entities.EntityQuery;
+import io.anuke.arc.function.Consumer;
+import io.anuke.arc.function.Predicate;
+import io.anuke.arc.math.geom.Geometry;
+import io.anuke.arc.math.geom.Rectangle;
+import io.anuke.arc.math.geom.Vector2;
 import io.anuke.mindustry.entities.traits.TargetTrait;
 import io.anuke.mindustry.entities.units.BaseUnit;
 import io.anuke.mindustry.game.Team;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.entities.EntityGroup;
-import io.anuke.arc.entities.EntityQuery;
-import io.anuke.arc.function.Consumer;
-import io.anuke.arc.function.Predicate;
-import io.anuke.arc.util.EnumSet;
-import io.anuke.arc.util.Geometry;
 
 import static io.anuke.mindustry.Vars.*;
 
@@ -38,7 +38,7 @@ public class Units{
      * @return whether the target is invalid
      */
     public static boolean invalidateTarget(TargetTrait target, Team team, float x, float y, float range){
-        return target == null || (range != Float.MAX_VALUE && target.distanceTo(x, y) > range) || target.getTeam() == team || !target.isValid();
+        return target == null || (range != Float.MAX_VALUE && target.dst(x, y) > range) || target.getTeam() == team || !target.isValid();
     }
 
     /**See {@link #invalidateTarget(TargetTrait, Team, float, float, float)}*/
@@ -221,7 +221,7 @@ public class Units{
         EntityGroup<BaseUnit> group = unitGroups[team.ordinal()];
         if(!group.isEmpty()){
             EntityQuery.getNearby(group, rect, entity -> {
-                if(entity.distanceTo(x, y) <= radius){
+                if(entity.dst(x, y) <= radius){
                     cons.accept((Unit) entity);
                 }
             });
@@ -229,7 +229,7 @@ public class Units{
 
         //now check all players
         EntityQuery.getNearby(playerGroup, rect, player -> {
-            if(((Unit) player).team == team && player.distanceTo(x, y) <= radius){
+            if(((Unit) player).team == team && player.dst(x, y) <= radius){
                 cons.accept((Unit) player);
             }
         });

core/src/io/anuke/mindustry/entities/bullet/ArtilleryBulletType.java

@@ -1,8 +1,8 @@
 package io.anuke.mindustry.entities.bullet;
 
 import io.anuke.mindustry.content.fx.BulletFx;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
 import io.anuke.arc.graphics.Draw;
 
 //TODO scale velocity depending on fslope()

core/src/io/anuke/mindustry/entities/bullet/BasicBulletType.java

@@ -6,11 +6,11 @@ import io.anuke.mindustry.entities.Damage;
 import io.anuke.mindustry.entities.Units;
 import io.anuke.mindustry.entities.traits.TargetTrait;
 import io.anuke.mindustry.graphics.Palette;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 /**
  * A BulletType for most ammo-based bullets shot from turrets and units.
@@ -47,8 +47,8 @@ public class BasicBulletType extends BulletType{
 
     @Override
     public void load(){
-        backRegion = Draw.region(bulletSprite + "-back");
+        backRegion = Core.atlas.find(bulletSprite + "-back");
-        frontRegion = Draw.region(bulletSprite);
+        frontRegion = Core.atlas.find(bulletSprite);
     }
 
     @Override

core/src/io/anuke/mindustry/entities/bullet/Bullet.java

@@ -10,13 +10,13 @@ import io.anuke.mindustry.entities.traits.SyncTrait;
 import io.anuke.mindustry.entities.traits.TeamTrait;
 import io.anuke.mindustry.game.Team;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.entities.EntityGroup;
 import io.anuke.arc.entities.impl.BulletEntity;
 import io.anuke.arc.entities.trait.Entity;
 import io.anuke.arc.entities.trait.SolidTrait;
 import io.anuke.arc.entities.trait.VelocityTrait;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Pooling;
 import io.anuke.arc.util.Timer;
 

core/src/io/anuke/mindustry/entities/bullet/BulletType.java

@@ -6,8 +6,8 @@ import io.anuke.mindustry.game.Content;
 import io.anuke.mindustry.type.ContentType;
 import io.anuke.mindustry.type.StatusEffect;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
 import io.anuke.arc.entities.impl.BaseBulletType;
 import io.anuke.arc.util.Translator;
 

core/src/io/anuke/mindustry/entities/bullet/FlakBulletType.java

@@ -3,7 +3,7 @@ package io.anuke.mindustry.entities.bullet;
 import io.anuke.arc.math.Rectangle;
 import io.anuke.mindustry.content.fx.BulletFx;
 import io.anuke.mindustry.entities.Units;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 
 public abstract class FlakBulletType extends BasicBulletType{
     protected static Rectangle rect = new Rectangle();
@@ -27,7 +27,7 @@ public abstract class FlakBulletType extends BasicBulletType{
             Units.getNearbyEnemies(b.getTeam(), rect.setSize(explodeRange*2f).setCenter(b.x, b.y), unit -> {
                 if(b.getData() instanceof Float) return;
 
-                if(unit.distanceTo(b) < explodeRange){
+                if(unit.dst(b) < explodeRange){
                     b.setData(0);
                     Time.run(5f, () -> {
                         if(b.getData() instanceof Integer){

core/src/io/anuke/mindustry/entities/bullet/LiquidBulletType.java

@@ -8,11 +8,11 @@ import io.anuke.mindustry.entities.effect.Fire;
 import io.anuke.mindustry.entities.effect.Puddle;
 import io.anuke.mindustry.type.Liquid;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.util.Geometry;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.tilesize;
 import static io.anuke.mindustry.Vars.world;

core/src/io/anuke/mindustry/entities/bullet/MissileBulletType.java

@@ -3,9 +3,9 @@ package io.anuke.mindustry.entities.bullet;
 import io.anuke.arc.graphics.Color;
 import io.anuke.mindustry.content.fx.BulletFx;
 import io.anuke.mindustry.graphics.Palette;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class MissileBulletType extends BasicBulletType{
     protected Color trailColor = Palette.missileYellowBack;

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

@@ -6,7 +6,7 @@ import io.anuke.arc.entities.EntityGroup;
 import io.anuke.arc.entities.impl.TimedEntity;
 import io.anuke.arc.entities.trait.DrawTrait;
 import io.anuke.arc.graphics.Draw;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.groundEffectGroup;
 

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

@@ -1,8 +1,8 @@
 package io.anuke.mindustry.entities.effect;
 
 import io.anuke.arc.math.GridPoint2;
-import io.anuke.arc.utils.IntMap;
+import io.anuke.arc.util.IntMap;
-import io.anuke.arc.utils.Pool.Poolable;
+import io.anuke.arc.util.Pool.Poolable;
 import io.anuke.annotations.Annotations.Loc;
 import io.anuke.annotations.Annotations.Remote;
 import io.anuke.mindustry.content.StatusEffects;
@@ -16,13 +16,13 @@ import io.anuke.mindustry.gen.Call;
 import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.entities.EntityGroup;
 import io.anuke.arc.entities.impl.TimedEntity;
 import io.anuke.arc.util.Structs;
 import io.anuke.arc.util.Geometry;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Pooling;
 
 import java.io.DataInput;

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

@@ -2,12 +2,12 @@ package io.anuke.mindustry.entities.effect;
 
 import io.anuke.mindustry.Vars;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Effects.Effect;
+import io.anuke.arc.entities.Effects.Effect;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.entities.impl.EffectEntity;
-import io.anuke.arc.core.Effects.EffectRenderer;
+import io.anuke.arc.Effects.EffectRenderer;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 /**
  * A ground effect contains an effect that is rendered on the ground layer as opposed to the top layer.

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

@@ -11,9 +11,9 @@ import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.math.Interpolation;
 import io.anuke.arc.math.Vector2;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Pooling;
-import io.anuke.arc.utils.Time;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.entities.Unit;
 import io.anuke.mindustry.graphics.Palette;
 import io.anuke.mindustry.type.Item;

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

@@ -2,8 +2,8 @@ package io.anuke.mindustry.entities.effect;
 
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.math.Rectangle;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.IntSet;
+import io.anuke.arc.util.IntSet;
 import io.anuke.annotations.Annotations.Loc;
 import io.anuke.annotations.Annotations.Remote;
 import io.anuke.mindustry.content.bullets.TurretBullets;
@@ -21,7 +21,6 @@ import io.anuke.arc.entities.trait.PosTrait;
 import io.anuke.arc.entities.trait.TimeTrait;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Lines;
-import io.anuke.arc.util.*;
 
 import java.io.DataInput;
 import java.io.DataOutput;

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

@@ -3,8 +3,8 @@ package io.anuke.mindustry.entities.effect;
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.math.GridPoint2;
 import io.anuke.arc.math.Rectangle;
-import io.anuke.arc.utils.IntMap;
+import io.anuke.arc.util.IntMap;
-import io.anuke.arc.utils.Pool.Poolable;
+import io.anuke.arc.util.Pool.Poolable;
 import io.anuke.annotations.Annotations.Loc;
 import io.anuke.annotations.Annotations.Remote;
 import io.anuke.mindustry.content.Liquids;
@@ -19,8 +19,8 @@ import io.anuke.mindustry.gen.Call;
 import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.type.Liquid;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.entities.EntityGroup;
 import io.anuke.arc.entities.impl.SolidEntity;
 import io.anuke.arc.entities.trait.DrawTrait;
@@ -29,7 +29,7 @@ import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Hue;
 import io.anuke.arc.util.Angles;
 import io.anuke.arc.util.Geometry;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Pooling;
 
 import java.io.DataInput;

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

@@ -1,7 +1,7 @@
 package io.anuke.mindustry.entities.effect;
 
 import io.anuke.arc.graphics.Draw;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class RubbleDecal extends Decal{
     private int size;

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

@@ -4,7 +4,7 @@ import io.anuke.arc.graphics.g2d.TextureRegion;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.world;
 
@@ -15,7 +15,7 @@ public class ScorchDecal extends Decal{
     public static void create(float x, float y){
         if(regions[0] == null){
             for(int i = 0; i < regions.length; i++){
-                regions[i] = Draw.region("scorch" + (i + 1));
+                regions[i] = Core.atlas.find("scorch" + (i + 1));
             }
         }
 

core/src/io/anuke/mindustry/entities/traits/BuilderTrait.java

@@ -2,8 +2,8 @@ package io.anuke.mindustry.entities.traits;
 
 import io.anuke.arc.Core;
 import io.anuke.arc.graphics.Color;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.Queue;
+import io.anuke.arc.util.Queue;
 import io.anuke.mindustry.Vars;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.content.fx.BlockFx;
@@ -21,16 +21,16 @@ import io.anuke.mindustry.world.Pos;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.BuildBlock;
 import io.anuke.mindustry.world.blocks.BuildBlock.BuildEntity;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Events;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.entities.trait.Entity;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.graphics.Shapes;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import java.io.DataInput;
 import java.io.DataOutput;
@@ -202,7 +202,7 @@ public interface BuilderTrait extends Entity{
 
         Tile tile = world.tile(current.x, current.y);
 
-        if(unit.distanceTo(tile) > placeDistance){
+        if(unit.dst(tile) > placeDistance){
             return;
         }
 
@@ -232,7 +232,7 @@ public interface BuilderTrait extends Entity{
             return;
         }
 
-        if(unit.distanceTo(tile) <= placeDistance){
+        if(unit.dst(tile) <= placeDistance){
             unit.rotation = Mathf.slerpDelta(unit.rotation, unit.angleTo(entity), 0.4f);
         }
 
@@ -261,7 +261,7 @@ public interface BuilderTrait extends Entity{
         Tile tile = getMineTile();
         TileEntity core = unit.getClosestCore();
 
-        if(core == null || tile.block() != Blocks.air || unit.distanceTo(tile.worldx(), tile.worldy()) > mineDistance
+        if(core == null || tile.block() != Blocks.air || unit.dst(tile.worldx(), tile.worldy()) > mineDistance
                 || tile.floor().drops == null || !unit.inventory.canAcceptItem(tile.floor().drops.item) || !canMine(tile.floor().drops.item)){
             setMineTile(null);
         }else{
@@ -270,7 +270,7 @@ public interface BuilderTrait extends Entity{
 
             if(Mathf.chance(Time.delta() * (0.06 - item.hardness * 0.01) * getMinePower())){
 
-                if(unit.distanceTo(core) < mineTransferRange && core.tile.block().acceptStack(item, 1, core.tile, unit) == 1){
+                if(unit.dst(core) < mineTransferRange && core.tile.block().acceptStack(item, 1, core.tile, unit) == 1){
                     Call.transferItemTo(item, 1,
                         tile.worldx() + Mathf.range(tilesize / 2f),
                         tile.worldy() + Mathf.range(tilesize / 2f), core.tile);
@@ -304,7 +304,7 @@ public interface BuilderTrait extends Entity{
 
         Tile tile = world.tile(request.x, request.y);
 
-        if(unit.distanceTo(tile) > placeDistance){
+        if(unit.dst(tile) > placeDistance){
             return;
         }
 

core/src/io/anuke/mindustry/entities/traits/CarryTrait.java

@@ -5,7 +5,7 @@ import io.anuke.annotations.Annotations.Remote;
 import io.anuke.mindustry.content.fx.UnitFx;
 import io.anuke.mindustry.entities.Player;
 import io.anuke.mindustry.gen.Call;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
 import io.anuke.arc.entities.trait.SolidTrait;
 
 public interface CarryTrait extends TeamTrait, SolidTrait, TargetTrait{

core/src/io/anuke/mindustry/entities/traits/SyncTrait.java

@@ -2,7 +2,7 @@ package io.anuke.mindustry.entities.traits;
 
 import io.anuke.mindustry.core.NetClient;
 import io.anuke.mindustry.net.Interpolator;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Core;
 import io.anuke.arc.entities.trait.Entity;
 import io.anuke.arc.util.Tmp;
 

core/src/io/anuke/mindustry/entities/units/BaseUnit.java

@@ -24,8 +24,8 @@ import io.anuke.mindustry.type.Weapon;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.units.CommandCenter.CommandCenterEntity;
 import io.anuke.mindustry.world.meta.BlockFlag;
-import io.anuke.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.entities.EntityGroup;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.util.*;

core/src/io/anuke/mindustry/entities/units/FlyingUnit.java

@@ -10,7 +10,7 @@ import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.type.AmmoType;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.meta.BlockFlag;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.util.*;
 

core/src/io/anuke/mindustry/entities/units/GroundUnit.java

@@ -12,10 +12,10 @@ import io.anuke.mindustry.type.ContentType;
 import io.anuke.mindustry.type.Weapon;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.Floor;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.util.Angles;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Translator;
 
 import java.io.DataInput;

core/src/io/anuke/mindustry/entities/units/UnitDrops.java

@@ -5,7 +5,7 @@ import io.anuke.mindustry.content.Items;
 import io.anuke.mindustry.entities.TileEntity;
 import io.anuke.mindustry.gen.Call;
 import io.anuke.mindustry.type.Item;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 public class UnitDrops{
     private static Item[] dropTable;

core/src/io/anuke/mindustry/entities/units/UnitType.java

@@ -2,7 +2,7 @@ package io.anuke.mindustry.entities.units;
 
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.graphics.g2d.TextureRegion;
-import io.anuke.arc.utils.ObjectSet;
+import io.anuke.arc.collection.ObjectSet;
 import io.anuke.mindustry.content.Items;
 import io.anuke.mindustry.content.Weapons;
 import io.anuke.mindustry.entities.traits.TypeTrait;
@@ -78,12 +78,12 @@ public class UnitType extends UnlockableContent{
 
     @Override
     public void load(){
-        iconRegion = Draw.region("unit-icon-" + name);
+        iconRegion = Core.atlas.find("unit-icon-" + name);
-        region = Draw.region(name);
+        region = Core.atlas.find(name);
 
         if(!isFlying){
-            legRegion = Draw.region(name + "-leg");
+            legRegion = Core.atlas.find(name + "-leg");
-            baseRegion = Draw.region(name + "-base");
+            baseRegion = Core.atlas.find(name + "-base");
         }
     }
 

core/src/io/anuke/mindustry/entities/units/types/AlphaDrone.java

@@ -15,8 +15,8 @@ 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.arc.core.Effects;
+import io.anuke.arc.Effects;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import java.io.DataInput;
 import java.io.DataOutput;

core/src/io/anuke/mindustry/entities/units/types/Drone.java

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.entities.units.types;
 
-import io.anuke.arc.utils.Queue;
+import io.anuke.arc.util.Queue;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.entities.Player;
 import io.anuke.mindustry.entities.TileEntity;
@@ -20,10 +20,10 @@ import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.BuildBlock;
 import io.anuke.mindustry.world.blocks.BuildBlock.BuildEntity;
 import io.anuke.mindustry.world.meta.BlockFlag;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Events;
 import io.anuke.arc.entities.EntityGroup;
 import io.anuke.arc.util.Geometry;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Structs;
 
 import java.io.DataInput;
@@ -108,7 +108,7 @@ public class Drone extends FlyingUnit implements BuilderTrait{
 
             if(target == null) return;
 
-            if(target.distanceTo(Drone.this) > type.range){
+            if(target.dst(Drone.this) > type.range){
                 circle(type.range*0.9f);
             }else{
                 getWeapon().update(Drone.this, target.getX(), target.getY());
@@ -254,7 +254,7 @@ public class Drone extends FlyingUnit implements BuilderTrait{
     }
 
     private void notifyPlaced(BuildEntity entity, boolean isBreaking){
-        float dist = Math.min(entity.distanceTo(x, y) - placeDistance, 0);
+        float dist = Math.min(entity.dst(x, y) - placeDistance, 0);
 
         if(!state.is(build) && dist / type.maxVelocity < entity.buildCost * 0.9f){
             target = entity;
@@ -311,7 +311,7 @@ public class Drone extends FlyingUnit implements BuilderTrait{
 
     @Override
     protected void updateRotation(){
-        if(target != null && ((state.is(repair) && target.distanceTo(this) < type.range) || state.is(mine))){
+        if(target != null && ((state.is(repair) && target.dst(this) < type.range) || state.is(mine))){
             rotation = Mathf.slerpDelta(rotation, angleTo(target), 0.3f);
         }else{
             rotation = Mathf.slerpDelta(rotation, velocity.angle(), 0.3f);

core/src/io/anuke/mindustry/game/EventType.java

@@ -43,14 +43,6 @@ public class EventType{
 
     }
 
-    /**
-     * Called after the WorldLoadEvent is, and all logic has been loaded.
-     * It is safe to intialize graphics here.
-     */
-    public static class WorldLoadGraphicsEvent implements Event{
-
-    }
-
     /**Called from the logic thread. Do not access graphics here!*/
     public static class TileChangeEvent implements Event{
         public final Tile tile;

core/src/io/anuke/mindustry/game/Saves.java

@@ -1,18 +1,17 @@
 package io.anuke.mindustry.game;
 
 import io.anuke.arc.files.FileHandle;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.IntArray;
+import io.anuke.arc.util.IntArray;
-import io.anuke.arc.utils.IntMap;
+import io.anuke.arc.util.IntMap;
-import io.anuke.arc.utils.TimeUtils;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.core.GameState.State;
 import io.anuke.mindustry.game.EventType.StateChangeEvent;
 import io.anuke.mindustry.io.SaveIO;
 import io.anuke.mindustry.io.SaveMeta;
 import io.anuke.mindustry.maps.Map;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Events;
-import io.anuke.arc.core.Settings;
+import io.anuke.arc.Timers;
-import io.anuke.arc.core.Timers;
 import io.anuke.arc.util.Strings;
 import io.anuke.arc.util.ThreadArray;
 
@@ -71,9 +70,9 @@ public class Saves{
         if(current != null && !state.is(State.menu)
             && !(state.isPaused() && ui.hasDialog())){
             if(lastTimestamp != 0){
-                totalPlaytime += TimeUtils.timeSinceMillis(lastTimestamp);
+                totalPlaytime += Time.timeSinceMillis(lastTimestamp);
             }
-            lastTimestamp = TimeUtils.millis();
+            lastTimestamp = Time.millis();
         }
 
         if(!state.is(State.menu) && !state.gameOver && current != null && current.isAutosave()){

core/src/io/anuke/mindustry/game/Teams.java

@@ -1,10 +1,9 @@
 package io.anuke.mindustry.game;
 
-import io.anuke.arc.utils.ObjectSet;
+import io.anuke.arc.collection.EnumSet;
+import io.anuke.arc.collection.ObjectSet;
 import io.anuke.mindustry.Vars;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.util.EnumSet;
-import io.anuke.arc.util.ThreadSet;
 
 /**
  * Class for various team-based utilities.
@@ -52,7 +51,7 @@ public class Teams{
     }
 
     public class TeamData{
-        public final ObjectSet<Tile> cores = new ThreadSet<>();
+        public final ObjectSet<Tile> cores = new ObjectSet<>();
         public final EnumSet<Team> enemies;
         public final Team team;
 

core/src/io/anuke/mindustry/game/Unlocks.java

@@ -1,11 +1,11 @@
 package io.anuke.mindustry.game;
 
-import io.anuke.arc.utils.ObjectMap;
+import io.anuke.arc.collection.ObjectMap;
-import io.anuke.arc.utils.ObjectSet;
+import io.anuke.arc.collection.ObjectSet;
 import io.anuke.mindustry.game.EventType.UnlockEvent;
 import io.anuke.mindustry.type.ContentType;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Events;
-import io.anuke.arc.core.Settings;
+import io.anuke.arc.Settings;
 
 /**Stores player unlocks. Clientside only.*/
 public class Unlocks{

core/src/io/anuke/mindustry/game/Version.java

@@ -2,8 +2,8 @@ package io.anuke.mindustry.game;
 
 import io.anuke.arc.Core;
 import io.anuke.arc.files.FileHandle;
-import io.anuke.arc.utils.ObjectMap;
+import io.anuke.arc.collection.ObjectMap;
-import io.anuke.arc.utils.PropertiesUtils;
+import io.anuke.arc.util.PropertiesUtils;
 import io.anuke.arc.util.Strings;
 
 import java.io.IOException;

core/src/io/anuke/mindustry/game/Waves.java

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.game;
 
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
 import io.anuke.mindustry.content.Items;
 import io.anuke.mindustry.content.StatusEffects;
 import io.anuke.mindustry.content.UnitTypes;

core/src/io/anuke/mindustry/graphics/BlockRenderer.java

@@ -1,20 +1,20 @@
 package io.anuke.mindustry.graphics;
 
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.IntSet;
+import io.anuke.arc.util.IntSet;
-import io.anuke.arc.utils.Sort;
+import io.anuke.arc.util.Sort;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.game.EventType.TileChangeEvent;
 import io.anuke.mindustry.game.EventType.WorldLoadGraphicsEvent;
 import io.anuke.mindustry.game.Team;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Core;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Events;
-import io.anuke.arc.core.Graphics;
+import io.anuke.arc.Graphics;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Surface;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.*;
 import static io.anuke.arc.core.Core.camera;

core/src/io/anuke/mindustry/graphics/CacheLayer.java

@@ -1,8 +1,8 @@
 package io.anuke.mindustry.graphics;
 
 import io.anuke.arc.graphics.Color;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Core;
-import io.anuke.arc.core.Graphics;
+import io.anuke.arc.Graphics;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Shader;
 

core/src/io/anuke/mindustry/graphics/FloorRenderer.java

@@ -4,23 +4,22 @@ import io.anuke.arc.Core;
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.graphics.GL20;
 import io.anuke.arc.graphics.OrthographicCamera;
-import io.anuke.arc.utils.IntArray;
+import io.anuke.arc.util.IntArray;
-import io.anuke.arc.utils.IntSet;
+import io.anuke.arc.util.IntSet;
-import io.anuke.arc.utils.IntSet.IntSetIterator;
+import io.anuke.arc.util.IntSet.IntSetIterator;
-import io.anuke.arc.utils.ObjectSet;
+import io.anuke.arc.collection.ObjectSet;
 import io.anuke.mindustry.game.EventType.WorldLoadGraphicsEvent;
 import io.anuke.mindustry.maps.Sector;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.blocks.Floor;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Events;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Graphics;
-import io.anuke.arc.core.Graphics;
+import io.anuke.arc.Timers;
-import io.anuke.arc.core.Timers;
 import io.anuke.arc.graphics.CacheBatch;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.util.Log;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Structs;
 
 import java.util.Arrays;

core/src/io/anuke/mindustry/graphics/FogRenderer.java

@@ -7,15 +7,14 @@ import io.anuke.arc.graphics.Pixmap.Format;
 import io.anuke.arc.graphics.Texture;
 import io.anuke.arc.graphics.g2d.TextureRegion;
 import io.anuke.arc.graphics.glutils.FrameBuffer;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.Disposable;
+import io.anuke.arc.util.Disposable;
 import io.anuke.mindustry.entities.Unit;
 import io.anuke.mindustry.game.EventType.TileChangeEvent;
 import io.anuke.mindustry.game.EventType.WorldLoadGraphicsEvent;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Events;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Graphics;
-import io.anuke.arc.core.Graphics;
 import io.anuke.arc.entities.EntityDraw;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;

core/src/io/anuke/mindustry/graphics/MinimapRenderer.java

@@ -6,20 +6,19 @@ import io.anuke.arc.graphics.Pixmap.Format;
 import io.anuke.arc.graphics.Texture;
 import io.anuke.arc.graphics.g2d.TextureRegion;
 import io.anuke.arc.math.Rectangle;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.Disposable;
+import io.anuke.arc.util.Disposable;
 import io.anuke.mindustry.entities.Unit;
 import io.anuke.mindustry.entities.Units;
 import io.anuke.mindustry.game.EventType.TileChangeEvent;
 import io.anuke.mindustry.game.EventType.WorldLoadGraphicsEvent;
 import io.anuke.mindustry.world.ColorMapper;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Events;
-import io.anuke.arc.core.Events;
+import io.anuke.arc.Graphics;
-import io.anuke.arc.core.Graphics;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Pixmaps;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.ThreadArray;
 
 import static io.anuke.mindustry.Vars.tilesize;

core/src/io/anuke/mindustry/graphics/OverlayRenderer.java

@@ -4,7 +4,7 @@ import io.anuke.arc.graphics.Color;
 import io.anuke.arc.math.MathUtils;
 import io.anuke.arc.math.Rectangle;
 import io.anuke.arc.math.Vector2;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.entities.Player;
 import io.anuke.mindustry.entities.TileEntity;
@@ -13,14 +13,14 @@ import io.anuke.mindustry.input.InputHandler;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
 import io.anuke.mindustry.world.meta.BlockBar;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Core;
-import io.anuke.arc.core.Graphics;
+import io.anuke.arc.Graphics;
-import io.anuke.arc.core.Settings;
+import io.anuke.arc.Settings;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Lines;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 import io.anuke.arc.util.Tmp;
 
 import static io.anuke.mindustry.Vars.*;

core/src/io/anuke/mindustry/graphics/Shaders.java

@@ -3,8 +3,8 @@ package io.anuke.mindustry.graphics;
 import io.anuke.arc.Core;
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.graphics.g2d.TextureRegion;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Core;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Shader;
 import io.anuke.arc.scene.ui.layout.Unit;

core/src/io/anuke/mindustry/graphics/Trail.java

@@ -2,12 +2,12 @@ package io.anuke.mindustry.graphics;
 
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.math.Vector2;
-import io.anuke.arc.utils.FloatArray;
+import io.anuke.arc.util.FloatArray;
-import io.anuke.arc.core.Timers;
+import io.anuke.arc.Timers;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Fill;
 import io.anuke.arc.graphics.Lines;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 /**
  * Class that renders a colored trail.

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

@@ -11,15 +11,15 @@ import io.anuke.mindustry.input.PlaceUtils.NormalizeResult;
 import io.anuke.mindustry.net.Net;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.Graphics;
+import io.anuke.arc.Graphics;
-import io.anuke.arc.core.Inputs;
+import io.anuke.arc.Inputs;
-import io.anuke.arc.core.Inputs.DeviceType;
+import io.anuke.arc.Core.input.DeviceType;
-import io.anuke.arc.core.KeyBinds;
+import io.anuke.arc.KeyBinds;
-import io.anuke.arc.core.Settings;
+import io.anuke.arc.Settings;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.scene.ui.layout.Unit;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.*;
 import static io.anuke.mindustry.input.CursorType.*;
@@ -128,11 +128,11 @@ public class DesktopInput extends InputHandler{
 
     @Override
     public void update(){
-        if(Net.active() && Inputs.keyTap("player_list")){
+        if(Net.active() && Core.input.keyTap("player_list")){
             ui.listfrag.toggle();
         }
 
-        if(Inputs.keyRelease(section, "select")){
+        if(Core.input.keyRelease(section, "select")){
             player.isShooting = false;
         }
 
@@ -141,11 +141,11 @@ public class DesktopInput extends InputHandler{
         boolean controller = KeyBinds.getSection(section).device.type == DeviceType.controller;
 
         //zoom and rotate things
-        if(Inputs.getAxisActive("zoom") && (Inputs.keyDown(section, "zoom_hold") || controller)){
+        if(Core.input.getAxisActive("zoom") && (Core.input.keyDown(section, "zoom_hold") || controller)){
-            renderer.scaleCamera((int) Inputs.getAxisTapped(section, "zoom"));
+            renderer.scaleCamera((int) Core.input.getAxisTapped(section, "zoom"));
         }
 
-        renderer.minimap.zoomBy(-(int) Inputs.getAxisTapped(section, "zoom_minimap"));
+        renderer.minimap.zoomBy(-(int) Core.input.getAxisTapped(section, "zoom_minimap"));
 
         if(player.isDead()) return;
 
@@ -167,7 +167,7 @@ public class DesktopInput extends InputHandler{
             selectScale = 0f;
         }
 
-        rotation = Mathf.mod(rotation + (int) Inputs.getAxisTapped(section, "rotate"), 4);
+        rotation = Mathf.mod(rotation + (int) Core.input.getAxisTapped(section, "rotate"), 4);
 
         Tile cursor = tileAt(Core.input.getX(), Core.input.getY());
 
@@ -203,11 +203,11 @@ public class DesktopInput extends InputHandler{
         int cursorX = tileX(Core.input.getX());
         int cursorY = tileY(Core.input.getY());
 
-        if(Inputs.keyTap(section, "deselect")){
+        if(Core.input.keyTap(section, "deselect")){
             player.setMineTile(null);
         }
 
-        if(Inputs.keyTap(section, "select") && !ui.hasMouse()){
+        if(Core.input.keyTap(section, "select") && !ui.hasMouse()){
             if(isPlacing()){
                 selectX = cursorX;
                 selectY = cursorY;
@@ -221,7 +221,7 @@ public class DesktopInput extends InputHandler{
             }else if(!ui.chatfrag.chatOpen()){ //if it's out of bounds, shooting is just fine
                 player.isShooting = true;
             }
-        }else if(Inputs.keyTap(section, "deselect") && (recipe != null || mode != none || player.isBuilding()) &&
+        }else if(Core.input.keyTap(section, "deselect") && (recipe != null || mode != none || player.isBuilding()) &&
         !(player.getCurrentRequest() != null && player.getCurrentRequest().breaking && KeyBinds.get(section, "deselect") == KeyBinds.get(section, "break"))){
             if(recipe == null){
                 player.clearBuilding();
@@ -229,7 +229,7 @@ public class DesktopInput extends InputHandler{
 
             recipe = null;
             mode = none;
-        }else if(Inputs.keyTap(section, "break") && !ui.hasMouse()){
+        }else if(Core.input.keyTap(section, "break") && !ui.hasMouse()){
             //is recalculated because setting the mode to breaking removes potential multiblock cursor offset
             mode = breaking;
             selectX = tileX(Core.input.getX());
@@ -237,7 +237,7 @@ public class DesktopInput extends InputHandler{
         }
 
 
-        if(Inputs.keyRelease(section, "break") || Inputs.keyRelease(section, "select")){
+        if(Core.input.keyRelease(section, "break") || Core.input.keyRelease(section, "select")){
 
             if(mode == placing){ //touch up while placing, place everything in selection
                 NormalizeResult result = PlaceUtils.normalizeArea(selectX, selectY, cursorX, cursorY, rotation, true, maxLength);
@@ -306,8 +306,8 @@ public class DesktopInput extends InputHandler{
                 controlling = true;
             }
 
-            float xa = Inputs.getAxis(section, "cursor_x");
+            float xa = Core.input.getAxis(section, "cursor_x");
-            float ya = Inputs.getAxis(section, "cursor_y");
+            float ya = Core.input.getAxis(section, "cursor_y");
 
             if(Math.abs(xa) > controllerMin || Math.abs(ya) > controllerMin){
                 float scl = Core.settings.getInt("sensitivity", 100) / 100f * Unit.dp.scl(1f);
@@ -319,7 +319,7 @@ public class DesktopInput extends InputHandler{
                     Core.input.setCursorCatched(true);
                 }
 
-                Inputs.getProcessor().touchDragged((int) getMouseX(), (int) getMouseY(), player.playerIndex);
+                Core.input.getProcessor().touchDragged((int) getMouseX(), (int) getMouseY(), player.playerIndex);
             }
 
             controlx = Mathf.clamp(controlx, 0, Core.graphics.getWidth());

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

@@ -6,11 +6,11 @@ import io.anuke.arc.Core;
 import io.anuke.arc.Graphics;
 import io.anuke.arc.entities.Effects;
 import io.anuke.arc.graphics.Color;
+import io.anuke.arc.input.InputProcessor;
 import io.anuke.arc.math.Mathf;
 import io.anuke.arc.math.geom.Vector2;
-import io.anuke.arc.scene.event.InputListener;
 import io.anuke.arc.scene.ui.layout.Table;
-import io.anuke.arc.utils.Time;
+import io.anuke.arc.util.Time;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.content.fx.EnvironmentFx;
 import io.anuke.mindustry.entities.Player;
@@ -29,7 +29,7 @@ import io.anuke.mindustry.world.Tile;
 
 import static io.anuke.mindustry.Vars.*;
 
-public abstract class InputHandler implements InputListener{
+public abstract class InputHandler implements InputProcessor{
     /**Used for dropping items.*/
     final static float playerSelectRange = mobile ? 17f : 11f;
     /**Maximum line length.*/
@@ -69,47 +69,45 @@ public abstract class InputHandler implements InputListener{
             throw new ValidateException(player, "Player cannot transfer an item.");
         }
 
-        threads.run(() -> {
+        if(player == null || tile.entity == null) return;
-            if(player == null || tile.entity == null) return;
 
-            player.isTransferring = true;
+        player.isTransferring = true;
 
-            Item item = player.inventory.getItem().item;
+        Item item = player.inventory.getItem().item;
-            int amount = player.inventory.getItem().amount;
+        int amount = player.inventory.getItem().amount;
-            int accepted = tile.block().acceptStack(item, amount, tile, player);
+        int accepted = tile.block().acceptStack(item, amount, tile, player);
-            player.inventory.getItem().amount -= accepted;
+        player.inventory.getItem().amount -= accepted;
 
-            int sent = Mathf.clamp(accepted / 4, 1, 8);
+        int sent = Mathf.clamp(accepted / 4, 1, 8);
-            int removed = accepted / sent;
+        int removed = accepted / sent;
-            int[] remaining = {accepted, accepted};
+        int[] remaining = {accepted, accepted};
-            Block block = tile.block();
+        Block block = tile.block();
 
-            for(int i = 0; i < sent; i++){
+        for(int i = 0; i < sent; i++){
-                boolean end = i == sent - 1;
+            boolean end = i == sent - 1;
-                Time.run(i * 3, () -> {
+            Time.run(i * 3, () -> {
-                    tile.block().getStackOffset(item, tile, stackTrns);
+                tile.block().getStackOffset(item, tile, stackTrns);
 
-                    ItemTransfer.create(item,
+                ItemTransfer.create(item,
-                            player.x + Mathf.trnsx(player.rotation + 180f, backTrns), player.y + Mathf.trnsy(player.rotation + 180f, backTrns),
+                        player.x + Mathf.trnsx(player.rotation + 180f, backTrns), player.y + Mathf.trnsy(player.rotation + 180f, backTrns),
-                            new Vector2(tile.drawx() + stackTrns.x, tile.drawy() + stackTrns.y), () -> {
+                        new Vector2(tile.drawx() + stackTrns.x, tile.drawy() + stackTrns.y), () -> {
-                                if(tile.block() != block || tile.entity == null || tile.entity.items == null) return;
+                            if(tile.block() != block || tile.entity == null || tile.entity.items == null) return;
 
-                                tile.block().handleStack(item, removed, tile, player);
+                            tile.block().handleStack(item, removed, tile, player);
-                                remaining[1] -= removed;
+                            remaining[1] -= removed;
 
-                                if(end && remaining[1] > 0){
+                            if(end && remaining[1] > 0){
-                                    tile.block().handleStack(item, remaining[1], tile, player);
+                                tile.block().handleStack(item, remaining[1], tile, player);
-                                }
+                            }
-                            });
+                        });
 
-                    remaining[0] -= removed;
+                remaining[0] -= removed;
 
-                    if(end){
+                if(end){
-                        player.isTransferring = false;
+                    player.isTransferring = false;
-                    }
+                }
-                });
+            });
-            }
+        }
-        });
     }
 
     @Remote(targets = Loc.both, called = Loc.server, forward = true)
@@ -246,7 +244,7 @@ public abstract class InputHandler implements InputListener{
                 && tile.floor().drops != null && tile.floor().drops.item.hardness <= player.mech.drillPower
                 && !tile.floor().playerUnmineable
                 && player.inventory.canAcceptItem(tile.floor().drops.item)
-                && tile.block() == Blocks.air && player.distanceTo(tile.worldx(), tile.worldy()) <= Player.mineDistance;
+                && tile.block() == Blocks.air && player.dst(tile.worldx(), tile.worldy()) <= Player.mineDistance;
     }
 
     /**Returns the tile at the specified MOUSE coordinates.*/
@@ -283,7 +281,7 @@ public abstract class InputHandler implements InputListener{
     }
 
     public void remove(){
-        Inputs.removeProcessor(this);
+        Core.input.removeProcessor(this);
         frag.remove();
     }
 
@@ -334,7 +332,7 @@ public abstract class InputHandler implements InputListener{
 
     public boolean validPlace(int x, int y, Block type, int rotation){
         for(Tile tile : state.teams.get(player.getTeam()).cores){
-            if(tile.distanceTo(x * tilesize, y * tilesize) < coreBuildRange){
+            if(tile.dst(x * tilesize, y * tilesize) < coreBuildRange){
                 return Build.validPlace(player.getTeam(), x, y, type, rotation) &&
                 Vector2.dst(player.x, player.y, x * tilesize, y * tilesize) < Player.placeDistance;
             }

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

@@ -8,9 +8,9 @@ import io.anuke.arc.input.GestureDetector.GestureListener;
 import io.anuke.arc.math.Interpolation;
 import io.anuke.arc.math.Rectangle;
 import io.anuke.arc.math.Vector2;
-import io.anuke.arc.utils.Align;
+import io.anuke.arc.util.Align;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.ObjectSet;
+import io.anuke.arc.collection.ObjectSet;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.content.fx.Fx;
 import io.anuke.mindustry.core.GameState.State;
@@ -27,11 +27,11 @@ import io.anuke.mindustry.type.Recipe;
 import io.anuke.mindustry.ui.dialogs.FloatingDialog;
 import io.anuke.mindustry.world.Block;
 import io.anuke.mindustry.world.Tile;
-import io.anuke.arc.core.*;
+import io.anuke.arc.*;
 import io.anuke.arc.graphics.Draw;
 import io.anuke.arc.graphics.Lines;
 import io.anuke.arc.scene.ui.layout.Table;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.*;
 import static io.anuke.mindustry.input.PlaceMode.*;
@@ -76,7 +76,7 @@ public class MobileInput extends InputHandler implements GestureListener{
 
     public MobileInput(Player player){
         super(player);
-        Inputs.addProcessor(new GestureDetector(20, 0.5f, 0.4f, 0.15f, this));
+        Core.input.addProcessor(new GestureDetector(20, 0.5f, 0.4f, 0.15f, this));
     }
 
     //region utility methods

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

@@ -1,7 +1,7 @@
 package io.anuke.mindustry.input;
 
 import io.anuke.mindustry.world.Block;
-import io.anuke.arc.util.Mathf;
+import io.anuke.arc.math.Mathf;
 
 import static io.anuke.mindustry.Vars.tilesize;
 

core/src/io/anuke/mindustry/io/BundleLoader.java

@@ -2,11 +2,9 @@ package io.anuke.mindustry.io;
 
 import io.anuke.arc.Core;
 import io.anuke.arc.files.FileHandle;
-import io.anuke.arc.utils.I18NBundle;
+import io.anuke.arc.util.I18NBundle;
 import io.anuke.mindustry.Vars;
-import io.anuke.arc.core.Core;
+import io.anuke.arc.Timers;
-import io.anuke.arc.core.Settings;
-import io.anuke.arc.core.Timers;
 import io.anuke.arc.util.Log;
 
 import java.util.Locale;

core/src/io/anuke/mindustry/io/Changelogs.java

@@ -1,8 +1,8 @@
 package io.anuke.mindustry.io;
 
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.JsonReader;
+import io.anuke.arc.util.JsonReader;
-import io.anuke.arc.utils.JsonValue;
+import io.anuke.arc.util.JsonValue;
 import io.anuke.mindustry.net.Net;
 import io.anuke.arc.function.Consumer;
 

core/src/io/anuke/mindustry/io/Contributors.java

@@ -1,8 +1,8 @@
 package io.anuke.mindustry.io;
 
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.JsonReader;
+import io.anuke.arc.util.JsonReader;
-import io.anuke.arc.utils.JsonValue;
+import io.anuke.arc.util.JsonValue;
 import io.anuke.mindustry.net.Net;
 import io.anuke.arc.function.Consumer;
 

core/src/io/anuke/mindustry/io/MapIO.java

@@ -3,9 +3,9 @@ package io.anuke.mindustry.io;
 import io.anuke.arc.graphics.Color;
 import io.anuke.arc.graphics.Pixmap;
 import io.anuke.arc.graphics.Pixmap.Format;
-import io.anuke.arc.utils.IntIntMap;
+import io.anuke.arc.util.IntIntMap;
-import io.anuke.arc.utils.ObjectMap;
+import io.anuke.arc.collection.ObjectMap;
-import io.anuke.arc.utils.ObjectMap.Entry;
+import io.anuke.arc.util.ObjectMap.Entry;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.content.blocks.StorageBlocks;
 import io.anuke.mindustry.game.Team;

core/src/io/anuke/mindustry/io/SaveFileVersion.java

@@ -1,6 +1,6 @@
 package io.anuke.mindustry.io;
 
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
 import io.anuke.mindustry.content.blocks.Blocks;
 import io.anuke.mindustry.content.blocks.StorageBlocks;
 import io.anuke.mindustry.entities.traits.SaveTrait;

core/src/io/anuke/mindustry/io/SaveIO.java

@@ -1,9 +1,9 @@
 package io.anuke.mindustry.io;
 
 import io.anuke.arc.files.FileHandle;
-import io.anuke.arc.utils.Array;
+import io.anuke.arc.collection.Array;
-import io.anuke.arc.utils.IntArray;
+import io.anuke.arc.util.IntArray;
-import io.anuke.arc.utils.IntMap;
+import io.anuke.arc.util.IntMap;
 import io.anuke.mindustry.Vars;
 import io.anuke.mindustry.io.versions.Save16;