mirrors/Mindustry
1
Fork 0
mirror of https://github.com/Anuken/Mindustry.git synced 2026-02-23 08:31:09 -08:00
Code Issues Projects Releases Wiki Activity

ctrl-shift-f

Browse source
This commit is contained in:
Anuken 2018-12-21 21:33:05 -05:00
parent 94908bc599
commit 3abfaf1bca
244 changed files with 976 additions and 999 deletions
Download patch file Download diff file Expand all files Collapse all files

2
build.gradle
View file

@ -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'

10
core/src/io/anuke/mindustry/Mindustry.java
View file

@ -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.utils.Log;
import io.anuke.arc.utils.Time;
import io.anuke.arc.utils.TimeUtils;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Time;
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);

2
core/src/io/anuke/mindustry/Vars.java
View file

@ -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;

17
core/src/io/anuke/mindustry/ai/BlockIndexer.java
View file

@ -1,7 +1,12 @@
package io.anuke.mindustry.ai;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.utils.*;
import io.anuke.arc.Events;
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 -> {

18
core/src/io/anuke/mindustry/ai/Pathfinder.java
View file

@ -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.utils.Queue;
import io.anuke.arc.utils.TimeUtils;
import io.anuke.arc.util.IntArray;
import io.anuke.arc.util.Queue;
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.core.Timers;
import io.anuke.arc.Events;
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];

6
core/src/io/anuke/mindustry/ai/WaveSpawner.java
View file

@ -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;

16
core/src/io/anuke/mindustry/content/Mechs.java
View file

@ -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.Effects;
import io.anuke.arc.core.Graphics;
import io.anuke.arc.core.Timers;
import io.anuke.arc.Core;
import io.anuke.arc.Effects;
import io.anuke.arc.Graphics;
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

6
core/src/io/anuke/mindustry/content/StatusEffects.java
View file

@ -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.core.Timers;
import io.anuke.arc.util.Mathf;
import io.anuke.arc.Effects;
import io.anuke.arc.Timers;
import io.anuke.arc.math.Mathf;
public class StatusEffects implements ContentList{
public static StatusEffect none, burning, freezing, wet, melting, tarred, overdrive, shielded, shocked;

2
core/src/io/anuke/mindustry/content/UnitTypes.java
View file

@ -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;

4
core/src/io/anuke/mindustry/content/blocks/Blocks.java
View file

@ -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,

2
core/src/io/anuke/mindustry/content/blocks/DebugBlocks.java
View file

@ -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;

2
core/src/io/anuke/mindustry/content/blocks/OreBlocks.java
View file

@ -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;

8
core/src/io/anuke/mindustry/content/blocks/TurretBlocks.java
View file

@ -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[1] = Draw.region(name + "-panel-right");
panels[0] = Core.atlas.find(name + "-panel-left");
panels[1] = Core.atlas.find(name + "-panel-right");
}
{

2
core/src/io/anuke/mindustry/content/bullets/FlakBullets.java
View file

@ -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;

4
core/src/io/anuke/mindustry/content/bullets/MissileBullets.java
View file

@ -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.util.Mathf;
import io.anuke.arc.Timers;
import io.anuke.arc.math.Mathf;
public class MissileBullets extends BulletList implements ContentList{
public static BulletType explosive, incindiary, surge, javelin, swarm;

12
core/src/io/anuke/mindustry/content/bullets/TurretBullets.java
View file

@ -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.core.Timers;
import io.anuke.arc.Effects;
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 dst1 = b.distanceTo(data.from);
float dst2 = b.distanceTo(data.to);
float baseDst = data.from.dst(data.to);
float dst1 = b.dst(data.from);
float dst2 = b.dst(data.to);
boolean intersect = false;

2
core/src/io/anuke/mindustry/content/bullets/WeaponBullets.java
View file

@ -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;

4
core/src/io/anuke/mindustry/content/fx/BlockFx.java
View file

@ -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;

4
core/src/io/anuke/mindustry/content/fx/BulletFx.java
View file

@ -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,

9
core/src/io/anuke/mindustry/content/fx/EnvironmentFx.java
View file

@ -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;

4
core/src/io/anuke/mindustry/content/fx/ExplosionFx.java
View file

@ -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;

2
core/src/io/anuke/mindustry/content/fx/Fx.java
View file

@ -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;

4
core/src/io/anuke/mindustry/content/fx/ShootFx.java
View file

@ -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;

4
core/src/io/anuke/mindustry/content/fx/UnitFx.java
View file

@ -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;

2
core/src/io/anuke/mindustry/core/ContentLoader.java
View file

@ -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.*;

11
core/src/io/anuke/mindustry/core/Control.java
View file

@ -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.utils.Strings;
import io.anuke.arc.utils.Time;
import io.anuke.arc.util.Interval;
import io.anuke.arc.util.Strings;
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){

2
core/src/io/anuke/mindustry/core/GameState.java
View file

@ -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;

18
core/src/io/anuke/mindustry/core/Logic.java
View file

@ -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();
}

37
core/src/io/anuke/mindustry/core/NetClient.java
View file

@ -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;
}

60
core/src/io/anuke/mindustry/core/NetServer.java
View file

@ -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;

12
core/src/io/anuke/mindustry/core/Platform.java
View file

@ -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;
}

16
core/src/io/anuke/mindustry/core/Renderer.java
View file

@ -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.utils.ScreenUtils;
import io.anuke.arc.utils.TimeUtils;
import io.anuke.arc.util.BufferUtils;
import io.anuke.arc.util.ScreenUtils;
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.core.Effects;
import io.anuke.arc.core.Graphics;
import io.anuke.arc.core.Settings;
import io.anuke.arc.Effects;
import io.anuke.arc.Graphics;
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();

45
core/src/io/anuke/mindustry/core/UI.java
View file

@ -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.freetype.FreeTypeFontGenerator.FreeTypeFontParameter;
import io.anuke.arc.graphics.g2d.Draw;
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(Keys.BACK, dialog::hide);
dialog.keyDown(KeyCode.ESCAPE, dialog::hide);
dialog.keyDown(KeyCode.BACK, dialog::hide);
dialog.show();
}

31
core/src/io/anuke/mindustry/core/World.java
View file

@ -1,8 +1,16 @@
package io.anuke.mindustry.core;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.utils.Array;
import io.anuke.arc.utils.ObjectMap;
import io.anuke.arc.ApplicationListener;
import io.anuke.arc.Core;
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),
Mathf.scl2(x2, tilesize), Mathf.scl2(y2, tilesize));
return raycast(Math.round(x / tilesize), Math.round(y / tilesize),
Math.round(x2 / tilesize), Math.round(y2 / tilesize));
}
/**

4
core/src/io/anuke/mindustry/editor/DrawOperation.java
View file

@ -1,7 +1,7 @@
package io.anuke.mindustry.editor;
import io.anuke.arc.utils.Array;
import io.anuke.arc.utils.IntSet;
import io.anuke.arc.collection.Array;
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;

2
core/src/io/anuke/mindustry/editor/EditorTool.java
View file

@ -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;

4
core/src/io/anuke/mindustry/editor/MapEditor.java
View file

@ -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};

31
core/src/io/anuke/mindustry/editor/MapEditorDialog.java
View file

@ -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.utils.Disposable;
import io.anuke.arc.utils.ObjectMap;
import io.anuke.arc.util.Align;
import io.anuke.arc.util.Disposable;
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.core.Graphics;
import io.anuke.arc.core.Inputs;
import io.anuke.arc.core.Timers;
import io.anuke.arc.Graphics;
import io.anuke.arc.Inputs;
import io.anuke.arc.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();

4
core/src/io/anuke/mindustry/editor/MapInfoDialog.java
View file

@ -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;

2
core/src/io/anuke/mindustry/editor/MapLoadDialog.java
View file

@ -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;

18
core/src/io/anuke/mindustry/editor/MapRenderer.java
View file

@ -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.utils.IntSet;
import io.anuke.arc.utils.IntSet.IntSetIterator;
import io.anuke.arc.util.Disposable;
import io.anuke.arc.util.IntSet;
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.Graphics;
import io.anuke.arc.Core;
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,

2
core/src/io/anuke/mindustry/editor/MapResizeDialog.java
View file

@ -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};

20
core/src/io/anuke/mindustry/editor/MapView.java
View file

@ -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.Graphics;
import io.anuke.arc.core.Inputs;
import io.anuke.arc.Core;
import io.anuke.arc.Graphics;
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)){
float ax = Inputs.getAxis("move_x");
float ay = Inputs.getAxis("move_y");
!Core.input.keyDown(io.anuke.arc.input.Input.CONTROL_LEFT)){
float ax = Core.input.getAxis("move_x");
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();
}

2
core/src/io/anuke/mindustry/editor/OperationStack.java
View file

@ -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;

10
core/src/io/anuke/mindustry/entities/Damage.java
View file

@ -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.core.Effects.Effect;
import io.anuke.arc.core.Timers;
import io.anuke.arc.Effects;
import io.anuke.arc.entities.Effects.Effect;
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);

65
core/src/io/anuke/mindustry/entities/Player.java
View file

@ -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 ya = Inputs.getAxis(section, "move_y");
if(!Inputs.keyDown("gridMode")){
float xa = Core.input.axis(section, "move_x");
float ya = Core.input.axis(section, "move_y");
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);

2
core/src/io/anuke/mindustry/entities/Predict.java
View file

@ -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.

4
core/src/io/anuke/mindustry/entities/StatusController.java
View file

@ -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;

26
core/src/io/anuke/mindustry/entities/TileEntity.java
View file

@ -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();

29
core/src/io/anuke/mindustry/entities/Unit.java
View file

@ -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.Vector2;
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.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(){

22
core/src/io/anuke/mindustry/entities/Units.java
View file

@ -1,18 +1,18 @@
package io.anuke.mindustry.entities;
import io.anuke.arc.math.Rectangle;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.collection.EnumSet;
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);
}
});

4
core/src/io/anuke/mindustry/entities/bullet/ArtilleryBulletType.java
View file

@ -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.core.Effects.Effect;
import io.anuke.arc.Effects;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.graphics.Draw;
//TODO scale velocity depending on fslope()

10
core/src/io/anuke/mindustry/entities/bullet/BasicBulletType.java
View file

@ -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.core.Timers;
import io.anuke.arc.Effects;
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");
frontRegion = Draw.region(bulletSprite);
backRegion = Core.atlas.find(bulletSprite + "-back");
frontRegion = Core.atlas.find(bulletSprite);
}
@Override

4
core/src/io/anuke/mindustry/entities/bullet/Bullet.java
View file

@ -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;

4
core/src/io/anuke/mindustry/entities/bullet/BulletType.java
View file

@ -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.core.Effects.Effect;
import io.anuke.arc.Effects;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.entities.impl.BaseBulletType;
import io.anuke.arc.util.Translator;

4
core/src/io/anuke/mindustry/entities/bullet/FlakBulletType.java
View file

@ -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){

4
core/src/io/anuke/mindustry/entities/bullet/LiquidBulletType.java
View file

@ -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;

6
core/src/io/anuke/mindustry/entities/bullet/MissileBulletType.java
View file

@ -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.core.Timers;
import io.anuke.arc.util.Mathf;
import io.anuke.arc.Effects;
import io.anuke.arc.Timers;
import io.anuke.arc.math.Mathf;
public class MissileBulletType extends BasicBulletType{
protected Color trailColor = Palette.missileYellowBack;

2
core/src/io/anuke/mindustry/entities/effect/Decal.java
View file

@ -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;

10
core/src/io/anuke/mindustry/entities/effect/Fire.java
View file

@ -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.utils.Pool.Poolable;
import io.anuke.arc.util.IntMap;
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.core.Timers;
import io.anuke.arc.Effects;
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;

10
core/src/io/anuke/mindustry/entities/effect/GroundEffectEntity.java
View file

@ -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.core.Effects.Effect;
import io.anuke.arc.core.Timers;
import io.anuke.arc.Effects;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.Timers;
import io.anuke.arc.entities.impl.EffectEntity;
import io.anuke.arc.core.Effects.EffectRenderer;
import io.anuke.arc.util.Mathf;
import io.anuke.arc.Effects.EffectRenderer;
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.

4
core/src/io/anuke/mindustry/entities/effect/ItemTransfer.java
View file

@ -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;

5
core/src/io/anuke/mindustry/entities/effect/Lightning.java
View file

@ -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.utils.IntSet;
import io.anuke.arc.collection.Array;
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;

10
core/src/io/anuke/mindustry/entities/effect/Puddle.java
View file

@ -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.utils.Pool.Poolable;
import io.anuke.arc.util.IntMap;
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.core.Timers;
import io.anuke.arc.Effects;
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;

2
core/src/io/anuke/mindustry/entities/effect/RubbleDecal.java
View file

@ -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;

4
core/src/io/anuke/mindustry/entities/effect/ScorchDecal.java
View file

@ -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));
}
}

22
core/src/io/anuke/mindustry/entities/traits/BuilderTrait.java
View file

@ -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.utils.Queue;
import io.anuke.arc.collection.Array;
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.core.Events;
import io.anuke.arc.core.Timers;
import io.anuke.arc.Effects;
import io.anuke.arc.Events;
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;
}

2
core/src/io/anuke/mindustry/entities/traits/CarryTrait.java
View file

@ -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{

2
core/src/io/anuke/mindustry/entities/traits/SyncTrait.java
View file

@ -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;

4
core/src/io/anuke/mindustry/entities/units/BaseUnit.java
View file

@ -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.core.Timers;
import io.anuke.arc.Effects;
import io.anuke.arc.Timers;
import io.anuke.arc.entities.EntityGroup;
import io.anuke.arc.graphics.Draw;
import io.anuke.arc.util.*;

2
core/src/io/anuke/mindustry/entities/units/FlyingUnit.java
View file

@ -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.*;

4
core/src/io/anuke/mindustry/entities/units/GroundUnit.java
View file

@ -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;

2
core/src/io/anuke/mindustry/entities/units/UnitDrops.java
View file

@ -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;

10
core/src/io/anuke/mindustry/entities/units/UnitType.java
View file

@ -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);
region = Draw.region(name);
iconRegion = Core.atlas.find("unit-icon-" + name);
region = Core.atlas.find(name);
if(!isFlying){
legRegion = Draw.region(name + "-leg");
baseRegion = Draw.region(name + "-base");
legRegion = Core.atlas.find(name + "-leg");
baseRegion = Core.atlas.find(name + "-base");
}
}

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

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

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

@ -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);

8
core/src/io/anuke/mindustry/game/EventType.java
View file

@ -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;

17
core/src/io/anuke/mindustry/game/Saves.java
View file

@ -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.utils.IntArray;
import io.anuke.arc.utils.IntMap;
import io.anuke.arc.utils.TimeUtils;
import io.anuke.arc.collection.Array;
import io.anuke.arc.util.IntArray;
import io.anuke.arc.util.IntMap;
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.core.Settings;
import io.anuke.arc.core.Timers;
import io.anuke.arc.Events;
import io.anuke.arc.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()){

7
core/src/io/anuke/mindustry/game/Teams.java
View file

@ -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;

8
core/src/io/anuke/mindustry/game/Unlocks.java
View file

@ -1,11 +1,11 @@
package io.anuke.mindustry.game;
import io.anuke.arc.utils.ObjectMap;
import io.anuke.arc.utils.ObjectSet;
import io.anuke.arc.collection.ObjectMap;
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.core.Settings;
import io.anuke.arc.Events;
import io.anuke.arc.Settings;
/**Stores player unlocks. Clientside only.*/
public class Unlocks{

4
core/src/io/anuke/mindustry/game/Version.java
View file

@ -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.utils.PropertiesUtils;
import io.anuke.arc.collection.ObjectMap;
import io.anuke.arc.util.PropertiesUtils;
import io.anuke.arc.util.Strings;
import java.io.IOException;

2
core/src/io/anuke/mindustry/game/Waves.java
View file

@ -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;

14
core/src/io/anuke/mindustry/graphics/BlockRenderer.java
View file

@ -1,20 +1,20 @@
package io.anuke.mindustry.graphics;
import io.anuke.arc.utils.Array;
import io.anuke.arc.utils.IntSet;
import io.anuke.arc.utils.Sort;
import io.anuke.arc.collection.Array;
import io.anuke.arc.util.IntSet;
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.Events;
import io.anuke.arc.core.Graphics;
import io.anuke.arc.Core;
import io.anuke.arc.Events;
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;

4
core/src/io/anuke/mindustry/graphics/CacheLayer.java
View file

@ -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.Graphics;
import io.anuke.arc.Core;
import io.anuke.arc.Graphics;
import io.anuke.arc.graphics.Draw;
import io.anuke.arc.graphics.Shader;

17
core/src/io/anuke/mindustry/graphics/FloorRenderer.java
View file

@ -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.utils.IntSet;
import io.anuke.arc.utils.IntSet.IntSetIterator;
import io.anuke.arc.utils.ObjectSet;
import io.anuke.arc.util.IntArray;
import io.anuke.arc.util.IntSet;
import io.anuke.arc.util.IntSet.IntSetIterator;
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.core.Events;
import io.anuke.arc.core.Graphics;
import io.anuke.arc.core.Timers;
import io.anuke.arc.Events;
import io.anuke.arc.Graphics;
import io.anuke.arc.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;

9
core/src/io/anuke/mindustry/graphics/FogRenderer.java
View file

@ -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.utils.Disposable;
import io.anuke.arc.collection.Array;
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.core.Events;
import io.anuke.arc.core.Graphics;
import io.anuke.arc.Events;
import io.anuke.arc.Graphics;
import io.anuke.arc.entities.EntityDraw;
import io.anuke.arc.graphics.Draw;
import io.anuke.arc.graphics.Fill;

11
core/src/io/anuke/mindustry/graphics/MinimapRenderer.java
View file

@ -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.utils.Disposable;
import io.anuke.arc.collection.Array;
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.core.Events;
import io.anuke.arc.core.Graphics;
import io.anuke.arc.Events;
import io.anuke.arc.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;

12
core/src/io/anuke/mindustry/graphics/OverlayRenderer.java
View file

@ -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.Graphics;
import io.anuke.arc.core.Settings;
import io.anuke.arc.core.Timers;
import io.anuke.arc.Core;
import io.anuke.arc.Graphics;
import io.anuke.arc.Settings;
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.*;

4
core/src/io/anuke/mindustry/graphics/Shaders.java
View file

@ -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.Timers;
import io.anuke.arc.Core;
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;

6
core/src/io/anuke/mindustry/graphics/Trail.java
View file

@ -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.core.Timers;
import io.anuke.arc.util.FloatArray;
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.

40
core/src/io/anuke/mindustry/input/DesktopInput.java
View file

@ -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.core.Inputs;
import io.anuke.arc.core.Inputs.DeviceType;
import io.anuke.arc.core.KeyBinds;
import io.anuke.arc.core.Settings;
import io.anuke.arc.Graphics;
import io.anuke.arc.Inputs;
import io.anuke.arc.Core.input.DeviceType;
import io.anuke.arc.KeyBinds;
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)){
renderer.scaleCamera((int) Inputs.getAxisTapped(section, "zoom"));
if(Core.input.getAxisActive("zoom") && (Core.input.keyDown(section, "zoom_hold") || controller)){
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 ya = Inputs.getAxis(section, "cursor_y");
float xa = Core.input.getAxis(section, "cursor_x");
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());

74
core/src/io/anuke/mindustry/input/InputHandler.java
View file

@ -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;
int amount = player.inventory.getItem().amount;
int accepted = tile.block().acceptStack(item, amount, tile, player);
player.inventory.getItem().amount -= accepted;
Item item = player.inventory.getItem().item;
int amount = player.inventory.getItem().amount;
int accepted = tile.block().acceptStack(item, amount, tile, player);
player.inventory.getItem().amount -= accepted;
int sent = Mathf.clamp(accepted / 4, 1, 8);
int removed = accepted / sent;
int[] remaining = {accepted, accepted};
Block block = tile.block();
int sent = Mathf.clamp(accepted / 4, 1, 8);
int removed = accepted / sent;
int[] remaining = {accepted, accepted};
Block block = tile.block();
for(int i = 0; i < sent; i++){
boolean end = i == sent - 1;
Time.run(i * 3, () -> {
tile.block().getStackOffset(item, tile, stackTrns);
for(int i = 0; i < sent; i++){
boolean end = i == sent - 1;
Time.run(i * 3, () -> {
tile.block().getStackOffset(item, tile, stackTrns);
ItemTransfer.create(item,
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), () -> {
if(tile.block() != block || tile.entity == null || tile.entity.items == null) return;
ItemTransfer.create(item,
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), () -> {
if(tile.block() != block || tile.entity == null || tile.entity.items == null) return;
tile.block().handleStack(item, removed, tile, player);
remaining[1] -= removed;
tile.block().handleStack(item, removed, tile, player);
remaining[1] -= removed;
if(end && remaining[1] > 0){
tile.block().handleStack(item, remaining[1], tile, player);
}
});
if(end && remaining[1] > 0){
tile.block().handleStack(item, remaining[1], tile, player);
}
});
remaining[0] -= removed;
remaining[0] -= removed;
if(end){
player.isTransferring = false;
}
});
}
});
if(end){
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;
}

12
core/src/io/anuke/mindustry/input/MobileInput.java
View file

@ -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.utils.Array;
import io.anuke.arc.utils.ObjectSet;
import io.anuke.arc.util.Align;
import io.anuke.arc.collection.Array;
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

2
core/src/io/anuke/mindustry/input/PlaceUtils.java
View file

@ -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;

6
core/src/io/anuke/mindustry/io/BundleLoader.java
View file

@ -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.core.Settings;
import io.anuke.arc.core.Timers;
import io.anuke.arc.Timers;
import io.anuke.arc.util.Log;
import java.util.Locale;

6
core/src/io/anuke/mindustry/io/Changelogs.java
View file

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

6
core/src/io/anuke/mindustry/io/Contributors.java
View file

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

6
core/src/io/anuke/mindustry/io/MapIO.java
View file

@ -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.utils.ObjectMap;
import io.anuke.arc.utils.ObjectMap.Entry;
import io.anuke.arc.util.IntIntMap;
import io.anuke.arc.collection.ObjectMap;
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;

2
core/src/io/anuke/mindustry/io/SaveFileVersion.java
View file

@ -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;

6
core/src/io/anuke/mindustry/io/SaveIO.java
View file

@ -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.utils.IntArray;
import io.anuke.arc.utils.IntMap;
import io.anuke.arc.collection.Array;
import io.anuke.arc.util.IntArray;
import io.anuke.arc.util.IntMap;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.io.versions.Save16;

Some files were not shown because too many files have changed in this diff Show more