Astronand/Mindustry
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hhhhhhh

Browse Source
This commit is contained in:
Anuken
2018-12-26 13:22:31 -05:00
parent 22b7086bea
commit 8879593381
164 changed files with 1151 additions and 1426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
core/src/io/anuke/mindustry/content/Mechs.java
View File

@@ -207,10 +207,10 @@ public class Mechs implements ContentList{
Shaders.build.region = armorRegion;
Shaders.build.time = Time.time() / 10f;
Shaders.build.color.set(Palette.accent).a = player.shootHeat;
Graphics.shader(Shaders.build);
Draw.shader(Shaders.build);
Draw.alpha(1f);
Draw.rect(armorRegion, player.snappedX(), player.snappedY(), player.rotation);
Graphics.shader(Shaders.mix);
Draw.shader(Shaders.mix);
Draw.color(1f, 1f, 1f, alpha);
}
};
@@ -269,13 +269,13 @@ public class Mechs implements ContentList{
float scl = scld(player);
if(scl < 0.01f) return;
float alpha = Core.batch.getColor().a;
Graphics.shader();
Draw.shader();
Graphics.setAdditiveBlending();
Draw.color(Palette.lancerLaser);
Draw.alpha(scl/2f);
Draw.rect(shield, player.snappedX() + Mathf.range(scl/2f), player.snappedY() + Mathf.range(scl/2f), player.rotation - 90);
Graphics.setNormalBlending();
Graphics.shader(Shaders.mix);
Draw.shader(Shaders.mix);
Draw.color();
Draw.alpha(alpha);
}

2
core/src/io/anuke/mindustry/content/blocks/TurretBlocks.java
View File

@@ -10,7 +10,7 @@ import io.anuke.mindustry.game.ContentList;
import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.blocks.defense.turrets.*;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.util.Angles;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
public class TurretBlocks extends BlockList implements ContentList{

2
core/src/io/anuke/mindustry/content/bullets/TurretBullets.java
View File

@@ -21,7 +21,7 @@ import io.anuke.mindustry.world.blocks.distribution.MassDriver.DriverBulletData;
import io.anuke.arc.entities.Effects;
import io.anuke.arc.util.Time;
import io.anuke.arc.graphics.*;
import io.anuke.arc.util.Angles;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
import static io.anuke.mindustry.Vars.content;

5
core/src/io/anuke/mindustry/content/fx/BlockFx.java
View File

@@ -6,10 +6,9 @@ import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.game.ContentList;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.graphics.Hue;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.util.Angles;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Tmp;

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

@@ -5,9 +5,9 @@ import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.game.ContentList;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.util.Angles;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
public class BulletFx extends FxList implements ContentList{

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

@@ -5,9 +5,9 @@ import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.game.ContentList;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.util.Angles;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
public class ExplosionFx extends FxList implements ContentList{

4
core/src/io/anuke/mindustry/content/fx/Fx.java
View File

@@ -5,9 +5,9 @@ import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.game.ContentList;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.util.Angles;
import io.anuke.arc.math.Angles;
import static io.anuke.mindustry.Vars.tilesize;

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

@@ -6,10 +6,10 @@ import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.game.ContentList;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.graphics.Shapes;
import io.anuke.arc.util.Angles;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
public class ShootFx extends FxList implements ContentList{

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

@@ -5,9 +5,9 @@ import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.game.ContentList;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.util.Angles;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
public class UnitFx extends FxList implements ContentList{

3
core/src/io/anuke/mindustry/core/Control.java
View File

@@ -8,6 +8,7 @@ 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.scene.ui.TextField;
import io.anuke.arc.util.Interval;
import io.anuke.arc.util.Strings;
import io.anuke.arc.util.Time;
@@ -349,7 +350,7 @@ public class Control implements ApplicationListener{
}
}
if(!mobile && Core.input.keyTap(Binding.screenshot) && !ui.chatfrag.chatOpen()){
if(!mobile && Core.input.keyTap(Binding.screenshot) && !(scene.getKeyboardFocus() instanceof TextField) && !ui.chatfrag.chatOpen()){
renderer.takeMapScreenshot();
}

130
core/src/io/anuke/mindustry/core/Renderer.java
View File

@@ -2,27 +2,20 @@ package io.anuke.mindustry.core;
import io.anuke.arc.ApplicationListener;
import io.anuke.arc.Core;
import io.anuke.arc.Graphics;
import io.anuke.arc.entities.Effects;
import io.anuke.arc.entities.EntityDraw;
import io.anuke.arc.entities.EntityGroup;
import io.anuke.arc.entities.impl.EffectEntity;
import io.anuke.arc.entities.trait.DrawTrait;
import io.anuke.arc.entities.trait.Entity;
import io.anuke.arc.files.FileHandle;
import io.anuke.arc.function.Consumer;
import io.anuke.arc.function.Predicate;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.Pixmap;
import io.anuke.arc.graphics.PixmapIO;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.Lines;
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.BufferUtils;
import io.anuke.arc.util.ScreenUtils;
import io.anuke.arc.util.Time;
import io.anuke.arc.util.pooling.Pools;
import io.anuke.mindustry.content.fx.Fx;
import io.anuke.mindustry.core.GameState.State;
@@ -35,9 +28,9 @@ import io.anuke.mindustry.entities.traits.BelowLiquidTrait;
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 static io.anuke.arc.Core.*;
import static io.anuke.arc.Core.camera;
import static io.anuke.arc.Core.graphics;
import static io.anuke.mindustry.Vars.*;
public class Renderer implements ApplicationListener{
@@ -102,68 +95,47 @@ public class Renderer implements ApplicationListener{
//TODO hack, find source of this bug
Color.WHITE.set(1f, 1f, 1f, 1f);
if(Core.cameraScale != targetscale){
float targetzoom = (float) Core.cameraScale / targetscale;
camera.zoom = Mathf.lerpDelta(camera.zoom, targetzoom, 0.2f);
if(Mathf.in(camera.zoom, targetzoom, 0.005f)){
camera.zoom = 1f;
Graphics.setCameraScale(targetscale);
for(Player player : players){
control.input(player.playerIndex).resetCursor();
}
}
}else{
camera.zoom = Mathf.lerpDelta(camera.zoom, 1f, 0.2f);
}
if(state.is(State.menu)){
Graphics.clear(Color.BLACK);
graphics.clear(Color.BLACK);
}else{
Vector2 position = averagePosition();
if(players[0].isDead()){
TileEntity core = players[0].getClosestCore();
if(core != null && players[0].spawner == Unit.noSpawner){
smoothCamera(core.x, core.y, 0.08f);
camera.position.lerpDelta(core.x, core.y, 0.08f);
}else{
smoothCamera(position.x + 0.0001f, position.y + 0.0001f, 0.08f);
camera.position.lerpDelta(position, 0.08f);
}
}else if(!mobile){
setCamera(position.x + 0.0001f, position.y + 0.0001f);
camera.position.set(position);
}
camera.position.x = Mathf.clamp(camera.position.x, -tilesize / 2f, world.width() * tilesize - tilesize / 2f);
camera.position.y = Mathf.clamp(camera.position.y, -tilesize / 2f, world.height() * tilesize - tilesize / 2f);
float prex = camera.position.x, prey = camera.position.y;
updateShake(0.75f);
//TODO update screenshake
//updateShake(0.75f);
float deltax = camera.position.x - prex, deltay = camera.position.y - prey;
float lastx = camera.position.x, lasty = camera.position.y;
if(snapCamera){
camera.position.set((int) camera.position.x, (int) camera.position.y, 0);
}
if(Core.graphics.getHeight() / Core.cameraScale % 2 == 1){
camera.position.add(0, -0.5f, 0);
}
if(Core.graphics.getWidth() / Core.cameraScale % 2 == 1){
camera.position.add(-0.5f, 0, 0);
camera.position.set((int) camera.position.x, (int) camera.position.y);
}
draw();
camera.position.set(lastx - deltax, lasty - deltay, 0);
camera.position.set(lastx - deltax, lasty - deltay);
}
if(!ui.chatfrag.chatOpen()){
renderer.record(); //this only does something if CoreGifRecorder is on the class path, which it usually isn't
//TODO does not work
//ScreenRecorder.record(); //this only does something if CoreGifRecorder is on the class path, which it usually isn't
}
}
@Override
public void draw(){
camera.update();
if(Float.isNaN(camera.position.x) || Float.isNaN(camera.position.y)){
@@ -171,13 +143,9 @@ public class Renderer implements ApplicationListener{
camera.position.y = players[0].y;
}
Graphics.clear(clearColor);
graphics.clear(clearColor);
batch.setProjectionMatrix(camera.combined);
Graphics.surface(pixelSurface, false);
Graphics.clear(clearColor);
graphics.batch().setProjection(camera.projection());
blocks.drawFloor();
@@ -189,26 +157,14 @@ public class Renderer implements ApplicationListener{
blocks.drawShadows();
for(Team team : Team.all){
if(blocks.isTeamShown(team)){
boolean outline = team != players[0].getTeam() && team != Team.none;
if(outline){
Shaders.outline.color.set(team.color);
Shaders.outline.color.a = 0.8f;
Graphics.beginShaders(Shaders.outline);
}
blocks.drawTeamBlocks(Layer.block, team);
if(outline){
Graphics.endShaders();
}
}
}
blocks.skipLayer(Layer.block);
Graphics.shader(Shaders.blockbuild, false);
Draw.shader(Shaders.blockbuild, false);
blocks.drawBlocks(Layer.placement);
Graphics.shader();
Draw.shader();
blocks.drawBlocks(Layer.overlay);
@@ -227,37 +183,47 @@ public class Renderer implements ApplicationListener{
overlays.drawBottom();
drawAndInterpolate(playerGroup, p -> true, Player::drawBuildRequests);
//TODO shield
/*
Graphics.beginShaders(Shaders.shield);
EntityDraw.draw(shieldGroup);
EntityDraw.drawWith(shieldGroup, shield -> true, shield -> ((ShieldEntity)shield).drawOver());
Draw.color(Palette.accent);
Graphics.endShaders();
Draw.color();
*/
overlays.drawTop();
//TODO fog
/*
if(showFog){
Graphics.surface();
}else{
Graphics.flushSurface();
}
}*/
batch.end();
//batch.end();
if(showFog){
fog.draw();
// fog.draw();
}
Graphics.beginCam();
//TODO this isn't necessary anymore
//Graphics.beginCam();
EntityDraw.setClip(false);
drawAndInterpolate(playerGroup, p -> !p.isDead() && !p.isLocal, Player::drawName);
EntityDraw.setClip(true);
Graphics.end();
//Graphics.end();
Draw.color();
Draw.flush();
}
private void drawFlyerShadows(){
Graphics.surface(effectSurface, true, false);
//TODO fix flyer shadows
//Graphics.surface(effectSurface, true, false);
float trnsX = -12, trnsY = -13;
@@ -271,9 +237,9 @@ public class Renderer implements ApplicationListener{
drawAndInterpolate(playerGroup, unit -> unit.isFlying() && !unit.isDead(), player -> player.drawShadow(trnsX, trnsY));
}
Draw.color(0, 0, 0, 0.15f);
Graphics.flushSurface();
Draw.color();
//Draw.color(0, 0, 0, 0.15f);
//Graphics.flushSurface();
// Draw.color();
}
private void drawAllTeams(boolean flying){
@@ -289,13 +255,13 @@ public class Renderer implements ApplicationListener{
Shaders.outline.color.set(team.color);
Shaders.mix.color.set(Color.WHITE);
Graphics.beginShaders(Shaders.outline);
Graphics.shader(Shaders.mix, true);
//Graphics.beginShaders(Shaders.outline);
//Draw.shader(Shaders.mix, true);
drawAndInterpolate(unitGroups[team.ordinal()], u -> u.isFlying() == flying && !u.isDead(), Unit::drawAll);
drawAndInterpolate(playerGroup, p -> p.isFlying() == flying && p.getTeam() == team, Unit::drawAll);
Graphics.shader();
//Draw.shader();
blocks.drawTeamBlocks(Layer.turret, team);
Graphics.endShaders();
//Graphics.endShaders();
drawAndInterpolate(unitGroups[team.ordinal()], u -> u.isFlying() == flying && !u.isDead(), Unit::drawOver);
drawAndInterpolate(playerGroup, p -> p.isFlying() == flying && p.getTeam() == team, Unit::drawOver);
@@ -316,13 +282,7 @@ public class Renderer implements ApplicationListener{
@Override
public void resize(int width, int height){
float lastX = camera.position.x, lastY = camera.position.y;
super.resize(width, height);
for(Player player : players){
control.input(player.playerIndex).resetCursor();
}
camera.update();
camera.position.set(lastX, lastY, 0f);
camera.resize(width, height);
}
@Override
@@ -342,10 +302,6 @@ public class Renderer implements ApplicationListener{
public void setCameraScale(int amount){
targetscale = amount;
clampScale();
//scale up all surfaces in preparation for the zoom
for(Surface surface : Graphics.getSurfaces()){
surface.setScale(targetscale);
}
}
public void scaleCamera(int amount){
@@ -358,6 +314,8 @@ public class Renderer implements ApplicationListener{
}
public void takeMapScreenshot(){
//TODO fix/implement
/*
float vpW = camera.width, vpH = camera.height;
int w = world.width()*tilesize, h = world.height()*tilesize;
int pw = pixelSurface.width(), ph = pixelSurface.height();
@@ -394,7 +352,7 @@ public class Renderer implements ApplicationListener{
pixelSurface.setSize(pw, ph, false);
Graphics.getEffectSurface().setSize(pw, ph, false);
ui.showInfoFade(Core.bundle.format("text.screenshot", file.toString()));
ui.showInfoFade(Core.bundle.format("text.screenshot", file.toString()));*/
}
}

10
core/src/io/anuke/mindustry/editor/MapRenderer.java
View File

@@ -2,7 +2,7 @@ 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.math.geom.Point2;
import io.anuke.arc.util.Disposable;
import io.anuke.arc.util.IntSet;
import io.anuke.arc.util.IntSet.IntSetIterator;
@@ -15,7 +15,7 @@ import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.IndexedRenderer;
import io.anuke.arc.util.Structs;
import io.anuke.arc.util.Bits;
import io.anuke.arc.util.Geometry;
import io.anuke.arc.math.geom.Geometry;
import static io.anuke.mindustry.Vars.content;
import static io.anuke.mindustry.Vars.tilesize;
@@ -111,8 +111,8 @@ public class MapRenderer implements Disposable{
byte bw = editor.getMap().read(wx, wy, DataPosition.wall);
byte btr = editor.getMap().read(wx, wy, DataPosition.rotationTeam);
byte elev = editor.getMap().read(wx, wy, DataPosition.elevation);
byte rotation = Bits.getLeftByte(btr);
Team team = Team.all[Bits.getRightByte(btr)];
byte rotation = Pack.leftByte(btr);
Team team = Team.all[Pack.rightByte(btr)];
Block floor = content.block(bf);
Block wall = content.block(bw);
@@ -159,7 +159,7 @@ public class MapRenderer implements Disposable{
}
private boolean checkElevation(byte elev, int x, int y){
for(GridPoint2 p : Geometry.d4){
for(Point2 p : Geometry.d4){
int wx = x + p.x, wy = y + p.y;
if(!Structs.inBounds(wx, wy, editor.getMap().width(), editor.getMap().height())){
return true;

28
core/src/io/anuke/mindustry/editor/MapView.java
View File

@@ -6,9 +6,9 @@ import io.anuke.arc.graphics.g2d.Batch;
import io.anuke.arc.input.GestureDetector;
import io.anuke.arc.input.GestureDetector.GestureListener;
import io.anuke.arc.math.Bresenham2;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.math.geom.Point2;
import io.anuke.arc.math.geom.Rectangle;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.math.geom.Vector2;
import io.anuke.arc.collection.Array;
import io.anuke.mindustry.editor.DrawOperation.TileOperation;
import io.anuke.mindustry.graphics.Palette;
@@ -24,7 +24,7 @@ import io.anuke.arc.scene.event.InputListener;
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.math.geom.Geometry;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Tmp;
@@ -61,7 +61,7 @@ public class MapView extends Element implements GestureListener{
}
Core.input.addProcessor(0, new GestureDetector(20, 0.5f, 2, 0.15f, this));
setTouchable(Touchable.enabled);
touchable(Touchable.enabled);
addListener(new InputListener(){
@@ -95,7 +95,7 @@ public class MapView extends Element implements GestureListener{
updated = false;
GridPoint2 p = project(x, y);
Point2 p = project(x, y);
lastx = p.x;
lasty = p.y;
startx = p.x;
@@ -119,12 +119,12 @@ public class MapView extends Element implements GestureListener{
drawing = false;
GridPoint2 p = project(x, y);
Point2 p = project(x, y);
if(tool == EditorTool.line){
ui.editor.resetSaved();
Array<GridPoint2> points = br.line(startx, starty, p.x, p.y);
for(GridPoint2 point : points){
Array<Point2> points = br.line(startx, starty, p.x, p.y);
for(Point2 point : points){
editor.draw(point.x, point.y);
}
updated = true;
@@ -149,12 +149,12 @@ public class MapView extends Element implements GestureListener{
mousex = x;
mousey = y;
GridPoint2 p = project(x, y);
Point2 p = project(x, y);
if(drawing && tool.draggable){
ui.editor.resetSaved();
Array<GridPoint2> points = br.line(lastx, lasty, p.x, p.y);
for(GridPoint2 point : points){
Array<Point2> points = br.line(lastx, lasty, p.x, p.y);
for(Point2 point : points){
tool.touched(editor, point.x, point.y);
}
updated = true;
@@ -231,7 +231,7 @@ public class MapView extends Element implements GestureListener{
zoom = Mathf.clamp(zoom, 0.2f, 12f);
}
private GridPoint2 project(float x, float y){
private Point2 project(float x, float y){
float ratio = 1f / ((float) editor.getMap().width() / editor.getMap().height());
float size = Math.min(width, height);
float sclwidth = size * zoom;
@@ -307,13 +307,13 @@ public class MapView extends Element implements GestureListener{
}
if(tool.edit && (!mobile || drawing)){
GridPoint2 p = project(mousex, mousey);
Point2 p = project(mousex, mousey);
Vector2 v = unproject(p.x, p.y).add(x, y);
Lines.poly(brushPolygons[index], v.x, v.y, scaling);
}
}else{
if((tool.edit || tool == EditorTool.line) && (!mobile || drawing)){
GridPoint2 p = project(mousex, mousey);
Point2 p = project(mousex, mousey);
Vector2 v = unproject(p.x, p.y).add(x, y);
float offset = (editor.getDrawBlock().size % 2 == 0 ? scaling / 2f : 0f);
Lines.square(

26
core/src/io/anuke/mindustry/entities/effect/Fire.java
View File

@@ -1,10 +1,18 @@
package io.anuke.mindustry.entities.effect;
import io.anuke.arc.math.GridPoint2;
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.arc.collection.IntMap;
import io.anuke.arc.entities.Effects;
import io.anuke.arc.entities.EntityGroup;
import io.anuke.arc.entities.impl.TimedEntity;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.math.geom.Geometry;
import io.anuke.arc.math.geom.Point2
import io.anuke.arc.util.Structs;
import io.anuke.arc.util.Time;
import io.anuke.arc.util.pooling.Pool.Poolable;
import io.anuke.arc.util.pooling.Pools;
import io.anuke.mindustry.content.StatusEffects;
import io.anuke.mindustry.content.bullets.TurretBullets;
import io.anuke.mindustry.content.fx.EnvironmentFx;
@@ -16,14 +24,6 @@ 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.entities.Effects;
import io.anuke.arc.util.Time;
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.math.Mathf;
import io.anuke.arc.util.Pooling;
import java.io.DataInput;
import java.io.DataOutput;
@@ -131,11 +131,11 @@ public class Fire extends TimedEntity implements SaveTrait, SyncTrait, Poolable{
}
if(flammability > 1f && Mathf.chance(spreadChance * Time.delta() * Mathf.clamp(flammability / 5f, 0.3f, 2f))){
GridPoint2 p = Mathf.select(Geometry.d4);
Point2 p = Geometry.d4[Mathf.random(3)];
Tile other = world.tile(tile.x + p.x, tile.y + p.y);
create(other);
if(Mathf.chance(fireballChance * Time.delta() * Mathf.clamp(flammability / 10.0))){
if(Mathf.chance(fireballChance * Time.delta() * Mathf.clamp(flammability / 10f))){
Call.createBullet(TurretBullets.fireball, x, y, Mathf.random(360f));
}
}

2
core/src/io/anuke/mindustry/entities/traits/BuilderTrait.java
View File

@@ -354,7 +354,7 @@ public interface BuilderTrait extends Entity{
Draw.color(Color.LIGHT_GRAY, Color.WHITE, 1f - flashScl + Mathf.absin(Time.time(), 0.5f, flashScl));
//TODO better laser drawing functions
Shapes.laser("minelaser", "minelaser-end", px, py, ex, ey);
//Shapes.laser("minelaser", "minelaser-end", px, py, ex, ey);
if(unit instanceof Player && ((Player) unit).isLocal){
Lines.stroke(1f, Palette.accent);

6
core/src/io/anuke/mindustry/entities/units/GroundUnit.java
View File

@@ -1,7 +1,7 @@
package io.anuke.mindustry.entities.units;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.math.geom.Vector2;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.entities.Predict;
import io.anuke.mindustry.entities.TileEntity;
@@ -14,9 +14,9 @@ import io.anuke.mindustry.world.Tile;
import io.anuke.mindustry.world.blocks.Floor;
import io.anuke.arc.util.Time;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.util.Angles;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Vector2;
import io.anuke.arc.math.geom.Vector2;
import java.io.DataInput;
import java.io.DataOutput;

2
core/src/io/anuke/mindustry/game/Difficulty.java
View File

@@ -1,6 +1,6 @@
package io.anuke.mindustry.game;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.Core;
public enum Difficulty{
training(3f, 3f),

6
core/src/io/anuke/mindustry/game/EventType.java
View File

@@ -11,6 +11,7 @@ public class EventType{
}
/**Called when the game is first loaded.*/
public static class GameLoadEvent implements Event{
}
@@ -35,10 +36,7 @@ public class EventType{
}
}
/**
* This event is called from the logic thread.
* DO NOT INITIALIZE GRAPHICS HERE.
*/
/**Called when a game begins and the world is loaded.*/
public static class WorldLoadEvent implements Event{
}

2
core/src/io/anuke/mindustry/game/GameMode.java
View File

@@ -1,6 +1,6 @@
package io.anuke.mindustry.game;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.Core;
public enum GameMode{
waves,

76
core/src/io/anuke/mindustry/graphics/BlockRenderer.java
View File

@@ -1,23 +1,23 @@
package io.anuke.mindustry.graphics;
import io.anuke.arc.Core;
import io.anuke.arc.Events;
import io.anuke.arc.collection.Array;
import io.anuke.arc.util.IntSet;
import io.anuke.arc.util.Sort;
import io.anuke.arc.collection.IntSet;
import io.anuke.arc.collection.Sort;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.glutils.FrameBuffer;
import io.anuke.arc.math.Mathf;
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.EventType.WorldLoadEvent;
import io.anuke.mindustry.game.Team;
import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.Tile;
import io.anuke.arc.Core;
import io.anuke.arc.Events;
import io.anuke.arc.Graphics;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Surface;
import io.anuke.arc.math.Mathf;
import static io.anuke.mindustry.Vars.*;
import static io.anuke.arc.core.Core.camera;
import static io.anuke.arc.Core.camera;
import static io.anuke.mindustry.Vars.tilesize;
import static io.anuke.mindustry.Vars.world;
public class BlockRenderer{
private final static int initialRequests = 32 * 32;
@@ -31,7 +31,7 @@ public class BlockRenderer{
private Layer lastLayer;
private int requestidx = 0;
private int iterateidx = 0;
private Surface shadows = Graphics.createSurface().setSize(2, 2);
private FrameBuffer shadows = new FrameBuffer(1, 1);
public BlockRenderer(){
floorRenderer = new FloorRenderer();
@@ -40,30 +40,28 @@ public class BlockRenderer{
requests.set(i, new BlockRequest());
}
Events.on(WorldLoadGraphicsEvent.class, event -> {
Events.on(WorldLoadEvent.class, event -> {
lastCamY = lastCamX = -99; //invalidate camera position so blocks get updated
});
Events.on(TileChangeEvent.class, event -> {
threads.runGraphics(() -> {
int avgx = Mathf.scl(camera.position.x, tilesize);
int avgy = Mathf.scl(camera.position.y, tilesize);
int rangex = (int) (camera.width / tilesize / 2) + 2;
int rangey = (int) (camera.height / tilesize / 2) + 2;
int avgx = (int)(camera.position.x / tilesize);
int avgy = (int)(camera.position. y/ tilesize);
int rangex = (int) (camera.width / tilesize / 2) + 2;
int rangey = (int) (camera.height / tilesize / 2) + 2;
if(Math.abs(avgx - event.tile.x) <= rangex && Math.abs(avgy - event.tile.y) <= rangey){
lastCamY = lastCamX = -99; //invalidate camera position so blocks get updated
}
});
if(Math.abs(avgx - event.tile.x) <= rangex && Math.abs(avgy - event.tile.y) <= rangey){
lastCamY = lastCamX = -99; //invalidate camera position so blocks get updated
}
});
}
public void drawShadows(){
Draw.color(0, 0, 0, 0.15f);
Draw.rect(shadows.texture(),
Core.camera.position.x - Core.camera.position.x % tilesize,
Core.camera.position.y - Core.camera.position.y % tilesize,
shadows.width(), -shadows.height());
Draw.rect().tex(shadows.getTexture()).center(
camera.position.x - camera.position.x % tilesize,
camera.position.y - camera.position.y % tilesize,
shadows.getWidth(), -shadows.getHeight());
Draw.color();
}
@@ -76,8 +74,8 @@ public class BlockRenderer{
iterateidx = 0;
lastLayer = null;
int avgx = Mathf.scl(camera.position.x, tilesize);
int avgy = Mathf.scl(camera.position.y, tilesize);
int avgx = (int)(camera.position.x / tilesize);
int avgy = (int)(camera.position.y / tilesize);
int rangex = (int) (camera.width / tilesize / 2) + 2;
int rangey = (int) (camera.height / tilesize / 2) + 2;
@@ -91,12 +89,16 @@ public class BlockRenderer{
teamChecks.clear();
requestidx = 0;
Graphics.end();
if(shadows.width() != shadowW || shadows.height() != shadowH){
shadows.setSize(shadowW, shadowH);
Draw.flush();
Core.graphics.batch().getProjection()
.setOrtho(Mathf.round(camera.position.x, tilesize)-shadowW/2f, Mathf.round(camera.position.y, tilesize)-shadowH/2f,
shadowW, shadowH);
if(shadows.getWidth() != shadowW || shadows.getHeight() != shadowH){
shadows.resize(shadowW, shadowH);
}
Core.batch.getProjectionMatrix().setToOrtho2D(Mathf.round(Core.camera.position.x, tilesize)-shadowW/2f, Mathf.round(Core.camera.position.y, tilesize)-shadowH/2f, shadowW, shadowH);
Graphics.surface(shadows);
shadows.begin();
int minx = Math.max(avgx - rangex - expandr, 0);
int miny = Math.max(avgy - rangey - expandr, 0);
@@ -136,10 +138,10 @@ public class BlockRenderer{
}
}
Graphics.surface();
Graphics.end();
Core.batch.setProjectionMatrix(camera.combined);
Graphics.begin();
shadows.end();
Draw.flush();
Draw.projection(camera.projection());
Sort.instance().sort(requests.items, 0, requestidx);

64
core/src/io/anuke/mindustry/graphics/CacheLayer.java
View File

@@ -1,57 +1,13 @@
package io.anuke.mindustry.graphics;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.Core;
import io.anuke.arc.Graphics;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Shader;
import static io.anuke.mindustry.Vars.renderer;
public enum CacheLayer{
water{
@Override
public void begin(){
beginShader();
}
@Override
public void end(){
endShader(Shaders.water);
}
},
lava{
@Override
public void begin(){
beginShader();
}
@Override
public void end(){
endShader(Shaders.lava);
}
},
oil{
@Override
public void begin(){
beginShader();
}
@Override
public void end(){
endShader(Shaders.oil);
}
},
space{
@Override
public void begin(){
beginShader();
}
@Override
public void end(){
endShader(Shaders.space);
}
},
normal;
@@ -64,25 +20,9 @@ public enum CacheLayer{
}
protected void beginShader(){
//renderer.getBlocks().endFloor();
renderer.effectSurface.getBuffer().begin();
Graphics.clear(Color.CLEAR);
//renderer.getBlocks().beginFloor();
}
public void endShader(Shader shader){
renderer.blocks.endFloor();
//renderer.effectSurface.getBuffer().end();
renderer.pixelSurface.getBuffer().begin();
Graphics.shader(shader);
Graphics.begin();
Draw.rect(renderer.effectSurface.texture(), Core.camera.position.x, Core.camera.position.y,
Core.camera.width , -Core.camera.height );
Graphics.end();
Graphics.shader();
renderer.blocks.beginFloor();
public void endShader(){
}
}

27
core/src/io/anuke/mindustry/graphics/FloorRenderer.java
View File

@@ -1,26 +1,23 @@
package io.anuke.mindustry.graphics;
import io.anuke.arc.Core;
import io.anuke.arc.Events;
import io.anuke.arc.Graphics;
import io.anuke.arc.collection.IntArray;
import io.anuke.arc.collection.IntSet;
import io.anuke.arc.collection.IntSet.IntSetIterator;
import io.anuke.arc.collection.ObjectSet;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.GL20;
import io.anuke.arc.graphics.OrthographicCamera;
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.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Structs;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.maps.Sector;
import io.anuke.mindustry.world.Tile;
import io.anuke.mindustry.world.blocks.Floor;
import io.anuke.arc.Events;
import io.anuke.arc.Graphics;
import io.anuke.arc.util.Time;
import io.anuke.arc.graphics.CacheBatch;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.util.Log;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Structs;
import java.util.Arrays;

30
core/src/io/anuke/mindustry/graphics/FogRenderer.java
View File

@@ -1,23 +1,23 @@
package io.anuke.mindustry.graphics;
import io.anuke.arc.Core;
import io.anuke.arc.Events;
import io.anuke.arc.Graphics;
import io.anuke.arc.collection.Array;
import io.anuke.arc.entities.EntityDraw;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.GL20;
import io.anuke.arc.graphics.Pixmap.Format;
import io.anuke.arc.graphics.Texture;
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.graphics.glutils.FrameBuffer;
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.game.EventType.WorldLoadEvent;
import io.anuke.mindustry.world.Tile;
import io.anuke.arc.Events;
import io.anuke.arc.Graphics;
import io.anuke.arc.entities.EntityDraw;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import java.nio.ByteBuffer;
@@ -33,7 +33,7 @@ public class FogRenderer implements Disposable{
private boolean dirty;
public FogRenderer(){
Events.on(WorldLoadGraphicsEvent.class, event -> {
Events.on(WorldLoadEvent.class, event -> {
dispose();
shadowPadding = -1;
@@ -43,7 +43,7 @@ public class FogRenderer implements Disposable{
//clear buffer to black
buffer.begin();
Graphics.clear(0, 0, 0, 1f);
Core.graphics.clear(0, 0, 0, 1f);
buffer.end();
for(int x = 0; x < world.width(); x++){
@@ -59,11 +59,11 @@ public class FogRenderer implements Disposable{
dirty = true;
});
Events.on(TileChangeEvent.class, event -> threads.runGraphics(() -> {
Events.on(TileChangeEvent.class, event -> {
if(event.tile.getTeam() == players[0].getTeam() && event.tile.block().synthetic() && event.tile.block().viewRange > 0){
changeQueue.add(event.tile);
}
}));
});
}
public void writeFog(){
@@ -146,11 +146,11 @@ public class FogRenderer implements Disposable{
Graphics.endClip();
region.setTexture(buffer.getColorBufferTexture());
region.setTexture(buffer.getTexture());
region.setRegion(u, v2, u2, v);
Core.batch.setProjectionMatrix(Core.camera.combined);
Graphics.shader(Shaders.fog);
Draw.shader(Shaders.fog);
renderer.pixelSurface.getBuffer().begin();
Graphics.begin();
@@ -158,7 +158,7 @@ public class FogRenderer implements Disposable{
Graphics.end();
renderer.pixelSurface.getBuffer().end();
Graphics.shader();
Draw.shader();
Graphics.setScreen();
Core.batch.draw(renderer.pixelSurface.texture(), 0, Core.graphics.getHeight(), Core.graphics.getWidth(), -Core.graphics.getHeight());
@@ -166,7 +166,7 @@ public class FogRenderer implements Disposable{
}
public Texture getTexture(){
return buffer.getColorBufferTexture();
return buffer.getTexture();
}
@Override

24
core/src/io/anuke/mindustry/graphics/Layer.java
View File

@@ -1,28 +1,16 @@
package io.anuke.mindustry.graphics;
public enum Layer{
/**
* Base block layer.
*/
/**Base block layer.*/
block,
/**
* for placement
*/
/**for placement*/
placement,
/**
* First overlay. Stuff like conveyor items.
*/
/**First overlay. Stuff like conveyor items.*/
overlay,
/**
* "High" blocks, like turrets.
*/
/**"High" blocks, like turrets.*/
turret,
/**
* Power lasers.
*/
/**Power lasers.*/
power,
/**
* Extra lasers, like healing turrets.
*/
/**Extra lasers, like healing turrets.*/
laser
}

34
core/src/io/anuke/mindustry/graphics/MinimapRenderer.java
View File

@@ -1,40 +1,39 @@
package io.anuke.mindustry.graphics;
import io.anuke.arc.Core;
import io.anuke.arc.Events;
import io.anuke.arc.collection.Array;
import io.anuke.arc.graphics.Pixmap;
import io.anuke.arc.graphics.Pixmap.Format;
import io.anuke.arc.graphics.Pixmaps;
import io.anuke.arc.graphics.Texture;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.ScissorStack;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.math.geom.Rectangle;
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.game.EventType.WorldLoadEvent;
import io.anuke.mindustry.world.ColorMapper;
import io.anuke.mindustry.world.Tile;
import io.anuke.arc.Events;
import io.anuke.arc.Graphics;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Pixmaps;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.ThreadArray;
import static io.anuke.mindustry.Vars.tilesize;
import static io.anuke.mindustry.Vars.world;
public class MinimapRenderer implements Disposable{
private static final int baseSize = 16;
private final Array<Unit> units = new ThreadArray<>();
private final Array<Unit> units = new Array<>();
private Pixmap pixmap;
private Texture texture;
private TextureRegion region;
private Rectangle rect = new Rectangle();
private Rectangle rect = new Rectangle(), scissor = new Rectangle();
private int zoom = 4;
public MinimapRenderer(){
Events.on(WorldLoadGraphicsEvent.class, event -> {
Events.on(WorldLoadEvent.class, event -> {
reset();
updateAll();
});
@@ -47,7 +46,7 @@ public class MinimapRenderer implements Disposable{
return texture;
}
public void zoomBy(int amount){
public void zoomBy(float amount){
zoom += amount;
zoom = Mathf.clamp(zoom, 1, Math.min(world.width(), world.height()) / baseSize / 2);
}
@@ -73,18 +72,19 @@ public class MinimapRenderer implements Disposable{
dx = Mathf.clamp(dx, sz, world.width() - sz);
dy = Mathf.clamp(dy, sz, world.height() - sz);
if(!ScissorStack.pushScissors(scissor.set(x, y, w, h))){
return;
}
rect.set((dx - sz) * tilesize, (dy - sz) * tilesize, sz * 2 * tilesize, sz * 2 * tilesize);
Graphics.beginClip(x, y, w, h);
for(Unit unit : units){
float rx = (unit.x - rect.x) / rect.width * w, ry = (unit.y - rect.y) / rect.width * h;
Draw.color(unit.getTeam().color);
Draw.crect(Draw.getBlankRegion(), x + rx, y + ry, w / (sz * 2), h / (sz * 2));
Draw.rect().tex(Core.atlas.white()).set(x + rx, y + ry, w / (sz * 2), h / (sz * 2));
}
Draw.color();
Graphics.endClip();
}
public TextureRegion getRegion(){
@@ -98,7 +98,7 @@ public class MinimapRenderer implements Disposable{
float invTexWidth = 1f / texture.getWidth();
float invTexHeight = 1f / texture.getHeight();
float x = dx - sz, y = world.height() - dy - sz, width = sz * 2, height = sz * 2;
region.setRegion(x * invTexWidth, y * invTexHeight, (x + width) * invTexWidth, (y + height) * invTexHeight);
region.set(x * invTexWidth, y * invTexHeight, (x + width) * invTexWidth, (y + height) * invTexHeight);
return region;
}

131
core/src/io/anuke/mindustry/graphics/OverlayRenderer.java
View File

@@ -1,27 +1,19 @@
package io.anuke.mindustry.graphics;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.math.MathUtils;
import io.anuke.arc.math.geom.Rectangle;
import io.anuke.arc.math.Vector2;
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;
import io.anuke.mindustry.game.Team;
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;
import io.anuke.arc.Graphics;
import io.anuke.arc.Settings;
import io.anuke.arc.util.Time;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.graphics.g2d.Lines;
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.Time;
import io.anuke.arc.util.Tmp;
import io.anuke.mindustry.content.blocks.Blocks;
import io.anuke.mindustry.entities.Player;
import io.anuke.mindustry.game.Team;
import io.anuke.mindustry.input.InputHandler;
import io.anuke.mindustry.world.Tile;
import static io.anuke.mindustry.Vars.*;
@@ -41,11 +33,12 @@ public class OverlayRenderer{
if(!input.isDrawing() || player.isDead()) continue;
Shaders.outline.color.set(Palette.accent);
Graphics.beginShaders(Shaders.outline);
//TODO draw outlined version
//Graphics.beginShaders(Shaders.outline);
input.drawOutlined();
Graphics.endShaders();
//Graphics.endShaders();
}
}
@@ -58,8 +51,7 @@ public class OverlayRenderer{
Tmp.v1.set(player.x, player.y).sub(Core.camera.position.x, Core.camera.position.y).setLength(indicatorLength);
Draw.color(player.getTeam().color);
Lines.stroke(2f);
Lines.stroke(2f, player.getTeam().color);
Lines.lineAngle(Core.camera.position.x + Tmp.v1.x, Core.camera.position.y + Tmp.v1.y, Tmp.v1.angle(), 4f);
Draw.reset();
}
@@ -107,76 +99,7 @@ public class OverlayRenderer{
if(tile != null && tile.block() != Blocks.air && tile.target().getTeam() == players[0].getTeam()){
Tile target = tile.target();
if(showBlockDebug && target.entity != null){
Draw.color(Color.RED);
Lines.crect(target.drawx(), target.drawy(), target.block().size * tilesize, target.block().size * tilesize);
Vector2 v = new Vector2();
Draw.tcolor(Color.YELLOW);
Draw.tscl(0.25f);
Array<Object> arr = target.block().getDebugInfo(target);
StringBuilder result = new StringBuilder();
for(int i = 0; i < arr.size / 2; i++){
result.append(arr.get(i * 2));
result.append(": ");
result.append(arr.get(i * 2 + 1));
result.append("\n");
}
Draw.textc(result.toString(), target.drawx(), target.drawy(), v);
Draw.color(0f, 0f, 0f, 0.5f);
Fill.rect(target.drawx(), target.drawy(), v.x, v.y);
Draw.textc(result.toString(), target.drawx(), target.drawy(), v);
Draw.tscl(1f);
Draw.reset();
}
Block block = target.block();
TileEntity entity = target.entity;
if(entity != null){
int[] values = {0, 0};
boolean[] doDraw = {false};
Runnable drawbars = () -> {
for(BlockBar bar : block.bars.list()){
float offset = Mathf.sign(bar.top) * (block.size / 2f * tilesize + 2f + (bar.top ? values[0] : values[1]));
float value = bar.value.get(target);
if(MathUtils.isEqual(value, -1f)) continue;
if(doDraw[0]){
drawBar(bar.type.color, target.drawx(), target.drawy() + offset, value);
}
if(bar.top)
values[0]++;
else
values[1]++;
}
};
drawbars.run();
if(values[0] > 0){
drawEncloser(target.drawx(), target.drawy() + block.size * tilesize / 2f + 2f, values[0]);
}
if(values[1] > 0){
drawEncloser(target.drawx(), target.drawy() - block.size * tilesize / 2f - 2f - values[1], values[1]);
}
doDraw[0] = true;
values[0] = 0;
values[1] = 1;
drawbars.run();
}
target.block().drawSelect(target);
}
}
@@ -198,32 +121,4 @@ public class OverlayRenderer{
}
}
}
void drawBar(Color color, float x, float y, float finion){
if(finion > 0.9f) finion = 1f; //fixes precision errors
finion = Mathf.clamp(finion);
if(finion > 0.001f) finion = Mathf.clamp(finion, 0.24f, 1f);
float len = 3;
float w = (int) (len * 2 * finion);
Draw.color(Color.BLACK);
Fill.crect(x - len, y, len * 2f, 1);
if(finion > 0){
Draw.color(color);
Fill.crect(x - len, y, Math.max(1, w), 1);
}
Draw.color();
}
void drawEncloser(float x, float y, float height){
float len = 4;
Draw.color(Palette.bar);
Fill.crect(x - len, y - 1, len * 2f, height + 2f);
Draw.color();
}
}

70
core/src/io/anuke/mindustry/graphics/Shaders.java
View File

@@ -3,11 +3,9 @@ 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;
import io.anuke.arc.util.Time;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Shader;
import io.anuke.arc.graphics.glutils.Shader;
import io.anuke.arc.scene.ui.layout.Unit;
import io.anuke.arc.util.Time;
import static io.anuke.mindustry.Vars.tilesize;
import static io.anuke.mindustry.Vars.world;
@@ -54,11 +52,11 @@ public class Shaders{
public void apply(){
time = time % 158;
shader.setUniformf("u_resolution", Core.graphics.getWidth(), Core.graphics.getHeight());
shader.setUniformi("u_time", (int)(time += Core.graphics.getDeltaTime() * 60f));
shader.setUniformf("u_uv", Draw.getBlankRegion().getU(), Draw.getBlankRegion().getV());
shader.setUniformf("u_scl", Unit.dp.scl(1f));
shader.setUniformf("u_uv2", Draw.getBlankRegion().getU2(), Draw.getBlankRegion().getV2());
setUniformf("u_resolution", Core.graphics.getWidth(), Core.graphics.getHeight());
setUniformi("u_time", (int)(time += Core.graphics.getDeltaTime() * 60f));
setUniformf("u_uv", Core.atlas.white().getU(), Core.atlas.white().getV());
setUniformf("u_scl", Unit.dp.scl(1f));
setUniformf("u_uv2", Core.atlas.white().getU2(), Core.atlas.white().getV2());
}
}
@@ -78,7 +76,7 @@ public class Shaders{
@Override
public void apply(){
super.apply();
shader.setUniformf("u_color", color);
setUniformf("u_color", color);
}
}
@@ -91,7 +89,7 @@ public class Shaders{
@Override
public void apply(){
super.apply();
shader.setUniformf("u_center", world.width() * tilesize / 2f, world.height() * tilesize / 2f);
setUniformf("u_center", world.width() * tilesize / 2f, world.height() * tilesize / 2f);
}
}
@@ -106,12 +104,12 @@ public class Shaders{
@Override
public void apply(){
shader.setUniformf("u_time", time);
shader.setUniformf("u_color", color);
shader.setUniformf("u_progress", progress);
shader.setUniformf("u_uv", region.getU(), region.getV());
shader.setUniformf("u_uv2", region.getU2(), region.getV2());
shader.setUniformf("u_texsize", region.getTexture().getWidth(), region.getTexture().getHeight());
setUniformf("u_time", time);
setUniformf("u_color", color);
setUniformf("u_progress", progress);
setUniformf("u_uv", region.getU(), region.getV());
setUniformf("u_uv2", region.getU2(), region.getV2());
setUniformf("u_texsize", region.getTexture().getWidth(), region.getTexture().getHeight());
}
}
@@ -124,8 +122,8 @@ public class Shaders{
@Override
public void apply(){
shader.setUniformf("u_color", color);
shader.setUniformf("u_texsize", region.getTexture().getWidth(), region.getTexture().getHeight());
setUniformf("u_color", color);
setUniformf("u_texsize", region.getTexture().getWidth(), region.getTexture().getHeight());
}
}
@@ -139,12 +137,12 @@ public class Shaders{
@Override
public void apply(){
shader.setUniformf("u_progress", progress);
shader.setUniformf("u_color", color);
shader.setUniformf("u_uv", region.getU(), region.getV());
shader.setUniformf("u_uv2", region.getU2(), region.getV2());
shader.setUniformf("u_time", Time.time());
shader.setUniformf("u_texsize", region.getTexture().getWidth(), region.getTexture().getHeight());
setUniformf("u_progress", progress);
setUniformf("u_color", color);
setUniformf("u_uv", region.getU(), region.getV());
setUniformf("u_uv2", region.getU2(), region.getV2());
setUniformf("u_time", Time.time());
setUniformf("u_texsize", region.getTexture().getWidth(), region.getTexture().getHeight());
}
}
@@ -157,10 +155,10 @@ public class Shaders{
@Override
public void apply(){
shader.setUniformf("u_color", color);
shader.setUniformf("u_uv", region.getU(), region.getV());
shader.setUniformf("u_uv2", region.getU2(), region.getV2());
shader.setUniformf("u_texsize", region.getTexture().getWidth(), region.getTexture().getHeight());
setUniformf("u_color", color);
setUniformf("u_uv", region.getU(), region.getV());
setUniformf("u_uv2", region.getU2(), region.getV2());
setUniformf("u_texsize", region.getTexture().getWidth(), region.getTexture().getHeight());
}
}
@@ -172,12 +170,12 @@ public class Shaders{
@Override
public void apply(){
shader.setUniformf("u_dp", Unit.dp.scl(1f));
shader.setUniformf("u_time", Time.time() / Unit.dp.scl(1f));
shader.setUniformf("u_offset",
setUniformf("u_dp", Unit.dp.scl(1f));
setUniformf("u_time", Time.time() / Unit.dp.scl(1f));
setUniformf("u_offset",
Core.camera.position.x - Core.camera.width / 2 ,
Core.camera.position.y - Core.camera.height / 2 );
shader.setUniformf("u_texsize", Core.camera.width ,
setUniformf("u_texsize", Core.camera.width ,
Core.camera.height );
}
}
@@ -190,12 +188,12 @@ public class Shaders{
@Override
public void apply(){
shader.setUniformf("camerapos",
setUniformf("camerapos",
Core.camera.position.x - Core.camera.width / 2 ,
Core.camera.position.y - Core.camera.height / 2 );
shader.setUniformf("screensize", Core.camera.width,
setUniformf("screensize", Core.camera.width,
Core.camera.height );
shader.setUniformf("time", Time.time());
setUniformf("time", Time.time());
}
}
}

8
core/src/io/anuke/mindustry/graphics/Trail.java
View File

@@ -1,16 +1,16 @@
package io.anuke.mindustry.graphics;
import io.anuke.arc.collection.FloatArray;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.util.FloatArray;
import io.anuke.arc.util.Time;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Time;
/**
* Class that renders a colored trail.
* TODO remove / recode
*/
public class Trail{
private final static float maxJump = 15f;

33
core/src/io/anuke/mindustry/input/DesktopInput.java
View File

@@ -1,14 +1,12 @@
package io.anuke.mindustry.input;
import io.anuke.arc.Core;
import io.anuke.arc.Graphics;
import io.anuke.arc.KeyBinds;
import io.anuke.arc.Graphics.Cursor;
import io.anuke.arc.Graphics.Cursor.SystemCursor;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.input.InputDevice.DeviceType;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.scene.ui.layout.Unit;
import io.anuke.mindustry.content.blocks.Blocks;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.entities.Player;
@@ -20,7 +18,6 @@ import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.Tile;
import static io.anuke.mindustry.Vars.*;
import static io.anuke.mindustry.input.CursorType.*;
import static io.anuke.mindustry.input.PlaceMode.*;
public class DesktopInput extends InputHandler{
@@ -29,7 +26,7 @@ public class DesktopInput extends InputHandler{
private float controlx, controly;
private boolean controlling;
/**Current cursor type.*/
private CursorType cursorType = normal;
private Cursor cursorType = SystemCursor.arrow;
/**Position where the player started dragging a line.*/
private int selectX, selectY;
@@ -52,7 +49,7 @@ public class DesktopInput extends InputHandler{
for(TextureRegion region : regions){
Draw.rect(region, x * tilesize + block.offset(), y * tilesize + block.offset(),
region.getWidth() * selectScale, region.getHeight() * selectScale, block.rotate ? rotation * 90 : 0);
region.getWidth() * selectScale, region.getHeight() * selectScale).rot(block.rotate ? rotation * 90 : 0);
}
}else{
Draw.color(Palette.removeBack);
@@ -82,8 +79,8 @@ public class DesktopInput extends InputHandler{
if(i + recipe.result.size > result.getLength() && recipe.result.rotate){
Draw.color(!validPlace(x, y, recipe.result, result.rotation) ? Palette.remove : Palette.placeRotate);
Draw.grect("place-arrow", x * tilesize + recipe.result.offset(),
y * tilesize + recipe.result.offset(), result.rotation * 90 - 90);
Draw.rect("place-arrow", x * tilesize + recipe.result.offset(),
y * tilesize + recipe.result.offset()).origin(x * tilesize + recipe.result.offset()/2f, 0f).rot(result.rotation * 90 - 90);
}
drawPlace(x, y, recipe.result, result.rotation);
@@ -114,8 +111,8 @@ public class DesktopInput extends InputHandler{
}else if(isPlacing()){
if(recipe.result.rotate){
Draw.color(!validPlace(cursorX, cursorY, recipe.result, rotation) ? Palette.remove : Palette.placeRotate);
Draw.grect("place-arrow", cursorX * tilesize + recipe.result.offset(),
cursorY * tilesize + recipe.result.offset(), rotation * 90 - 90);
Draw.rect("place-arrow", cursorX * tilesize + recipe.result.offset(),
cursorY * tilesize + recipe.result.offset()).origin(cursorX * tilesize + recipe.result.offset()/2f, 0).rot(rotation * 90 - 90);
}
drawPlace(cursorX, cursorY, recipe.result, rotation);
recipe.result.drawPlace(cursorX, cursorY, rotation, validPlace(cursorX, cursorY, recipe.result, rotation));
@@ -157,7 +154,7 @@ public class DesktopInput extends InputHandler{
}
if(isPlacing()){
cursorType = hand;
cursorType = SystemCursor.hand;
selectScale = Mathf.lerpDelta(selectScale, 1f, 0.2f);
}else{
selectScale = 0f;
@@ -168,30 +165,30 @@ public class DesktopInput extends InputHandler{
Tile cursor = tileAt(Core.input.mouseX(), Core.input.mouseY());
if(player.isDead()){
cursorType = normal;
cursorType = SystemCursor.arrow;
}else if(cursor != null){
cursor = cursor.target();
cursorType = cursor.block().getCursor(cursor);
if(isPlacing()){
cursorType = hand;
cursorType = SystemCursor.hand;
}
if(!isPlacing() && canMine(cursor)){
cursorType = drill;
cursorType = ui.drillCursor;
}
if(canTapPlayer(Core.input.mouseWorld().x, Core.input.mouseWorld().y)){
cursorType = unload;
cursorType = ui.unloadCursor;
}
}
if(!Core.scene.hasMouse()){
cursorType.set();
Core.graphics.cursor(cursorType);
}
cursorType = normal;
cursorType = SystemCursor.arrow;
}
void pollInput(){

79
core/src/io/anuke/mindustry/input/MobileInput.java
View File

@@ -1,16 +1,23 @@
package io.anuke.mindustry.input;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.arc.collection.ObjectSet;
import io.anuke.arc.entities.Effects;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.input.GestureDetector;
import io.anuke.arc.input.GestureDetector.GestureListener;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.math.Interpolation;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.math.geom.Rectangle;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.math.geom.Vector2;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Align;
import io.anuke.arc.collection.Array;
import io.anuke.arc.collection.ObjectSet;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.content.blocks.Blocks;
import io.anuke.mindustry.content.fx.Fx;
import io.anuke.mindustry.core.GameState.State;
@@ -27,11 +34,6 @@ 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.*;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.math.Mathf;
import static io.anuke.mindustry.Vars.*;
import static io.anuke.mindustry.input.PlaceMode.*;
@@ -176,8 +178,8 @@ public class MobileInput extends InputHandler implements GestureListener{
for(TextureRegion region : regions){
Draw.rect(region, tile.worldx() + offset, tile.worldy() + offset,
region.getWidth() * request.scale, region.getHeight() * request.scale,
request.recipe.result.rotate ? request.rotation * 90 : 0);
region.getWidth() * request.scale, region.getHeight() * request.scale)
.rot(request.recipe.result.rotate ? request.rotation * 90 : 0);
}
}else{
float rad = (tile.block().size * tilesize / 2f - 1) * request.scale;
@@ -198,7 +200,7 @@ public class MobileInput extends InputHandler implements GestureListener{
dialog.content().add("$text." + type).growX().wrap();
dialog.content().row();
dialog.content().addCheck("$text.showagain", false, checked -> {
Core.settings.putBool(type, checked);
Core.settings.put(type, checked);
Core.settings.save();
}).growX().left().get().left();
dialog.show();
@@ -277,7 +279,7 @@ public class MobileInput extends InputHandler implements GestureListener{
Lines.stroke(1f);
Shaders.mix.color.set(Palette.accent);
Graphics.shader(Shaders.mix);
Draw.shader(Shaders.mix);
//draw removals
for(PlaceRequest request : removals){
@@ -315,7 +317,7 @@ public class MobileInput extends InputHandler implements GestureListener{
}
}
Graphics.shader();
Draw.shader();
Draw.color(Palette.accent);
@@ -334,8 +336,8 @@ public class MobileInput extends InputHandler implements GestureListener{
//go through each cell and draw the block to place if valid
for(int i = 0; i <= result.getLength(); i += recipe.result.size){
int x = lineStartX + i * Mathf.sign(tileX - lineStartX) * Mathf.bool(result.isX());
int y = lineStartY + i * Mathf.sign(tileY - lineStartY) * Mathf.bool(!result.isX());
int x = lineStartX + i * Mathf.sign(tileX - lineStartX) * Mathf.num(result.isX());
int y = lineStartY + i * Mathf.sign(tileY - lineStartY) * Mathf.num(!result.isX());
if(!checkOverlapPlacement(x, y, recipe.result) && validPlace(x, y, recipe.result, result.rotation)){
Draw.color();
@@ -344,7 +346,8 @@ public class MobileInput extends InputHandler implements GestureListener{
for(TextureRegion region : regions){
Draw.rect(region, x * tilesize + recipe.result.offset(), y * tilesize + recipe.result.offset(),
region.getWidth() * lineScale, region.getHeight() * lineScale, recipe.result.rotate ? result.rotation * 90 : 0);
region.getWidth() * lineScale, region.getHeight() * lineScale)
.rot(recipe.result.rotate ? result.rotation * 90 : 0);
}
}else{
Draw.color(Palette.removeBack);
@@ -409,7 +412,7 @@ public class MobileInput extends InputHandler implements GestureListener{
//region input events
@Override
public boolean touchDown(int screenX, int screenY, int pointer, int button){
public boolean touchDown(int screenX, int screenY, int pointer, KeyCode button){
if(state.is(State.menu) || player.isDead()) return false;
//get tile on cursor
@@ -418,7 +421,7 @@ public class MobileInput extends InputHandler implements GestureListener{
float worldx = Core.input.mouseWorld(screenX, screenY).x, worldy = Core.input.mouseWorld(screenX, screenY).y;
//ignore off-screen taps
if(cursor == null || ui.hasMouse(screenX, screenY)) return false;
if(cursor == null || Core.scene.hasMouse(screenX, screenY)) return false;
//only begin selecting if the tapped block is a request
selecting = hasRequest(cursor) && isPlacing() && mode == placing;
@@ -432,7 +435,7 @@ public class MobileInput extends InputHandler implements GestureListener{
}
@Override
public boolean touchUp(int screenX, int screenY, int pointer, int button){
public boolean touchUp(int screenX, int screenY, int pointer, KeyCode button){
//place down a line if in line mode
if(lineMode){
@@ -448,8 +451,8 @@ public class MobileInput extends InputHandler implements GestureListener{
//place blocks on line
for(int i = 0; i <= result.getLength(); i += recipe.result.size){
int x = lineStartX + i * Mathf.sign(tileX - lineStartX) * Mathf.bool(result.isX());
int y = lineStartY + i * Mathf.sign(tileY - lineStartY) * Mathf.bool(!result.isX());
int x = lineStartX + i * Mathf.sign(tileX - lineStartX) * Mathf.num(result.isX());
int y = lineStartY + i * Mathf.sign(tileY - lineStartY) * Mathf.num(!result.isX());
if(!checkOverlapPlacement(x, y, recipe.result) && validPlace(x, y, recipe.result, result.rotation)){
PlaceRequest request = new PlaceRequest(x * tilesize + recipe.result.offset(), y * tilesize + recipe.result.offset(), recipe, result.rotation);
@@ -505,7 +508,7 @@ public class MobileInput extends InputHandler implements GestureListener{
Tile cursor = tileAt(x, y);
//ignore off-screen taps
if(cursor == null || ui.hasMouse(x, y)) return false;
if(cursor == null || Core.scene.hasMouse(x, y)) return false;
//remove request if it's there
//long pressing enables line mode otherwise
@@ -523,7 +526,7 @@ public class MobileInput extends InputHandler implements GestureListener{
}
@Override
public boolean tap(float x, float y, int count, int button){
public boolean tap(float x, float y, int count, KeyCode button){
if(state.is(State.menu) || lineMode) return false;
float worldx = Core.input.mouseWorld(x, y).x, worldy = Core.input.mouseWorld(x, y).y;
@@ -532,7 +535,7 @@ public class MobileInput extends InputHandler implements GestureListener{
Tile cursor = tileAt(x, y);
//ignore off-screen taps
if(cursor == null || ui.hasMouse(x, y)) return false;
if(cursor == null || Core.scene.hasMouse(x, y)) return false;
checkTargets(worldx, worldy);
@@ -616,7 +619,7 @@ public class MobileInput extends InputHandler implements GestureListener{
//When in line mode, pan when near screen edges automatically
if(Core.input.isTouched(0) && lineMode){
float screenX = Graphics.mouse().x, screenY = Graphics.mouse().y;
float screenX = Core.input.mouseX(), screenY = Core.input.mouseY();
float panX = 0, panY = 0;
@@ -652,7 +655,7 @@ public class MobileInput extends InputHandler implements GestureListener{
PlaceRequest request = removals.get(i);
if(request.scale <= 0.0001f){
removals.removeIndex(i);
removals.removeAt(i);
i--;
}
}
@@ -667,33 +670,21 @@ public class MobileInput extends InputHandler implements GestureListener{
return false;
}
float dx = deltaX / Core.cameraScale, dy = deltaY / Core.cameraScale;
if(selecting){ //pan all requests
for(PlaceRequest req : selection){
if(req.remove) continue; //don't shift removal requests
req.x += dx;
req.y -= dy;
req.x += deltaX;
req.y -= deltaY;
}
}else{
//pan player
Core.camera.position.x -= dx;
Core.camera.position.y += dy;
Core.camera.position.x -= deltaX;
Core.camera.position.y += deltaY;
}
return false;
}
@Override
public boolean panStop(float x, float y, int pointer, int button){
return false;
}
@Override
public boolean pinch(Vector2 initialPointer1, Vector2 initialPointer2, Vector2 pointer1, Vector2 pointer2){
return false;
}
@Override
public boolean zoom(float initialDistance, float distance){
@@ -713,13 +704,13 @@ public class MobileInput extends InputHandler implements GestureListener{
}
@Override
public boolean touchDown(float x, float y, int pointer, int button){
public boolean touchDown(float x, float y, int pointer, KeyCode button){
canPan = !Core.scene.hasMouse();
return false;
}
@Override
public boolean fling(float velocityX, float velocityY, int button){
public boolean fling(float velocityX, float velocityY, KeyCode button){
return false;
}

3
core/src/io/anuke/mindustry/io/BundleLoader.java
View File

@@ -15,7 +15,7 @@ public class BundleLoader{
public static void load(){
Core.settings.defaults("locale", "default");
Core.settings.load(Vars.appName, headless ? "io.anuke.mindustry.server" : "io.anuke.mindustry");
Core.settings.load();
loadBundle();
}
@@ -37,7 +37,6 @@ public class BundleLoader{
}
private static void loadBundle(){
I18NBundle.setExceptionOnMissingKey(false);
try{
//try loading external bundle
FileHandle handle = Core.files.local("bundle");

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

@@ -1,10 +1,10 @@
package io.anuke.mindustry.io;
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;
import io.anuke.arc.util.serialization.JsonReader;
import io.anuke.arc.util.serialization.JsonValue;
import io.anuke.mindustry.net.Net;
import static io.anuke.mindustry.Vars.releasesURL;

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

@@ -1,10 +1,10 @@
package io.anuke.mindustry.io;
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;
import io.anuke.arc.util.serialization.JsonReader;
import io.anuke.arc.util.serialization.JsonValue;
import io.anuke.mindustry.net.Net;
import static io.anuke.mindustry.Vars.contributorsURL;

16
core/src/io/anuke/mindustry/io/MapIO.java
View File

@@ -1,11 +1,13 @@
package io.anuke.mindustry.io;
import io.anuke.arc.collection.IntIntMap;
import io.anuke.arc.collection.ObjectMap;
import io.anuke.arc.collection.ObjectMap.Entry;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.Pixmap;
import io.anuke.arc.graphics.Pixmap.Format;
import io.anuke.arc.util.IntIntMap;
import io.anuke.arc.collection.ObjectMap;
import io.anuke.arc.util.ObjectMap.Entry;
import io.anuke.arc.util.Pack;
import io.anuke.arc.util.Structs;
import io.anuke.mindustry.content.blocks.Blocks;
import io.anuke.mindustry.content.blocks.StorageBlocks;
import io.anuke.mindustry.game.Team;
@@ -19,8 +21,6 @@ import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.ColorMapper;
import io.anuke.mindustry.world.LegacyColorMapper;
import io.anuke.mindustry.world.LegacyColorMapper.LegacyBlock;
import io.anuke.arc.util.Bits;
import io.anuke.arc.util.Structs;
import java.io.DataInputStream;
import java.io.DataOutputStream;
@@ -90,14 +90,14 @@ public class MapIO{
if(Structs.inBounds(worldx, worldy, pixmap.getWidth(), pixmap.getHeight())){
data.write(worldx, worldy, DataPosition.wall, Blocks.blockpart.id);
data.write(worldx, worldy, DataPosition.rotationTeam, Bits.packByte((byte)0, (byte)Team.blue.ordinal()));
data.write(worldx, worldy, DataPosition.link, Bits.packByte((byte) (dx - 1 + 8), (byte) (dy - 1 + 8)));
data.write(worldx, worldy, DataPosition.rotationTeam, Pack.byteByte((byte)0, (byte)Team.blue.ordinal()));
data.write(worldx, worldy, DataPosition.link, Pack.byteByte((byte) (dx - 1 + 8), (byte) (dy - 1 + 8)));
}
}
}
data.write(x, y, DataPosition.wall, StorageBlocks.core.id);
data.write(x, y, DataPosition.rotationTeam, Bits.packByte((byte)0, (byte)Team.blue.ordinal()));
data.write(x, y, DataPosition.rotationTeam, Pack.byteByte((byte)0, (byte)Team.blue.ordinal()));
}
}
}

14
core/src/io/anuke/mindustry/io/SaveFileVersion.java
View File

@@ -1,6 +1,10 @@
package io.anuke.mindustry.io;
import io.anuke.arc.collection.Array;
import io.anuke.arc.entities.Entities;
import io.anuke.arc.entities.EntityGroup;
import io.anuke.arc.entities.trait.Entity;
import io.anuke.arc.util.Pack;
import io.anuke.mindustry.content.blocks.Blocks;
import io.anuke.mindustry.content.blocks.StorageBlocks;
import io.anuke.mindustry.entities.traits.SaveTrait;
@@ -13,10 +17,6 @@ import io.anuke.mindustry.maps.Map;
import io.anuke.mindustry.type.ContentType;
import io.anuke.mindustry.world.Tile;
import io.anuke.mindustry.world.blocks.BlockPart;
import io.anuke.arc.entities.Entities;
import io.anuke.arc.entities.EntityGroup;
import io.anuke.arc.entities.trait.Entity;
import io.anuke.arc.util.Bits;
import java.io.DataInputStream;
import java.io.DataOutputStream;
@@ -59,7 +59,7 @@ public abstract class SaveFileVersion{
if(tile.block() instanceof BlockPart){
stream.writeByte(tile.link);
}else if(tile.entity != null){
stream.writeByte(Bits.packByte(tile.getTeamID(), tile.getRotation())); //team + rotation
stream.writeByte(Pack.byteByte(tile.getTeamID(), tile.getRotation())); //team + rotation
stream.writeShort((short) tile.entity.health); //health
if(tile.entity.items != null) tile.entity.items.write(stream);
@@ -139,8 +139,8 @@ public abstract class SaveFileVersion{
byte tr = stream.readByte();
short health = stream.readShort();
byte team = Bits.getLeftByte(tr);
byte rotation = Bits.getRightByte(tr);
byte team = Pack.leftByte(tr);
byte rotation = Pack.rightByte(tr);
Team t = Team.all[team];

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

4
core/src/io/anuke/mindustry/maps/MapMeta.java
View File

@@ -1,8 +1,8 @@
package io.anuke.mindustry.maps;
import io.anuke.arc.util.IntIntMap;
import io.anuke.arc.Core;
import io.anuke.arc.collection.IntIntMap;
import io.anuke.arc.collection.ObjectMap;
import io.anuke.arc.util.Bundles;
public class MapMeta{
public final int version;

14
core/src/io/anuke/mindustry/maps/MapTileData.java
View File

@@ -1,11 +1,11 @@
package io.anuke.mindustry.maps;
import io.anuke.arc.util.IntIntMap;
import io.anuke.arc.collection.IntIntMap;
import io.anuke.arc.util.Pack;
import io.anuke.arc.util.Structs;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.content.blocks.Blocks;
import io.anuke.mindustry.world.Block;
import io.anuke.arc.util.Bits;
import io.anuke.arc.util.Structs;
import java.nio.ByteBuffer;
@@ -73,7 +73,7 @@ public class MapTileData{
if(Structs.inBounds(worldx, worldy, width, height) && !(dx + offsetx == 0 && dy + offsety == 0)){
write(worldx, worldy, DataPosition.wall, Blocks.blockpart.id);
write(worldx, worldy, DataPosition.link, Bits.packByte((byte) (dx + offsetx + 8), (byte) (dy + offsety + 8)));
write(worldx, worldy, DataPosition.link, Pack.byteByte((byte) (dx + offsetx + 8), (byte) (dy + offsety + 8)));
}
}
}
@@ -154,8 +154,8 @@ public class MapTileData{
link = buffer.get();
byte rt = buffer.get();
elevation = buffer.get();
rotation = Bits.getLeftByte(rt);
team = Bits.getRightByte(rt);
rotation = Pack.leftByte(rt);
team = Pack.rightByte(rt);
if(map != null){
floor = (byte) map.get(floor, Blocks.stone.id);
@@ -168,7 +168,7 @@ public class MapTileData{
buffer.put(floor);
buffer.put(wall);
buffer.put(link);
buffer.put(Bits.packByte(rotation, team));
buffer.put(Pack.byteByte(rotation, team));
buffer.put(elevation);
}
}

5
core/src/io/anuke/mindustry/maps/Maps.java
View File

@@ -9,7 +9,6 @@ import io.anuke.arc.collection.ObjectMap;
import io.anuke.mindustry.io.MapIO;
import io.anuke.arc.function.Supplier;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.ThreadArray;
import java.io.DataInputStream;
import java.io.IOException;
@@ -26,9 +25,9 @@ public class Maps implements Disposable{
/**Maps map names to the real maps.*/
private ObjectMap<String, Map> maps = new ObjectMap<>();
/**All maps stored in an ordered array.*/
private Array<Map> allMaps = new ThreadArray<>();
private Array<Map> allMaps = new Array<>();
/**Temporary array used for returning things.*/
private Array<Map> returnArray = new ThreadArray<>();
private Array<Map> returnArray = new Array<>();
/**Returns a list of all maps, including custom ones.*/
public Array<Map> all(){

10
core/src/io/anuke/mindustry/maps/Sector.java
View File

@@ -1,13 +1,13 @@
package io.anuke.mindustry.maps;
import io.anuke.arc.graphics.Texture;
import io.anuke.arc.collection.Array;
import io.anuke.annotations.Annotations.Serialize;
import io.anuke.arc.collection.Array;
import io.anuke.arc.graphics.Texture;
import io.anuke.arc.util.Pack;
import io.anuke.mindustry.game.Saves.SaveSlot;
import io.anuke.mindustry.game.SpawnGroup;
import io.anuke.mindustry.maps.missions.*;
import io.anuke.mindustry.type.ItemStack;
import io.anuke.arc.util.Bits;
import static io.anuke.mindustry.Vars.control;
import static io.anuke.mindustry.Vars.headless;
@@ -56,7 +56,7 @@ public class Sector{
}
public int getSeed(){
return Bits.packInt(x, y);
return pos();
}
public SaveSlot getSave(){
@@ -68,6 +68,6 @@ public class Sector{
}
public int pos(){
return Bits.packInt(x, y);
return Pack.shortInt(x, y);
}
}

4
core/src/io/anuke/mindustry/maps/SectorPresets.java
View File

@@ -1,6 +1,8 @@
package io.anuke.mindustry.maps;
import io.anuke.arc.collection.Array;
import io.anuke.arc.collection.GridMap;
import io.anuke.arc.util.Structs;
import io.anuke.mindustry.content.Items;
import io.anuke.mindustry.content.Liquids;
import io.anuke.mindustry.content.Mechs;
@@ -12,8 +14,6 @@ import io.anuke.mindustry.content.blocks.UpgradeBlocks;
import io.anuke.mindustry.entities.units.UnitCommand;
import io.anuke.mindustry.maps.missions.*;
import io.anuke.mindustry.type.Item;
import io.anuke.arc.util.GridMap;
import io.anuke.arc.util.Structs;
import static io.anuke.mindustry.Vars.mobile;

26
core/src/io/anuke/mindustry/maps/Sectors.java
View File

@@ -1,12 +1,17 @@
package io.anuke.mindustry.maps;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.arc.collection.Array.ArrayIterable;
import io.anuke.arc.collection.GridMap;
import io.anuke.arc.graphics.Pixmap;
import io.anuke.arc.graphics.Pixmap.Format;
import io.anuke.arc.graphics.Texture;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.collection.Array;
import io.anuke.arc.util.Array.ArrayIterable;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.math.geom.Geometry;
import io.anuke.arc.math.geom.Point2;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Pack;
import io.anuke.arc.util.async.AsyncExecutor;
import io.anuke.mindustry.content.Items;
import io.anuke.mindustry.core.GameState.State;
@@ -27,7 +32,6 @@ import io.anuke.mindustry.type.Recipe.RecipeVisibility;
import io.anuke.mindustry.world.ColorMapper;
import io.anuke.mindustry.world.blocks.Floor;
import io.anuke.mindustry.world.blocks.defense.Wall;
import io.anuke.arc.util.*;
import static io.anuke.mindustry.Vars.*;
@@ -71,7 +75,7 @@ public class Sectors{
playSector(sector);
if(!headless){
threads.runGraphics(() -> ui.showError("$text.sector.corrupted"));
ui.showError("$text.sector.corrupted");
}
}
}
@@ -82,7 +86,7 @@ public class Sectors{
}
public Sector get(int position){
return grid.get(Bits.getLeftShort(position), Bits.getRightShort(position));
return grid.get(Pack.leftShort(position), Pack.rightShort(position));
}
public Iterable<Sector> getSectors(){
@@ -111,7 +115,7 @@ public class Sectors{
Sector sector = get(x, y);
sector.complete = true;
for(GridPoint2 g : Geometry.d4){
for(Point2 g : Geometry.d4){
createSector(x + g.x, y + g.y);
}
}
@@ -130,7 +134,7 @@ public class Sectors{
grid.put(sector.x, sector.y, sector);
if(sector.texture == null){
threads.runGraphics(() -> createTexture(sector));
createTexture(sector);
}
if(sector.missions.size == 0){
@@ -148,7 +152,7 @@ public class Sectors{
grid.put(sector.x, sector.y, sector);
threads.runGraphics(() -> createTexture(sector));
createTexture(sector);
save();
}
@@ -245,14 +249,14 @@ public class Sectors{
Generation gen = new Generation(sector, null, sectorSize, sectorSize, null);
Array<GridPoint2> points = new Array<>();
Array<Point2> points = new Array<>();
for(Mission mission : sector.missions){
points.addAll(mission.getSpawnPoints(gen));
}
GenResult result = new GenResult();
for(GridPoint2 point : new ArrayIterable<>(points)){
for(Point2 point : new ArrayIterable<>(points)){
world.generator.generateTile(result, sector.x, sector.y, point.x, point.y, true, null, null);
if(((Floor)result.floor).isLiquid || result.wall.solid){
sector.missions.clear();

25
core/src/io/anuke/mindustry/maps/generation/FortressGenerator.java
View File

@@ -1,10 +1,14 @@
package io.anuke.mindustry.maps.generation;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.collection.Array;
import io.anuke.arc.util.IntIntMap;
import io.anuke.arc.util.Predicate;
import io.anuke.arc.collection.IntIntMap;
import io.anuke.arc.function.BiFunction;
import io.anuke.arc.function.IntPositionConsumer;
import io.anuke.arc.function.Predicate;
import io.anuke.arc.function.TriFunction;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.math.geom.Geometry;
import io.anuke.arc.math.geom.Point2;
import io.anuke.mindustry.content.Items;
import io.anuke.mindustry.content.Liquids;
import io.anuke.mindustry.content.blocks.*;
@@ -29,11 +33,6 @@ import io.anuke.mindustry.world.blocks.power.SolarGenerator;
import io.anuke.mindustry.world.blocks.storage.CoreBlock;
import io.anuke.mindustry.world.blocks.storage.StorageBlock;
import io.anuke.mindustry.world.blocks.units.UnitFactory;
import io.anuke.arc.function.BiFunction;
import io.anuke.arc.function.IntPositionConsumer;
import io.anuke.arc.function.TriFunction;
import io.anuke.arc.util.Geometry;
import io.anuke.arc.math.Mathf;
import static io.anuke.mindustry.Vars.content;
@@ -83,11 +82,11 @@ public class FortressGenerator{
}
TriFunction<Tile, Block, Predicate<Tile>, Boolean> checker = (current, block, pred) -> {
for(GridPoint2 point : Edges.getEdges(block.size)){
for(Point2 point : Edges.getEdges(block.size)){
Tile tile = gen.tile(current.x + point.x, current.y + point.y);
if(tile != null){
tile = tile.target();
if(tile.getTeamID() == team.ordinal() && pred.evaluate(tile)){
if(tile.getTeamID() == team.ordinal() && pred.test(tile)){
return true;
}
}
@@ -160,7 +159,7 @@ public class FortressGenerator{
(x, y) -> {
if(!gen.canPlace(x, y, wall)) return;
for(GridPoint2 point : Geometry.d8){
for(Point2 point : Geometry.d8){
Tile tile = gen.tile(x + point.x, y + point.y);
if(tile != null){
tile = tile.target();
@@ -211,7 +210,7 @@ public class FortressGenerator{
Array<Block> find(Predicate<Block> pred){
Array<Block> out = new Array<>();
for(Block block : content.blocks()){
if(pred.evaluate(block) && Recipe.getByResult(block) != null){
if(pred.test(block) && Recipe.getByResult(block) != null){
out.add(block);
}
}

6
core/src/io/anuke/mindustry/maps/generation/Generation.java
View File

@@ -1,5 +1,6 @@
package io.anuke.mindustry.maps.generation;
import io.anuke.arc.math.RandomXS128;
import io.anuke.mindustry.game.Team;
import io.anuke.mindustry.maps.Sector;
import io.anuke.mindustry.type.Item;
@@ -7,15 +8,14 @@ import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.Tile;
import io.anuke.mindustry.world.blocks.production.Drill;
import io.anuke.arc.util.Structs;
import io.anuke.arc.util.SeedRandom;
public class Generation{
public final Sector sector;
public final Tile[][] tiles;
public final int width, height;
public final SeedRandom random;
public final RandomXS128 random;
public Generation(Sector sector, Tile[][] tiles, int width, int height, SeedRandom random){
public Generation(Sector sector, Tile[][] tiles, int width, int height, RandomXS128 random){
this.sector = sector;
this.tiles = tiles;
this.width = width;

43
core/src/io/anuke/mindustry/maps/generation/WorldGenerator.java
View File

@@ -1,10 +1,15 @@
package io.anuke.mindustry.maps.generation;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.collection.Array;
import io.anuke.arc.util.IntArray;
import io.anuke.arc.collection.IntArray;
import io.anuke.arc.collection.ObjectMap;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.math.RandomXS128;
import io.anuke.arc.math.geom.Geometry;
import io.anuke.arc.math.geom.Point2;
import io.anuke.arc.util.Structs;
import io.anuke.arc.util.noise.RidgedPerlin;
import io.anuke.arc.util.noise.Simplex;
import io.anuke.mindustry.content.Items;
import io.anuke.mindustry.content.blocks.Blocks;
import io.anuke.mindustry.content.blocks.OreBlocks;
@@ -21,12 +26,6 @@ import io.anuke.mindustry.world.Pos;
import io.anuke.mindustry.world.Tile;
import io.anuke.mindustry.world.blocks.Floor;
import io.anuke.mindustry.world.blocks.OreBlock;
import io.anuke.arc.noise.RidgedPerlin;
import io.anuke.arc.noise.Simplex;
import io.anuke.arc.util.Geometry;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.SeedRandom;
import io.anuke.arc.util.Structs;
import static io.anuke.mindustry.Vars.*;
@@ -39,13 +38,13 @@ public class WorldGenerator{
private Simplex sim2 = new Simplex(baseSeed + 1);
private Simplex sim3 = new Simplex(baseSeed + 2);
private RidgedPerlin rid = new RidgedPerlin(baseSeed + 4, 1);
private SeedRandom random = new SeedRandom(baseSeed + 3);
private RandomXS128 random = new RandomXS128(baseSeed + 3);
private GenResult result = new GenResult();
private ObjectMap<Block, Block> decoration;
public WorldGenerator(){
decoration = Structs.map(
decoration = ObjectMap.of(
Blocks.grass, Blocks.shrub,
Blocks.stone, Blocks.rock,
Blocks.ice, Blocks.icerock,
@@ -149,15 +148,15 @@ public class WorldGenerator{
int sy = (short)Mathf.range(Short.MAX_VALUE/2);
int width = 380;
int height = 380;
Array<GridPoint2> spawns = new Array<>();
Array<Point2> spawns = new Array<>();
Array<Item> ores = Item.getAllOres();
if(state.mode.isPvp){
int scaling = 10;
spawns.add(new GridPoint2(width/scaling, height/scaling));
spawns.add(new GridPoint2(width - 1 - width/scaling, height - 1 - height/scaling));
spawns.add(new Point2(width/scaling, height/scaling));
spawns.add(new Point2(width - 1 - width/scaling, height - 1 - height/scaling));
}else{
spawns.add(new GridPoint2(width/2, height/2));
spawns.add(new Point2(width/2, height/2));
}
Tile[][] tiles = world.createTiles(width, height);
@@ -179,7 +178,7 @@ public class WorldGenerator{
byte elevation = tile.getElevation();
for(GridPoint2 point : Geometry.d4){
for(Point2 point : Geometry.d4){
if(!Structs.inBounds(x + point.x, y + point.y, width, height)) continue;
if(tiles[x + point.x][y + point.y].getElevation() < elevation){
@@ -220,7 +219,7 @@ public class WorldGenerator{
ores.addAll(baseOres);
}else{
for(Item item : usedOres){
ores.add(baseOres.select(entry -> entry.item == item).iterator().next());
ores.add(baseOres.find(entry -> entry.item == item));
}
}
@@ -249,9 +248,9 @@ public class WorldGenerator{
public void generateMap(Tile[][] tiles, Sector sector){
int width = tiles.length, height = tiles[0].length;
SeedRandom rnd = new SeedRandom(sector.getSeed());
RandomXS128 rnd = new RandomXS128(sector.getSeed());
Generation gena = new Generation(sector, tiles, tiles.length, tiles[0].length, rnd);
Array<GridPoint2> spawnpoints = sector.currentMission().getSpawnPoints(gena);
Array<Point2> spawnpoints = sector.currentMission().getSpawnPoints(gena);
Array<Item> ores = world.sectors.getOres(sector.x, sector.y);
for(int x = 0; x < width; x++){
@@ -268,7 +267,7 @@ public class WorldGenerator{
byte elevation = tile.getElevation();
for(GridPoint2 point : Geometry.d4){
for(Point2 point : Geometry.d4){
if(!Structs.inBounds(x + point.x, y + point.y, width, height)) continue;
if(tiles[x + point.x][y + point.y].getElevation() < elevation){
@@ -317,7 +316,7 @@ public class WorldGenerator{
* @param spawnpoints list of player spawnpoints, can be null
* @return the GenResult passed in with its values modified
*/
public GenResult generateTile(GenResult result, int sectorX, int sectorY, int localX, int localY, boolean detailed, Array<GridPoint2> spawnpoints, Array<Item> ores){
public GenResult generateTile(GenResult result, int sectorX, int sectorY, int localX, int localY, boolean detailed, Array<Point2> spawnpoints, Array<Item> ores){
int x = sectorX * sectorSize + localX + Short.MAX_VALUE;
int y = sectorY * sectorSize + localY + Short.MAX_VALUE;
@@ -338,7 +337,7 @@ public class WorldGenerator{
float minDst = Float.MAX_VALUE;
if(detailed && spawnpoints != null){
for(GridPoint2 p : spawnpoints){
for(Point2 p : spawnpoints){
float dst = Mathf.dst2(p.x, p.y, localX, localY);
minDst = Math.min(minDst, dst);

6
core/src/io/anuke/mindustry/maps/missions/ActionMission.java
View File

@@ -1,8 +1,6 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.util.Bundles;
import static io.anuke.mindustry.Vars.threads;
import io.anuke.arc.Core;
/**A mission which simply runs a single action and is completed instantly.*/
public class ActionMission extends Mission{
@@ -17,7 +15,7 @@ public class ActionMission extends Mission{
@Override
public void onComplete(){
threads.run(runner);
runner.run();
}
@Override

11
core/src/io/anuke/mindustry/maps/missions/BattleMission.java
View File

@@ -1,16 +1,17 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.arc.math.geom.Point2;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.game.GameMode;
import io.anuke.mindustry.game.Team;
import io.anuke.mindustry.maps.generation.FortressGenerator;
import io.anuke.mindustry.maps.generation.Generation;
import io.anuke.mindustry.world.Tile;
import io.anuke.arc.util.Bundles;
import static io.anuke.mindustry.Vars.*;
import static io.anuke.mindustry.Vars.defaultTeam;
import static io.anuke.mindustry.Vars.state;
public class BattleMission extends MissionWithStartingCore{
final int spacing = 30;
@@ -47,8 +48,8 @@ public class BattleMission extends MissionWithStartingCore{
}
@Override
public Array<GridPoint2> getSpawnPoints(Generation gen){
return Array.with(new GridPoint2(50, 50), new GridPoint2(gen.width - 1 - spacing, gen.height - 1 - spacing));
public Array<Point2> getSpawnPoints(Generation gen){
return Array.with(new Point2(50, 50), new Point2(gen.width - 1 - spacing, gen.height - 1 - spacing));
}
@Override

22
core/src/io/anuke/mindustry/maps/missions/BlockLocMission.java
View File

@@ -1,17 +1,15 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.world.Block;
import io.anuke.arc.util.Time;
import io.anuke.arc.Core;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.Lines;
import io.anuke.arc.util.Angles;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.world.Block;
import static io.anuke.mindustry.Vars.players;
import static io.anuke.mindustry.Vars.tilesize;
import static io.anuke.mindustry.Vars.world;
import static io.anuke.mindustry.Vars.*;
public class BlockLocMission extends Mission{
private final Block block;
@@ -44,18 +42,18 @@ public class BlockLocMission extends Mission{
if(block.rotate){
Draw.colorl(0.4f);
Draw.rect("icon-arrow", x * tilesize + block.offset(), y * tilesize + block.offset() - 1f, rotation*90);
Draw.rect("icon-arrow", x * tilesize + block.offset(), y * tilesize + block.offset() - 1f).rot(rotation*90);
Draw.colorl(0.6f);
Draw.rect("icon-arrow", x * tilesize + block.offset(), y * tilesize + block.offset(), rotation*90);
Draw.rect("icon-arrow", x * tilesize + block.offset(), y * tilesize + block.offset()).rot(rotation*90);
}
float rot = players[0].angleTo(x * tilesize + block.offset(), y * tilesize + block.offset());
float len = 12f;
Draw.color(Palette.accentBack);
Draw.rect("icon-arrow", players[0].x + Angles.trnsx(rot, len), players[0].y + Angles.trnsy(rot, len), rot);
Draw.rect("icon-arrow", players[0].x + Angles.trnsx(rot, len), players[0].y + Angles.trnsy(rot, len)).rot(rot);
Draw.color(Palette.accent);
Draw.rect("icon-arrow", players[0].x + Angles.trnsx(rot, len), players[0].y + Angles.trnsy(rot, len) + 1f, rot);
Draw.rect("icon-arrow", players[0].x + Angles.trnsx(rot, len), players[0].y + Angles.trnsy(rot, len) + 1f).rot(rot);
Draw.reset();
}

2
core/src/io/anuke/mindustry/maps/missions/CommandMission.java
View File

@@ -1,9 +1,9 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.Core;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.entities.units.BaseUnit;
import io.anuke.mindustry.entities.units.UnitCommand;
import io.anuke.arc.util.Bundles;
public class CommandMission extends Mission{
private final UnitCommand command;

2
core/src/io/anuke/mindustry/maps/missions/ContentMission.java
View File

@@ -1,7 +1,7 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.Core;
import io.anuke.mindustry.game.UnlockableContent;
import io.anuke.arc.util.Bundles;
public class ContentMission extends Mission {
private final UnlockableContent content;

2
core/src/io/anuke/mindustry/maps/missions/ItemMission.java
View File

@@ -1,10 +1,10 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.Core;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.entities.TileEntity;
import io.anuke.mindustry.type.Item;
import io.anuke.mindustry.world.Tile;
import io.anuke.arc.util.Bundles;
import static io.anuke.mindustry.Vars.state;

8
core/src/io/anuke/mindustry/maps/missions/LineBlockMission.java
View File

@@ -1,8 +1,8 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.math.Bresenham2;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.collection.Array;
import io.anuke.arc.math.geom.Bresenham2;
import io.anuke.arc.math.geom.Point2;
import io.anuke.mindustry.world.Block;
public class LineBlockMission extends Mission{
@@ -10,8 +10,8 @@ public class LineBlockMission extends Mission{
private int completeIndex;
public LineBlockMission(Block block, int x1, int y1, int x2, int y2, int rotation){
Array<GridPoint2> points = new Bresenham2().line(x1, y1, x2, y2);
for(GridPoint2 point : points){
Array<Point2> points = new Bresenham2().line(x1, y1, x2, y2);
for(Point2 point : points){
this.points.add(new BlockLocMission(block, point.x, point.y, rotation));
}
}

2
core/src/io/anuke/mindustry/maps/missions/MechMission.java
View File

@@ -1,9 +1,9 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.Core;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.entities.Player;
import io.anuke.mindustry.type.Mech;
import io.anuke.arc.util.Bundles;
public class MechMission extends Mission{
private final Mech mech;

15
core/src/io/anuke/mindustry/maps/missions/Mission.java
View File

@@ -1,17 +1,18 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.arc.math.geom.Point2;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.game.GameMode;
import io.anuke.mindustry.game.SpawnGroup;
import io.anuke.mindustry.game.UnlockableContent;
import io.anuke.mindustry.maps.Sector;
import io.anuke.mindustry.maps.generation.Generation;
import io.anuke.arc.util.Time;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
import static io.anuke.mindustry.Vars.*;
import static io.anuke.mindustry.Vars.headless;
import static io.anuke.mindustry.Vars.ui;
public abstract class Mission{
private String extraMessage;
@@ -81,7 +82,7 @@ public abstract class Mission{
public void onComplete(){
if(showComplete && !headless){
threads.runGraphics(() -> ui.hudfrag.showToast("[LIGHT_GRAY]"+menuDisplayString() + ":\n" + Core.bundle.get("text.mission.complete")));
ui.hudfrag.showToast("[LIGHT_GRAY]"+menuDisplayString() + ":\n" + Core.bundle.get("text.mission.complete"));
}
}
@@ -93,7 +94,7 @@ public abstract class Mission{
return new Array<>();
}
public Array<GridPoint2> getSpawnPoints(Generation gen){
public Array<Point2> getSpawnPoints(Generation gen){
return Array.with();
}

12
core/src/io/anuke/mindustry/maps/missions/MissionWithStartingCore.java
View File

@@ -1,6 +1,6 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.math.geom.Point2;
import io.anuke.arc.collection.Array;
import io.anuke.mindustry.content.blocks.StorageBlocks;
import io.anuke.mindustry.game.Team;
@@ -11,7 +11,7 @@ import static io.anuke.mindustry.Vars.state;
public abstract class MissionWithStartingCore extends Mission{
/** Stores a custom starting location for the core, or null if the default calculation (map center) shall be used. */
private final GridPoint2 customStartingPoint;
private final Point2 customStartingPoint;
/** Default constructor. Missions created this way will have a player starting core in the center of the map. */
MissionWithStartingCore(){
@@ -24,7 +24,7 @@ public abstract class MissionWithStartingCore extends Mission{
* @param yCorePos The y coordinate of the custom core position.
*/
MissionWithStartingCore(int xCorePos, int yCorePos){
this.customStartingPoint = new GridPoint2(xCorePos, yCorePos);
this.customStartingPoint = new Point2(xCorePos, yCorePos);
}
/**
@@ -33,7 +33,7 @@ public abstract class MissionWithStartingCore extends Mission{
* @param team The team to generate the core for.
*/
public void generateCoreAtFirstSpawnPoint(Generation gen, Team team){
Array<GridPoint2> spawnPoints = getSpawnPoints(gen);
Array<Point2> spawnPoints = getSpawnPoints(gen);
if(spawnPoints == null || spawnPoints.size == 0){
throw new IllegalArgumentException("A MissionWithStartingCore subclass did not provide a spawn point in getSpawnPoints(). However, at least one point must always be provided.");
}
@@ -58,9 +58,9 @@ public abstract class MissionWithStartingCore extends Mission{
* @implNote Must return an array with at least one entry.
*/
@Override
public Array<GridPoint2> getSpawnPoints(Generation gen){
public Array<Point2> getSpawnPoints(Generation gen){
if(this.customStartingPoint == null){
return Array.with(new GridPoint2(gen.width / 2, gen.height / 2));
return Array.with(new Point2(gen.width / 2, gen.height / 2));
}else{
return Array.with(this.customStartingPoint);
}

2
core/src/io/anuke/mindustry/maps/missions/UnitMission.java
View File

@@ -1,9 +1,9 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.Core;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.entities.units.BaseUnit;
import io.anuke.mindustry.entities.units.UnitType;
import io.anuke.arc.util.Bundles;
public class UnitMission extends Mission{
private final UnitType type;

2
core/src/io/anuke/mindustry/maps/missions/WaveMission.java
View File

@@ -1,5 +1,6 @@
package io.anuke.mindustry.maps.missions;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.mindustry.game.GameMode;
import io.anuke.mindustry.game.SpawnGroup;
@@ -7,7 +8,6 @@ import io.anuke.mindustry.game.Team;
import io.anuke.mindustry.game.Waves;
import io.anuke.mindustry.maps.Sector;
import io.anuke.mindustry.maps.generation.Generation;
import io.anuke.arc.util.Bundles;
import static io.anuke.mindustry.Vars.*;

10
core/src/io/anuke/mindustry/net/Administration.java
View File

@@ -1,10 +1,10 @@
package io.anuke.mindustry.net;
import io.anuke.annotations.Annotations.Serialize;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.arc.collection.ObjectMap;
import io.anuke.arc.collection.ObjectSet;
import io.anuke.annotations.Annotations.Serialize;
import io.anuke.arc.Settings;
import static io.anuke.mindustry.Vars.headless;
@@ -15,7 +15,7 @@ public class Administration{
private Array<String> bannedIPs = new Array<>();
public Administration(){
Core.settings.defaultList(
Core.settings.defaults(
"strict", true
);
@@ -23,7 +23,7 @@ public class Administration{
}
public void setStrict(boolean on){
Core.settings.putBool("strict", on);
Core.settings.put("strict", on);
Core.settings.save();
}
@@ -36,7 +36,7 @@ public class Administration{
}
public void setCustomClients(boolean allowed){
Core.settings.putBool("allow-custom", allowed);
Core.settings.put("allow-custom", allowed);
Core.settings.save();
}

19
core/src/io/anuke/mindustry/net/NetworkIO.java
View File

@@ -1,7 +1,10 @@
package io.anuke.mindustry.net;
import io.anuke.arc.Core;
import io.anuke.arc.collection.ObjectMap;
import io.anuke.arc.util.ObjectMap.Entry;
import io.anuke.arc.collection.ObjectMap.Entry;
import io.anuke.arc.entities.Entities;
import io.anuke.arc.util.Pack;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.content.blocks.Blocks;
import io.anuke.mindustry.entities.Player;
@@ -14,10 +17,6 @@ import io.anuke.mindustry.maps.Map;
import io.anuke.mindustry.maps.MapMeta;
import io.anuke.mindustry.world.Tile;
import io.anuke.mindustry.world.blocks.BlockPart;
import io.anuke.arc.Core;
import io.anuke.arc.util.Time;
import io.anuke.arc.entities.Entities;
import io.anuke.arc.util.Bits;
import java.io.*;
import java.nio.ByteBuffer;
@@ -66,7 +65,7 @@ public class NetworkIO{
if(tile.block() instanceof BlockPart){
stream.writeByte(tile.link);
}else if(tile.entity != null){
stream.writeByte(Bits.packByte(tile.getTeamID(), tile.getRotation())); //team + rotation
stream.writeByte(Pack.byteByte(tile.getTeamID(), tile.getRotation())); //team + rotation
stream.writeShort((short) tile.entity.health); //health
if(tile.entity.items != null) tile.entity.items.write(stream);
@@ -160,7 +159,7 @@ public class NetworkIO{
int missions = stream.readInt();
if(sector != invalidSector){
world.sectors.createSector(Bits.getLeftShort(sector), Bits.getRightShort(sector));
world.sectors.createSector(Pack.leftShort(sector), Pack.rightShort(sector));
world.setSector(world.sectors.get(sector));
world.getSector().completedMissions = missions;
}else{
@@ -218,8 +217,8 @@ public class NetworkIO{
byte tr = stream.readByte();
short health = stream.readShort();
byte team = Bits.getLeftByte(tr);
byte rotation = Bits.getRightByte(tr);
byte team = Pack.leftByte(tr);
byte rotation = Pack.rightByte(tr);
tile.setTeam(Team.all[team]);
tile.entity.health = health;
@@ -281,7 +280,7 @@ public class NetworkIO{
}
if(team == players[0].getTeam() && cores > 0){
Core.camera.position.set(state.teams.get(team).cores.first().drawx(), state.teams.get(team).cores.first().drawy(), 0);
Core.camera.position.set(state.teams.get(team).cores.first().drawx(), state.teams.get(team).cores.first().drawy());
}
}

2
core/src/io/anuke/mindustry/net/Packet.java
View File

@@ -1,6 +1,6 @@
package io.anuke.mindustry.net;
import io.anuke.arc.util.Pool.Poolable;
import io.anuke.arc.util.pooling.Pool.Poolable;
import java.nio.ByteBuffer;

4
core/src/io/anuke/mindustry/net/Packets.java
View File

@@ -1,9 +1,9 @@
package io.anuke.mindustry.net;
import io.anuke.arc.util.Base64Coder;
import io.anuke.arc.Core;
import io.anuke.arc.util.serialization.Base64Coder;
import io.anuke.mindustry.game.Version;
import io.anuke.mindustry.io.TypeIO;
import io.anuke.arc.util.Bundles;
import java.nio.ByteBuffer;

4
core/src/io/anuke/mindustry/net/Registrator.java
View File

@@ -1,8 +1,8 @@
package io.anuke.mindustry.net;
import io.anuke.arc.util.ObjectIntMap;
import io.anuke.mindustry.net.Packets.*;
import io.anuke.arc.collection.ObjectIntMap;
import io.anuke.arc.function.Supplier;
import io.anuke.mindustry.net.Packets.*;
public class Registrator{
private static ClassEntry[] classes = {

11
core/src/io/anuke/mindustry/type/Item.java
View File

@@ -1,17 +1,16 @@
package io.anuke.mindustry.type;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.collection.Array;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Strings;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.game.UnlockableContent;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.ui.ContentDisplay;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Strings;
public class Item extends UnlockableContent implements Comparable<Item>{
public final String name;

5
core/src/io/anuke/mindustry/type/Liquid.java
View File

@@ -1,13 +1,12 @@
package io.anuke.mindustry.type;
import io.anuke.arc.Core;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.mindustry.content.StatusEffects;
import io.anuke.mindustry.game.UnlockableContent;
import io.anuke.mindustry.ui.ContentDisplay;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
public class Liquid extends UnlockableContent{
public final Color color;

5
core/src/io/anuke/mindustry/type/Mech.java
View File

@@ -1,15 +1,14 @@
package io.anuke.mindustry.type;
import io.anuke.arc.Core;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.mindustry.content.Weapons;
import io.anuke.mindustry.entities.Player;
import io.anuke.mindustry.game.UnlockableContent;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.ui.ContentDisplay;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
public class Mech extends UnlockableContent{
public final String name;

12
core/src/io/anuke/mindustry/type/Recipe.java
View File

@@ -1,9 +1,13 @@
package io.anuke.mindustry.type;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.arc.collection.ObjectMap;
import io.anuke.arc.util.OrderedMap;
import io.anuke.arc.collection.OrderedMap;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Strings;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.game.GameMode;
import io.anuke.mindustry.game.UnlockableContent;
@@ -12,10 +16,6 @@ import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.meta.BlockStat;
import io.anuke.mindustry.world.meta.ContentStatValue;
import io.anuke.mindustry.world.meta.StatValue;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Strings;
import java.util.Arrays;

15
core/src/io/anuke/mindustry/type/Weapon.java
View File

@@ -1,8 +1,14 @@
package io.anuke.mindustry.type;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.annotations.Annotations.Loc;
import io.anuke.annotations.Annotations.Remote;
import io.anuke.arc.Core;
import io.anuke.arc.entities.Effects;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.math.Angles;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.math.geom.Vector2;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.content.fx.Fx;
import io.anuke.mindustry.entities.Player;
@@ -11,13 +17,6 @@ import io.anuke.mindustry.entities.traits.ShooterTrait;
import io.anuke.mindustry.game.Content;
import io.anuke.mindustry.gen.Call;
import io.anuke.mindustry.net.Net;
import io.anuke.arc.entities.Effects;
import io.anuke.arc.entities.Effects.Effect;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.util.Angles;
import io.anuke.arc.util.Log;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Vector2;
public class Weapon extends Content{
public final String name;

5
core/src/io/anuke/mindustry/ui/BorderImage.java
View File

@@ -1,7 +1,6 @@
package io.anuke.mindustry.ui;
import io.anuke.arc.graphics.Texture;
import io.anuke.arc.graphics.g2d.Batch;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.arc.graphics.g2d.Draw;
@@ -31,8 +30,8 @@ public class BorderImage extends Image{
}
@Override
public void draw(Batch batch, float alpha){
super.draw(batch, alpha);
public void draw(){
super.draw();
float scaleX = getScaleX();
float scaleY = getScaleY();

9
core/src/io/anuke/mindustry/ui/ContentDisplay.java
View File

@@ -1,7 +1,10 @@
package io.anuke.mindustry.ui;
import io.anuke.arc.Core;
import io.anuke.arc.collection.OrderedMap;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.util.OrderedMap;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Strings;
import io.anuke.mindustry.entities.units.UnitType;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.type.Item;
@@ -13,10 +16,6 @@ import io.anuke.mindustry.world.meta.BlockStat;
import io.anuke.mindustry.world.meta.BlockStats;
import io.anuke.mindustry.world.meta.StatCategory;
import io.anuke.mindustry.world.meta.StatValue;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.util.Strings;
public class ContentDisplay{

13
core/src/io/anuke/mindustry/ui/GridImage.java
View File

@@ -1,8 +1,6 @@
package io.anuke.mindustry.ui;
import io.anuke.arc.graphics.g2d.Batch;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.scene.Element;
public class GridImage extends Element{
@@ -13,9 +11,8 @@ public class GridImage extends Element{
this.imageHeight = h;
}
public void draw(Batch batch, float alpha){
TextureRegion blank = Core.atlas.find("white");
@Override
public void draw(){
float xspace = (getWidth() / imageWidth);
float yspace = (getHeight() / imageHeight);
float s = 1f;
@@ -26,11 +23,11 @@ public class GridImage extends Element{
int jumpy = (int) (Math.max(minspace, yspace) / yspace);
for(int x = 0; x <= imageWidth; x += jumpx){
batch.draw(blank, (int) (getX() + xspace * x - s), getY() - s, 2, getHeight() + (x == imageWidth ? 1 : 0));
Fill.rect().set((int) (getX() + xspace * x - s), getY() - s, 2, getHeight() + (x == imageWidth ? 1 : 0));
}
for(int y = 0; y <= imageHeight; y += jumpy){
batch.draw(blank, getX() - s, (int) (getY() + y * yspace - s), getWidth(), 2);
Fill.rect().set(getX() - s, (int) (getY() + y * yspace - s), getWidth(), 2);
}
}

3
core/src/io/anuke/mindustry/ui/IntFormat.java
View File

@@ -1,6 +1,7 @@
package io.anuke.mindustry.ui;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.Core;
/**
* A low-garbage way to format bundle strings.

2
core/src/io/anuke/mindustry/ui/Links.java
View File

@@ -1,7 +1,7 @@
package io.anuke.mindustry.ui;
import io.anuke.arc.Core;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.util.Bundles;
public class Links{
private static LinkEntry[] links;

22
core/src/io/anuke/mindustry/ui/Minimap.java
View File

@@ -1,15 +1,14 @@
package io.anuke.mindustry.ui;
import io.anuke.arc.graphics.Texture.TextureFilter;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.mindustry.graphics.Shaders;
import io.anuke.arc.Core;
import io.anuke.arc.Graphics;
import io.anuke.arc.graphics.Texture.TextureFilter;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.event.InputEvent;
import io.anuke.arc.scene.event.InputListener;
import io.anuke.arc.scene.ui.layout.Container;
import io.anuke.mindustry.graphics.Shaders;
import static io.anuke.mindustry.Vars.*;
@@ -23,7 +22,7 @@ public class Minimap extends Container<Element>{
public void draw(){
if(renderer.minimap.getRegion() == null) return;
Draw.crect(renderer.minimap.getRegion(), x, y, width, height);
Draw.rect().tex(renderer.minimap.getRegion()).set(x, y, width, height);
if(renderer.minimap.getTexture() != null){
renderer.minimap.drawEntities(x, y, width, height);
@@ -46,9 +45,9 @@ public class Minimap extends Container<Element>{
r.setU2(px2 / (world.width() + pad*2f));
r.setV2(1f - py2 / (world.height() + pad*2f));
Graphics.shader(Shaders.fog);
Draw.crect(r, x, y, width, height);
Graphics.shader();
Draw.shader(Shaders.fog);
Draw.rect().tex(r).set(x, y, width, height);
Draw.shader();
renderer.fog.getTexture().setFilter(TextureFilter.Linear, TextureFilter.Linear);
}
@@ -61,15 +60,16 @@ public class Minimap extends Container<Element>{
margin(5f);
addListener(new InputListener(){
public boolean scrolled(InputEvent event, float x, float y, int amount){
renderer.minimap.zoomBy(amount);
@Override
public boolean scrolled(InputEvent event, float x, float y, float amountx, float amounty){
renderer.minimap.zoomBy(amounty);
return true;
}
});
update(() -> {
Element e = Core.scene.hit(Graphics.mouse().x, Graphics.mouse().y, true);
Element e = Core.scene.hit(Core.input.mouseX(), Core.input.mouseY(), true);
if(e != null && e.isDescendantOf(this)){
Core.scene.setScrollFocus(this);
}else if(Core.scene.getScrollFocus() == this){

11
core/src/io/anuke/mindustry/ui/dialogs/ChangelogDialog.java
View File

@@ -2,15 +2,14 @@ package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.io.Changelogs;
import io.anuke.mindustry.io.Changelogs.VersionInfo;
import io.anuke.mindustry.game.Version;
import io.anuke.arc.Settings;
import io.anuke.arc.scene.ui.ScrollPane;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.OS;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.game.Version;
import io.anuke.mindustry.io.Changelogs;
import io.anuke.mindustry.io.Changelogs.VersionInfo;
import static io.anuke.mindustry.Vars.ios;
@@ -79,7 +78,7 @@ public class ChangelogDialog extends FloatingDialog{
int lastid = Core.settings.getInt("lastBuild");
if(lastid != 0 && versions.peek().build > lastid){
Core.settings.putInt("lastBuild", versions.peek().build);
Core.settings.put("lastBuild", versions.peek().build);
Core.settings.save();
show();
}

6
core/src/io/anuke/mindustry/ui/dialogs/ColorPickDialog.java
View File

@@ -1,8 +1,8 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Input.Keys;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.function.Consumer;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.scene.ui.Dialog;
import io.anuke.arc.scene.ui.ImageButton;
import io.anuke.arc.scene.ui.layout.Table;
@@ -38,7 +38,7 @@ public class ColorPickDialog extends Dialog{
}
keyDown(key -> {
if(key == Keys.ESCAPE || key == Keys.BACK)
if(key == KeyCode.ESCAPE || key == KeyCode.BACK)
hide();
});

11
core/src/io/anuke/mindustry/ui/dialogs/ControlsDialog.java
View File

@@ -1,15 +1,16 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Input.Keys;
import io.anuke.arc.util.Align;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.arc.Core;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.scene.ui.Image;
import io.anuke.arc.scene.ui.KeybindDialog;
import io.anuke.arc.util.Align;
import io.anuke.mindustry.graphics.Palette;
public class ControlsDialog extends KeybindDialog{
public ControlsDialog(){
setDialog();
setStyle(Core.scene.skin.get("dialog", WindowStyle.class));
setFillParent(true);
title().setAlignment(Align.center);
@@ -23,7 +24,7 @@ public class ControlsDialog extends KeybindDialog{
buttons().addImageTextButton("$text.back", "icon-arrow-left", 30f, this::hide).size(230f, 64f);
keyDown(key -> {
if(key == Keys.ESCAPE || key == Keys.BACK)
if(key == KeyCode.ESCAPE || key == KeyCode.BACK)
hide();
});
}

17
core/src/io/anuke/mindustry/ui/dialogs/CustomGameDialog.java
View File

@@ -2,20 +2,19 @@ package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.util.Align;
import io.anuke.arc.util.Scaling;
import io.anuke.mindustry.game.Difficulty;
import io.anuke.mindustry.game.GameMode;
import io.anuke.mindustry.maps.Map;
import io.anuke.mindustry.ui.BorderImage;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.scene.event.Touchable;
import io.anuke.arc.scene.ui.ButtonGroup;
import io.anuke.arc.scene.ui.ImageButton;
import io.anuke.arc.scene.ui.ScrollPane;
import io.anuke.arc.scene.ui.TextButton;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Align;
import io.anuke.arc.util.Scaling;
import io.anuke.mindustry.game.Difficulty;
import io.anuke.mindustry.game.GameMode;
import io.anuke.mindustry.maps.Map;
import io.anuke.mindustry.ui.BorderImage;
import static io.anuke.mindustry.Vars.*;
@@ -76,7 +75,7 @@ public class CustomGameDialog extends FloatingDialog{
sdif.addButton("", () -> {})
.update(t -> {
t.setText(state.difficulty.toString());
t.setTouchable(Touchable.disabled);
t.touchable(Touchable.disabled);
}).width(180f);
sdif.addImageButton("icon-arrow-right", 10 * 3, () -> {

18
core/src/io/anuke/mindustry/ui/dialogs/FileChooser.java
View File

@@ -1,22 +1,22 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.files.FileHandle;
import io.anuke.arc.graphics.g2d.GlyphLayout;
import io.anuke.arc.util.Align;
import io.anuke.arc.collection.Array;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.core.Platform;
import io.anuke.arc.util.Time;
import io.anuke.arc.files.FileHandle;
import io.anuke.arc.function.Consumer;
import io.anuke.arc.function.Predicate;
import io.anuke.arc.graphics.g2d.GlyphLayout;
import io.anuke.arc.scene.event.Touchable;
import io.anuke.arc.scene.ui.*;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.scene.ui.layout.Unit;
import io.anuke.arc.scene.utils.UIUtils;
import io.anuke.arc.util.Align;
import io.anuke.arc.util.OS;
import io.anuke.arc.util.Pooling;
import io.anuke.arc.util.Time;
import io.anuke.arc.util.pooling.Pools;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.core.Platform;
import java.util.Arrays;
@@ -73,7 +73,7 @@ public class FileChooser extends FloatingDialog{
cancel.clicked(this::hide);
navigation = new TextField("");
navigation.setTouchable(Touchable.disabled);
navigation.touchable(Touchable.disabled);
files = new Table();
files.marginRight(10);
@@ -180,7 +180,7 @@ public class FileChooser extends FloatingDialog{
GlyphLayout layout = Pools.obtain(GlyphLayout.class, GlyphLayout::new);
layout.setText(Core.font, navigation.getText());
layout.setText(Core.scene.skin.getFont("default-font"), navigation.getText());
if(layout.width < navigation.getWidth()){
navigation.setCursorPosition(0);

4
core/src/io/anuke/mindustry/ui/dialogs/FloatingDialog.java
View File

@@ -1,7 +1,7 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.Input.Keys;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.util.Align;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.game.EventType.ResizeEvent;
@@ -66,7 +66,7 @@ public class FloatingDialog extends Dialog{
buttons().addImageTextButton("$text.back", "icon-arrow-left", 30f, this::hide).size(230f, 64f);
keyDown(key -> {
if(key == Keys.ESCAPE || key == Keys.BACK) {
if(key == KeyCode.ESCAPE || key == KeyCode.BACK) {
Core.app.post(this::hide);
}
});

28
core/src/io/anuke/mindustry/ui/dialogs/GenViewDialog.java
View File

@@ -1,23 +1,23 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.Graphics.Cursor.SystemCursor;
import io.anuke.arc.collection.Array;
import io.anuke.arc.collection.GridMap;
import io.anuke.arc.graphics.Pixmap;
import io.anuke.arc.graphics.Pixmap.Format;
import io.anuke.arc.graphics.Texture;
import io.anuke.arc.collection.Array;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.event.InputEvent;
import io.anuke.arc.scene.event.InputListener;
import io.anuke.arc.util.async.AsyncExecutor;
import io.anuke.mindustry.content.Items;
import io.anuke.mindustry.game.Team;
import io.anuke.mindustry.maps.generation.WorldGenerator.GenResult;
import io.anuke.mindustry.type.Item;
import io.anuke.mindustry.world.ColorMapper;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.event.InputEvent;
import io.anuke.arc.scene.event.InputListener;
import io.anuke.arc.scene.utils.Cursors;
import io.anuke.arc.util.GridMap;
import io.anuke.arc.math.Mathf;
import static io.anuke.mindustry.Vars.sectorSize;
import static io.anuke.mindustry.Vars.world;
@@ -37,13 +37,13 @@ public class GenViewDialog extends FloatingDialog{
float panX, panY;
float lastX, lastY;
int viewsize = 3;
AsyncExecutor async = new AsyncExecutor(Mathf.sqr(viewsize*2));
AsyncExecutor async = new AsyncExecutor(viewsize*2 * viewsize*2);
{
addListener(new InputListener(){
@Override
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button){
Cursors.setHand();
public boolean touchDown(InputEvent event, float x, float y, int pointer, KeyCode button){
Core.graphics.cursor(SystemCursor.hand);
lastX = x;
lastY = y;
return true;
@@ -59,8 +59,8 @@ public class GenViewDialog extends FloatingDialog{
}
@Override
public void touchUp(InputEvent event, float x, float y, int pointer, int button){
Cursors.restoreCursor();
public void touchUp(InputEvent event, float x, float y, int pointer, KeyCode button){
Core.graphics.restoreCursor();
}
});
}
@@ -99,7 +99,7 @@ public class GenViewDialog extends FloatingDialog{
float drawX = x + width/2f+ wx * padSectorSize - tx * padSectorSize - panX % padSectorSize;
float drawY = y + height/2f + wy * padSectorSize - ty * padSectorSize - panY % padSectorSize;
Draw.rect(map.get(wx, wy), drawX, drawY, padSectorSize, padSectorSize);
Draw.rect().tex(map.get(wx, wy)).set(drawX, drawY, padSectorSize, padSectorSize);
}
}
}

11
core/src/io/anuke/mindustry/ui/dialogs/HostDialog.java
View File

@@ -1,14 +1,13 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.scene.ui.ImageButton;
import io.anuke.arc.util.Strings;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.entities.Player;
import io.anuke.mindustry.net.Net;
import io.anuke.arc.Settings;
import io.anuke.arc.util.Time;
import io.anuke.arc.scene.ui.ImageButton;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.util.Strings;
import java.io.IOException;
@@ -37,7 +36,7 @@ public class HostDialog extends FloatingDialog{
ImageButton button = t.addImageButton("white", "clear-full", 40, () -> {
new ColorPickDialog().show(color -> {
player.color.set(color);
Core.settings.putInt("color-0", Color.rgba8888(color));
Core.settings.put("color-0", Color.rgba8888(color));
Core.settings.save();
});
}).size(54f).get();

33
core/src/io/anuke/mindustry/ui/dialogs/JoinDialog.java
View File

@@ -1,24 +1,23 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.math.MathUtils;
import io.anuke.arc.collection.Array;
import io.anuke.annotations.Annotations.Serialize;
import io.anuke.arc.Core;
import io.anuke.arc.collection.Array;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.scene.style.Drawable;
import io.anuke.arc.scene.ui.*;
import io.anuke.arc.scene.ui.layout.Cell;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.scene.utils.UIUtils;
import io.anuke.arc.util.Strings;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.core.Platform;
import io.anuke.mindustry.entities.Player;
import io.anuke.mindustry.game.Version;
import io.anuke.mindustry.net.Host;
import io.anuke.mindustry.net.Net;
import io.anuke.arc.Settings;
import io.anuke.arc.util.Time;
import io.anuke.arc.scene.style.Drawable;
import io.anuke.arc.scene.ui.*;
import io.anuke.arc.scene.ui.layout.Cell;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.scene.utils.UIUtils;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.util.Strings;
import static io.anuke.mindustry.Vars.*;
@@ -48,7 +47,7 @@ public class JoinDialog extends FloatingDialog{
add.content().add("$text.joingame.ip").padRight(5f).left();
TextField field = add.content().addField(Core.settings.getString("ip"), text -> {
Core.settings.putString("ip", text);
Core.settings.put("ip", text);
Core.settings.save();
}).size(320f, 54f).get();
@@ -145,7 +144,7 @@ public class JoinDialog extends FloatingDialog{
void refreshServer(Server server){
server.content.clear();
server.content.label(() -> Core.bundle.get("text.server.refreshing") + Strings.animated(4, 11, "."));
server.content.label(() -> Core.bundle.get("text.server.refreshing") + Strings.animated(Time.time(), 4, 11, "."));
Net.pingHost(server.ip, server.port, host -> {
String versionString;
@@ -213,7 +212,7 @@ public class JoinDialog extends FloatingDialog{
ImageButton button = t.addImageButton("white", "clear-full", 40, () -> {
new ColorPickDialog().show(color -> {
player.color.set(color);
Core.settings.putInt("color-0", Color.rgba8888(color));
Core.settings.put("color-0", Color.rgba8888(color));
Core.settings.save();
});
}).size(54f).get();
@@ -235,7 +234,7 @@ public class JoinDialog extends FloatingDialog{
Cell<TextButton> cell = ((Table) pane.getParent()).getCell(button);
if(!MathUtils.isEqual(cell.getMinWidth(), pw)){
if(!Mathf.isEqual(cell.getMinWidth(), pw)){
cell.width(pw);
cell.padLeft(pad);
pane.getParent().invalidateHierarchy();
@@ -248,7 +247,7 @@ public class JoinDialog extends FloatingDialog{
local.clear();
local.background((Drawable)null);
local.table("button", t -> t.label(() -> "[accent]" + Core.bundle.get("text.hosts.discovering") + Strings.animated(4, 10f, ".")).pad(10f)).growX();
local.table("button", t -> t.label(() -> "[accent]" + Core.bundle.get("text.hosts.discovering") + Strings.animated(Time.time(), 4, 10f, ".")).pad(10f)).growX();
Net.discoverServers(this::addLocalHost, this::finishLocalHosts);
}

10
core/src/io/anuke/mindustry/ui/dialogs/LanguageDialog.java
View File

@@ -1,6 +1,6 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Settings;
import io.anuke.arc.Core;
import io.anuke.arc.scene.ui.ButtonGroup;
import io.anuke.arc.scene.ui.ScrollPane;
import io.anuke.arc.scene.ui.TextButton;
@@ -33,7 +33,7 @@ public class LanguageDialog extends FloatingDialog{
TextButton button = new TextButton(loc.getDisplayName(loc), "toggle");
button.clicked(() -> {
if(getLocale().equals(loc)) return;
Core.settings.putString("locale", loc.toString());
Core.settings.put("locale", loc.toString());
Core.settings.save();
Log.info("Setting locale: {0}", loc.toString());
ui.showInfo("$text.language.restart");
@@ -67,7 +67,7 @@ public class LanguageDialog extends FloatingDialog{
//check exact locale
for(Locale l : locales){
if(l.equals(Locale.getDefault())){
Core.settings.putString("locale", l.toString());
Core.settings.put("locale", l.toString());
return;
}
}
@@ -75,11 +75,11 @@ public class LanguageDialog extends FloatingDialog{
//find by language
for(Locale l : locales){
if(l.getLanguage().equals(Locale.getDefault().getLanguage())){
Core.settings.putString("locale", l.toString());
Core.settings.put("locale", l.toString());
return;
}
}
Core.settings.putString("locale", new Locale("en").toString());
Core.settings.put("locale", new Locale("en").toString());
}
}

4
core/src/io/anuke/mindustry/ui/dialogs/LoadDialog.java
View File

@@ -8,12 +8,10 @@ import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.core.Platform;
import io.anuke.mindustry.io.SaveIO;
import io.anuke.mindustry.game.Saves.SaveSlot;
import io.anuke.arc.Core;
import io.anuke.arc.util.Time;
import io.anuke.arc.scene.ui.ScrollPane;
import io.anuke.arc.scene.ui.TextButton;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Strings;
@@ -183,7 +181,7 @@ public class LoadDialog extends FloatingDialog{
Log.err(e);
state.set(State.menu);
logic.reset();
threads.runGraphics(() -> ui.showError("$text.save.corrupted"));
ui.showError("$text.save.corrupted");
}
});
}

6
core/src/io/anuke/mindustry/ui/dialogs/LocalPlayerDialog.java
View File

@@ -1,11 +1,11 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.util.Scaling;
import io.anuke.mindustry.entities.Player;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.Core;
import io.anuke.arc.scene.ui.Image;
import io.anuke.arc.scene.ui.layout.Stack;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Scaling;
import io.anuke.mindustry.entities.Player;
import static io.anuke.mindustry.Vars.control;
import static io.anuke.mindustry.Vars.players;

18
core/src/io/anuke/mindustry/ui/dialogs/MapsDialog.java
View File

@@ -1,7 +1,16 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.scene.event.Touchable;
import io.anuke.arc.scene.ui.Image;
import io.anuke.arc.scene.ui.ScrollPane;
import io.anuke.arc.scene.ui.TextButton;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.scene.utils.UIUtils;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Scaling;
import io.anuke.arc.util.Strings;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.core.Platform;
import io.anuke.mindustry.io.MapIO;
@@ -9,15 +18,6 @@ import io.anuke.mindustry.maps.Map;
import io.anuke.mindustry.maps.MapMeta;
import io.anuke.mindustry.maps.MapTileData;
import io.anuke.mindustry.ui.BorderImage;
import io.anuke.arc.scene.event.Touchable;
import io.anuke.arc.scene.ui.Image;
import io.anuke.arc.scene.ui.ScrollPane;
import io.anuke.arc.scene.ui.TextButton;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.scene.utils.UIUtils;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.util.Log;
import io.anuke.arc.util.Strings;
import java.io.DataInputStream;

2
core/src/io/anuke/mindustry/ui/dialogs/MissionDialog.java
View File

@@ -1,8 +1,8 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.maps.Sector;
import io.anuke.arc.util.Bundles;
public class MissionDialog extends FloatingDialog{

12
core/src/io/anuke/mindustry/ui/dialogs/PausedDialog.java
View File

@@ -1,11 +1,11 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Input.Keys;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.net.Net;
import io.anuke.arc.Core;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.scene.style.Drawable;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.net.Net;
import static io.anuke.mindustry.Vars.*;
@@ -22,7 +22,7 @@ public class PausedDialog extends FloatingDialog{
shown(this::rebuild);
keyDown(key -> {
if(key == Keys.ESCAPE || key == Keys.BACK) {
if(key == KeyCode.ESCAPE || key == KeyCode.BACK) {
hide();
}
});
@@ -111,7 +111,7 @@ public class PausedDialog extends FloatingDialog{
control.saves.getCurrent().save();
}catch(Throwable e){
e.printStackTrace();
threads.runGraphics(() -> ui.showError("[accent]" + Core.bundle.get("text.savefail")));
ui.showError("[accent]" + Core.bundle.get("text.savefail"));
}
state.set(State.menu);
});

2
core/src/io/anuke/mindustry/ui/dialogs/RestartDialog.java
View File

@@ -1,9 +1,9 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.game.Team;
import io.anuke.mindustry.maps.Sector;
import io.anuke.arc.util.Bundles;
import static io.anuke.mindustry.Vars.*;

8
core/src/io/anuke/mindustry/ui/dialogs/SaveDialog.java
View File

@@ -1,10 +1,10 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.scene.ui.TextButton;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.game.Saves.SaveSlot;
import io.anuke.arc.util.Time;
import io.anuke.arc.scene.ui.TextButton;
import io.anuke.arc.util.Bundles;
import static io.anuke.mindustry.Vars.*;
@@ -26,7 +26,7 @@ public class SaveDialog extends LoadDialog{
ui.showTextInput("$text.save", "$text.save.newslot", "", text -> {
ui.loadGraphics("$text.saving", () -> {
control.saves.addSave(text);
threads.runGraphics(() -> threads.run(() -> threads.runGraphics(this::setup)));
Core.app.post(() -> Core.app.post(this::setup));
});
})
).fillX().margin(10f).minWidth(300f).height(70f).pad(4f).padRight(-4);

41
core/src/io/anuke/mindustry/ui/dialogs/SectorsDialog.java
View File

@@ -2,14 +2,11 @@ package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.math.GridPoint2;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.util.Align;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.maps.Sector;
import io.anuke.arc.Graphics;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.math.geom.Geometry;
import io.anuke.arc.math.geom.Point2;
import io.anuke.arc.math.geom.Vector2;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.Group;
import io.anuke.arc.scene.event.InputEvent;
@@ -18,10 +15,10 @@ import io.anuke.arc.scene.event.Touchable;
import io.anuke.arc.scene.ui.layout.Cell;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.scene.ui.layout.Unit;
import io.anuke.arc.scene.utils.Cursors;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.util.Geometry;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Align;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.maps.Sector;
import static io.anuke.mindustry.Vars.world;
@@ -54,7 +51,7 @@ public class SectorsDialog extends FloatingDialog{
});
Group container = new Group();
container.setTouchable(Touchable.childrenOnly);
container.touchable(Touchable.childrenOnly);
container.addChild(table);
margin(0);
@@ -133,7 +130,7 @@ public class SectorsDialog extends FloatingDialog{
SectorView(){
addListener(new InputListener(){
@Override
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button){
public boolean touchDown(InputEvent event, float x, float y, int pointer, KeyCode button){
if(pointer != 0) return false;
//Cursors.setHand();
lastX = x;
@@ -152,9 +149,9 @@ public class SectorsDialog extends FloatingDialog{
}
@Override
public void touchUp(InputEvent event, float x, float y, int pointer, int button){
public void touchUp(InputEvent event, float x, float y, int pointer, KeyCode button){
if(pointer != 0) return;
Cursors.restoreCursor();
//Cursors.restoreCursor();
}
});
@@ -183,7 +180,7 @@ public class SectorsDialog extends FloatingDialog{
@Override
public void draw(){
Draw.alpha(alpha);
Draw.alpha(parentAlpha);
int shownSectorsX = (int)(width/sectorSize);
int shownSectorsY = (int)(height/sectorSize);
@@ -191,7 +188,7 @@ public class SectorsDialog extends FloatingDialog{
int offsetX = (int)(panX / sectorSize);
int offsetY = (int)(panY / sectorSize);
Vector2 mouse = Graphics.mouse();
Vector2 mouse = Core.input.mouse();
for(int x = -shownSectorsX; x <= shownSectorsX; x++){
for(int y = -shownSectorsY; y <= shownSectorsY; y++){
@@ -208,10 +205,10 @@ public class SectorsDialog extends FloatingDialog{
Draw.rect("empty-sector", drawX, drawY, sectorSize, sectorSize);
int i = 0;
for(GridPoint2 point : Geometry.d4){
for(Point2 point : Geometry.d4){
Sector other = world.sectors.get(sectorX + point.x, sectorY + point.y);
if(other != null){
Draw.rect("sector-edge", drawX, drawY, sectorSize, sectorSize, i*90);
Draw.rect("sector-edge", drawX, drawY, sectorSize, sectorSize).rot(i*90);
}
i ++;
@@ -220,7 +217,7 @@ public class SectorsDialog extends FloatingDialog{
}
Draw.colorl(!sector.complete ? 0.3f : 1f);
Draw.rect(sector.texture, drawX, drawY, sectorSize, sectorSize);
Draw.rect().tex(sector.texture).center(drawX, drawY, sectorSize, sectorSize);
if(sector.missions.size == 0) continue;
@@ -236,8 +233,8 @@ public class SectorsDialog extends FloatingDialog{
if(sector == selected){
selectColor = Palette.accent;
}else if(Mathf.inRect(mouse.x, mouse.y, drawX - sectorSize / 2f, drawY - sectorSize / 2f,
drawX + sectorSize / 2f, drawY + sectorSize / 2f)){
}else if(mouse.x > drawX - sectorSize / 2f && mouse.y > drawY - sectorSize / 2f
&& mouse.x < drawX + sectorSize / 2f && mouse.y < drawY + sectorSize / 2f){
if(clicked){
selectSector(sector);
}

41
core/src/io/anuke/mindustry/ui/dialogs/SettingsMenuDialog.java
View File

@@ -1,14 +1,10 @@
package io.anuke.mindustry.ui.dialogs;
import io.anuke.arc.Core;
import io.anuke.arc.Input.Keys;
import io.anuke.arc.collection.ObjectMap;
import io.anuke.arc.files.FileHandle;
import io.anuke.arc.util.Align;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.net.Net;
import io.anuke.arc.function.Consumer;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.event.InputEvent;
import io.anuke.arc.scene.event.InputListener;
@@ -18,11 +14,11 @@ import io.anuke.arc.scene.ui.SettingsDialog;
import io.anuke.arc.scene.ui.SettingsDialog.SettingsTable.Setting;
import io.anuke.arc.scene.ui.Slider;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.math.Mathf;
import java.util.HashMap;
import java.util.Map;
import io.anuke.arc.util.Align;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.net.Net;
import static io.anuke.mindustry.Vars.*;
@@ -36,7 +32,7 @@ public class SettingsMenuDialog extends SettingsDialog{
private boolean wasPaused;
public SettingsMenuDialog(){
setStyle(Core.skin.get("dialog", WindowStyle.class));
setStyle(Core.scene.skin.get("dialog", WindowStyle.class));
hidden(() -> {
if(!state.is(State.menu)){
@@ -96,7 +92,7 @@ public class SettingsMenuDialog extends SettingsDialog{
ScrollPane pane = new ScrollPane(prefs);
pane.addCaptureListener(new InputListener(){
@Override
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button){
public boolean touchDown(InputEvent event, float x, float y, int pointer, KeyCode button){
Element actor = pane.hit(x, y, true);
if(actor instanceof Slider){
pane.setFlickScroll(false);
@@ -107,7 +103,7 @@ public class SettingsMenuDialog extends SettingsDialog{
}
@Override
public void touchUp(InputEvent event, float x, float y, int pointer, int button){
public void touchUp(InputEvent event, float x, float y, int pointer, KeyCode button){
pane.setFlickScroll(true);
super.touchUp(event, x, y, pointer, button);
}
@@ -125,7 +121,8 @@ public class SettingsMenuDialog extends SettingsDialog{
}
void addSettings(){
sound.volumePrefs();
//TODO add when sound works again
//sound.volumePrefs();
game.screenshakePref();
game.checkPref("effects", true);
@@ -162,14 +159,14 @@ public class SettingsMenuDialog extends SettingsDialog{
dialog.content().row();
dialog.content().addButton("$text.settings.clearall", () -> {
ui.showConfirm("$text.confirm", "$text.settings.clearall.confirm", () -> {
Map<String, Object> map = new HashMap<>();
for(String value : Core.settings.prefs().get().keySet()){
ObjectMap<String, Object> map = new ObjectMap<>();
for(String value : Core.settings.keys()){
if(value.contains("usid") || value.contains("uuid")){
map.put(value, Core.settings.prefs().getString(value));
map.put(value, Core.settings.getString(value));
}
}
Core.settings.prefs().clear();
Core.settings.prefs().put(map);
Core.settings.clear();
Core.settings.putAll(map);
Core.settings.save();
for(FileHandle file : dataDirectory.list()){
@@ -218,7 +215,7 @@ public class SettingsMenuDialog extends SettingsDialog{
private void visible(int index){
prefs.clearChildren();
Table table = Mathf.select(index, game, graphics, sound);
Table table = new Table[]{game, graphics, sound}[index];
prefs.add(table);
}
@@ -227,7 +224,7 @@ public class SettingsMenuDialog extends SettingsDialog{
buttons().addImageTextButton("$text.menu", "icon-arrow-left", 30f, this::hide).size(230f, 64f);
keyDown(key -> {
if(key == Keys.ESCAPE || key == Keys.BACK)
if(key == KeyCode.ESCAPE || key == KeyCode.BACK)
hide();
});
}

22
core/src/io/anuke/mindustry/ui/fragments/BackgroundFragment.java
View File

@@ -1,16 +1,14 @@
package io.anuke.mindustry.ui.fragments;
import io.anuke.arc.Core;
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.scene.Group;
import io.anuke.arc.scene.ui.layout.Unit;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.graphics.Shaders;
import io.anuke.arc.Core;
import io.anuke.arc.Graphics;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.Fill;
import io.anuke.arc.scene.Group;
import io.anuke.arc.scene.ui.layout.Unit;
import static io.anuke.mindustry.Vars.state;
@@ -20,21 +18,21 @@ public class BackgroundFragment extends Fragment{
public void build(Group parent){
Core.scene.table().addRect((a, b, w, h) -> {
Draw.colorl(0.1f);
Fill.crect(0, 0, w, h);
Fill.rect().set(0, 0, w, h);
Draw.color(Palette.accent);
Graphics.shader(Shaders.menu);
Fill.crect(0, 0, w, h);
Graphics.shader();
Draw.shader(Shaders.menu);
Fill.rect().set(0, 0, w, h);
Draw.shader();
Draw.color();
boolean portrait = Core.graphics.getWidth() < Core.graphics.getHeight();
float logoscl = (int) Unit.dp.scl(7) * (portrait ? 5f / 7f : 1f);
TextureRegion logo = Core.skin.getRegion("logotext");
TextureRegion logo = Core.atlas.find("logotext");
float logow = logo.getWidth() * logoscl;
float logoh = logo.getHeight() * logoscl;
Draw.color();
Core.batch.draw(logo, (int) (w / 2 - logow / 2), (int) (h - logoh + 15 - Unit.dp.scl(portrait ? 30f : 0)), logow, logoh);
Draw.rect().tex(logo).set((int) (w / 2 - logow / 2), (int) (h - logoh + 15 - Unit.dp.scl(portrait ? 30f : 0)), logow, logoh);
}).visible(() -> state.is(State.menu)).grow();
}
}

15
core/src/io/anuke/mindustry/ui/fragments/BlockConfigFragment.java
View File

@@ -2,18 +2,17 @@ package io.anuke.mindustry.ui.fragments;
import io.anuke.arc.Core;
import io.anuke.arc.math.Interpolation;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.math.geom.Vector2;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.Group;
import io.anuke.arc.scene.actions.Actions;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Align;
import io.anuke.mindustry.content.blocks.Blocks;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.input.InputHandler;
import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.Tile;
import io.anuke.arc.Graphics;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.Group;
import io.anuke.arc.scene.actions.Actions;
import io.anuke.arc.scene.ui.layout.Table;
import static io.anuke.mindustry.Vars.state;
import static io.anuke.mindustry.Vars.tilesize;
@@ -45,7 +44,7 @@ public class BlockConfigFragment extends Fragment{
configTile = tile;
configBlock = tile.block();
table.setVisible(true);
table.visible(true);
table.clear();
tile.block().buildTable(tile, table);
table.pack();
@@ -65,7 +64,7 @@ public class BlockConfigFragment extends Fragment{
}
table.setOrigin(Align.center);
Vector2 pos = Graphics.screen(tile.drawx(), tile.drawy() - tile.block().size * tilesize / 2f - 1);
Vector2 pos = Core.input.mouseScreen(tile.drawx(), tile.drawy() - tile.block().size * tilesize / 2f - 1);
table.setPosition(pos.x, pos.y, Align.top);
if(configTile == null || configTile.block() == Blocks.air || configTile.block() != configBlock){
hideConfig();

15
core/src/io/anuke/mindustry/ui/fragments/BlockConsumeFragment.java
View File

@@ -1,20 +1,19 @@
package io.anuke.mindustry.ui.fragments;
import io.anuke.arc.Core;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.util.Align;
import io.anuke.arc.collection.ObjectSet;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.math.geom.Vector2;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.Group;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.util.Align;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.entities.TileEntity;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.Tile;
import io.anuke.mindustry.world.consumers.Consume;
import io.anuke.arc.Graphics;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.Group;
import io.anuke.arc.scene.ui.layout.Table;
import static io.anuke.mindustry.Vars.*;
@@ -86,7 +85,7 @@ public class BlockConsumeFragment extends Fragment{
rebuild(block, entity);
}
Vector2 v = Graphics.screen(tile.drawx() - tile.block().size * tilesize / 2f + 0.25f, tile.drawy() + tile.block().size * tilesize / 2f);
Vector2 v = Core.input.mouseScreen(tile.drawx() - tile.block().size * tilesize / 2f + 0.25f, tile.drawy() + tile.block().size * tilesize / 2f);
table.pack();
table.setPosition(v.x, v.y, Align.topRight);
});

39
core/src/io/anuke/mindustry/ui/fragments/BlockInventoryFragment.java
View File

@@ -1,21 +1,14 @@
package io.anuke.mindustry.ui.fragments;
import io.anuke.arc.math.Interpolation;
import io.anuke.arc.math.Vector2;
import io.anuke.arc.util.Align;
import io.anuke.arc.util.IntSet;
import io.anuke.annotations.Annotations.Loc;
import io.anuke.annotations.Annotations.Remote;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.entities.Player;
import io.anuke.mindustry.gen.Call;
import io.anuke.mindustry.input.InputHandler;
import io.anuke.mindustry.type.Item;
import io.anuke.mindustry.ui.ItemImage;
import io.anuke.mindustry.world.Tile;
import io.anuke.arc.Graphics;
import io.anuke.arc.util.Time;
import io.anuke.arc.Core;
import io.anuke.arc.collection.IntSet;
import io.anuke.arc.function.BooleanProvider;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.math.Interpolation;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.math.geom.Vector2;
import io.anuke.arc.scene.Group;
import io.anuke.arc.scene.actions.Actions;
import io.anuke.arc.scene.event.HandCursorListener;
@@ -23,8 +16,16 @@ import io.anuke.arc.scene.event.InputEvent;
import io.anuke.arc.scene.event.InputListener;
import io.anuke.arc.scene.event.Touchable;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Align;
import io.anuke.arc.util.Strings;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.entities.Player;
import io.anuke.mindustry.gen.Call;
import io.anuke.mindustry.input.InputHandler;
import io.anuke.mindustry.type.Item;
import io.anuke.mindustry.ui.ItemImage;
import io.anuke.mindustry.world.Tile;
import static io.anuke.mindustry.Vars.*;
@@ -75,7 +76,7 @@ public class BlockInventoryFragment extends Fragment{
table.clear();
table.update(null);
}));
table.setTouchable(Touchable.disabled);
table.touchable(Touchable.disabled);
tile = null;
}
@@ -87,7 +88,7 @@ public class BlockInventoryFragment extends Fragment{
table.clearChildren();
table.background("inventory");
table.setTouchable(Touchable.enabled);
table.touchable(Touchable.enabled);
table.update(() -> {
if(state.is(State.menu) || tile == null || tile.entity == null || !tile.block().isAccessible() || tile.entity.items.total() == 0){
hide();
@@ -144,7 +145,7 @@ public class BlockInventoryFragment extends Fragment{
image.addListener(new InputListener(){
@Override
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button){
public boolean touchDown(InputEvent event, float x, float y, int pointer, KeyCode button){
if(!canPick.get() || !tile.entity.items.has(item)) return false;
int amount = Math.min(1, player.inventory.itemCapacityUsed(item));
Call.requestItem(player, tile, item, amount);
@@ -155,7 +156,7 @@ public class BlockInventoryFragment extends Fragment{
}
@Override
public void touchUp(InputEvent event, float x, float y, int pointer, int button){
public void touchUp(InputEvent event, float x, float y, int pointer, KeyCode button){
holding = false;
lastItem = null;
}
@@ -190,7 +191,7 @@ public class BlockInventoryFragment extends Fragment{
}
private void updateTablePosition(){
Vector2 v = Graphics.screen(tile.drawx() + tile.block().size * tilesize / 2f, tile.drawy() + tile.block().size * tilesize / 2f);
Vector2 v = Core.input.mouseScreen(tile.drawx() + tile.block().size * tilesize / 2f, tile.drawy() + tile.block().size * tilesize / 2f);
table.pack();
table.setPosition(v.x, v.y, Align.topLeft);
}

71
core/src/io/anuke/mindustry/ui/fragments/ChatFragment.java
View File

@@ -1,19 +1,14 @@
package io.anuke.mindustry.ui.fragments;
import io.anuke.arc.Core;
import io.anuke.arc.Input.Keys;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.g2d.Batch;
import io.anuke.arc.graphics.g2d.BitmapFont;
import io.anuke.arc.graphics.g2d.GlyphLayout;
import io.anuke.arc.util.Align;
import io.anuke.arc.collection.Array;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.gen.Call;
import io.anuke.mindustry.net.Net;
import io.anuke.arc.Inputs;
import io.anuke.arc.util.Time;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.g2d.BitmapFont;
import io.anuke.arc.graphics.g2d.Draw;
import io.anuke.arc.graphics.g2d.Fill;
import io.anuke.arc.graphics.g2d.GlyphLayout;
import io.anuke.arc.input.KeyCode;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.scene.Group;
import io.anuke.arc.scene.ui.Dialog;
import io.anuke.arc.scene.ui.Label;
@@ -21,11 +16,17 @@ import io.anuke.arc.scene.ui.Label.LabelStyle;
import io.anuke.arc.scene.ui.TextField;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.scene.ui.layout.Unit;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Align;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.Vars;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.gen.Call;
import io.anuke.mindustry.input.Binding;
import io.anuke.mindustry.net.Net;
import static io.anuke.arc.Core.input;
import static io.anuke.arc.Core.scene;
import static io.anuke.mindustry.Vars.*;
import static io.anuke.arc.core.Core.scene;
import static io.anuke.arc.core.Core.skin;
public class ChatFragment extends Table{
private final static int messagesShown = 10;
@@ -54,7 +55,7 @@ public class ChatFragment extends Table{
super();
setFillParent(true);
font = Core.skin.getFont("default-font");
font = scene.skin.getFont("default-font");
visible(() -> {
if(!Net.active() && messages.size > 0){
@@ -70,21 +71,21 @@ public class ChatFragment extends Table{
update(() -> {
if(Net.active() && Core.input.keyTap("chat")){
if(Net.active() && input.keyTap(Binding.chat)){
toggle();
}
if(chatOpen){
if(Core.input.keyTap("chat_history_prev") && historyPos < history.size - 1){
if(input.keyTap(Binding.chat_history_prev) && historyPos < history.size - 1){
if(historyPos == 0) history.set(0, chatfield.getText());
historyPos++;
updateChat();
}
if(Core.input.keyTap("chat_history_next") && historyPos > 0){
if(input.keyTap(Binding.chat_history_next) && historyPos > 0){
historyPos--;
updateChat();
}
scrollPos = (int) Mathf.clamp(scrollPos + Core.input.getAxis("chat_scroll"), 0, Math.max(0, messages.size - messagesShown));
scrollPos = (int) Mathf.clamp(scrollPos + input.axis(Binding.chat_scroll), 0, Math.max(0, messages.size - messagesShown));
}
});
@@ -107,10 +108,10 @@ public class ChatFragment extends Table{
fieldlabel.getStyle().font = font;
fieldlabel.setStyle(fieldlabel.getStyle());
chatfield = new TextField("", new TextField.TextFieldStyle(skin.get(TextField.TextFieldStyle.class)));
chatfield = new TextField("", new TextField.TextFieldStyle(scene.skin.get(TextField.TextFieldStyle.class)));
chatfield.setTextFieldFilter((field, c) -> field.getText().length() < Vars.maxTextLength);
chatfield.getStyle().background = null;
chatfield.getStyle().font = skin.getFont("default-font-chat");
chatfield.getStyle().font = scene.skin.getFont("default-font-chat");
chatfield.getStyle().fontColor = Color.WHITE;
chatfield.setStyle(chatfield.getStyle());
@@ -122,7 +123,7 @@ public class ChatFragment extends Table{
dialog.content().defaults().height(65f);
TextField to = dialog.content().addField("", t-> {}).pad(15).width(250f).get();
to.setMaxLength(maxTextLength);
to.keyDown(Keys.ENTER, () -> dialog.content().find("okb").fireClick());
to.keyDown(KeyCode.ENTER, () -> dialog.content().find("okb").fireClick());
dialog.content().addButton("$text.ok", () -> {
chatfield.clearText();
chatfield.appendText(to.getText());
@@ -152,22 +153,22 @@ public class ChatFragment extends Table{
}
@Override
public void draw(Batch batch, float alpha){
public void draw(){
batch.setColor(shadowColor);
Draw.color(shadowColor);
if(chatOpen){
batch.draw(skin.getRegion("white"), offsetx, chatfield.getY(), chatfield.getWidth() + 15f, chatfield.getHeight() - 1);
Fill.rect().set(offsetx, chatfield.getY(), chatfield.getWidth() + 15f, chatfield.getHeight() - 1);
}
super.draw(batch, alpha);
super.draw();
float spacing = chatspace;
chatfield.setVisible(chatOpen);
fieldlabel.setVisible(chatOpen);
chatfield.visible(chatOpen);
fieldlabel.visible(chatOpen);
batch.setColor(shadowColor);
Draw.color(shadowColor);
float theight = offsety + spacing + getMarginBottom();
for(int i = scrollPos; i < messages.size && i < messagesShown + scrollPos && (i < fadetime || chatOpen); i++){
@@ -181,16 +182,16 @@ public class ChatFragment extends Table{
if(!chatOpen && fadetime - i < 1f && fadetime - i >= 0f){
font.getCache().setAlphas(fadetime - i);
batch.setColor(0, 0, 0, shadowColor.a * (fadetime - i));
Draw.color(0, 0, 0, shadowColor.a * (fadetime - i));
}
batch.draw(skin.getRegion("white"), offsetx, theight - layout.height - 2, textWidth + Unit.dp.scl(4f), layout.height + textspacing);
batch.setColor(shadowColor);
Fill.rect().set(offsetx, theight - layout.height - 2, textWidth + Unit.dp.scl(4f), layout.height + textspacing);
Draw.color(shadowColor);
font.getCache().draw(batch);
font.getCache().draw();
}
batch.setColor(Color.WHITE);
Draw.color();
if(fadetime > 0 && !chatOpen)
fadetime -= Time.delta() / 180f;

58
core/src/io/anuke/mindustry/ui/fragments/HudFragment.java
View File

@@ -1,25 +1,12 @@
package io.anuke.mindustry.ui.fragments;
import io.anuke.arc.Core;
import io.anuke.arc.Events;
import io.anuke.arc.collection.Array;
import io.anuke.arc.graphics.Color;
import io.anuke.arc.graphics.g2d.TextureRegion;
import io.anuke.arc.math.Interpolation;
import io.anuke.arc.util.Align;
import io.anuke.arc.collection.Array;
import io.anuke.arc.util.Scaling;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.game.EventType.StateChangeEvent;
import io.anuke.mindustry.game.Team;
import io.anuke.mindustry.gen.Call;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.net.Net;
import io.anuke.mindustry.net.Packets.AdminAction;
import io.anuke.mindustry.type.Recipe;
import io.anuke.mindustry.ui.IntFormat;
import io.anuke.mindustry.ui.Minimap;
import io.anuke.mindustry.ui.dialogs.FloatingDialog;
import io.anuke.arc.*;
import io.anuke.arc.graphics.Hue;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.scene.Element;
import io.anuke.arc.scene.Group;
import io.anuke.arc.scene.actions.Actions;
@@ -31,8 +18,21 @@ import io.anuke.arc.scene.ui.TextButton;
import io.anuke.arc.scene.ui.layout.Stack;
import io.anuke.arc.scene.ui.layout.Table;
import io.anuke.arc.scene.ui.layout.Unit;
import io.anuke.arc.util.Bundles;
import io.anuke.arc.math.Mathf;
import io.anuke.arc.util.Align;
import io.anuke.arc.util.Scaling;
import io.anuke.arc.util.Time;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.game.EventType.StateChangeEvent;
import io.anuke.mindustry.game.Team;
import io.anuke.mindustry.gen.Call;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.input.Binding;
import io.anuke.mindustry.net.Net;
import io.anuke.mindustry.net.Packets.AdminAction;
import io.anuke.mindustry.type.Recipe;
import io.anuke.mindustry.ui.IntFormat;
import io.anuke.mindustry.ui.Minimap;
import io.anuke.mindustry.ui.dialogs.FloatingDialog;
import static io.anuke.mindustry.Vars.*;
@@ -75,10 +75,10 @@ public class HudFragment extends Fragment{
}
}).update(i -> {
if(Net.active()){
i.getStyle().imageUp = Core.skin.getDrawable("icon-players");
i.getStyle().imageUp = Core.scene.skin.getDrawable("icon-players");
}else{
i.setDisabled(Net.active());
i.getStyle().imageUp = Core.skin.getDrawable(state.is(State.paused) ? "icon-play" : "icon-pause");
i.getStyle().imageUp = Core.scene.skin.getDrawable(state.is(State.paused) ? "icon-play" : "icon-pause");
}
}).get();
@@ -94,9 +94,9 @@ public class HudFragment extends Fragment{
}
}).update(i -> {
if(Net.active() && mobile){
i.getStyle().imageUp = Core.skin.getDrawable("icon-chat");
i.getStyle().imageUp = Core.scene.skin.getDrawable("icon-chat");
}else{
i.getStyle().imageUp = Core.skin.getDrawable("icon-unlocks");
i.getStyle().imageUp = Core.scene.skin.getDrawable("icon-unlocks");
}
}).get();
@@ -109,7 +109,7 @@ public class HudFragment extends Fragment{
}
cont.update(() -> {
if(!Core.input.keyDown("gridMode") && Core.input.keyTap("toggle_menus") && !ui.chatfrag.chatOpen()){
if(!Core.input.keyDown(Binding.gridMode) && Core.input.keyTap(Binding.toggle_menus) && !ui.chatfrag.chatOpen()){
toggleMenus();
}
});
@@ -198,7 +198,7 @@ public class HudFragment extends Fragment{
return coreAttackOpacity > 0;
});
t.table("button", top -> top.add("$text.coreattack").pad(2)
.update(label -> label.setColor(Hue.mix(Color.ORANGE, Color.SCARLET, Mathf.absin(Time.time(), 2f, 1f)))));
.update(label -> label.getColor().set(Color.ORANGE).lerp(Color.SCARLET, Mathf.absin(Time.time(), 2f, 1f))));
});
//'saving' indicator
@@ -207,7 +207,7 @@ public class HudFragment extends Fragment{
t.add("$text.saveload");
});
blockfrag.build(Core.scene.getRoot());
blockfrag.build(Core.scene.root);
}
public void showToast(String text){
@@ -345,7 +345,7 @@ public class HudFragment extends Fragment{
Interpolation in = Interpolation.pow3Out;
if(flip != null){
flip.getStyle().imageUp = Core.skin.getDrawable(shown ? "icon-arrow-down" : "icon-arrow-up");
flip.getStyle().imageUp = Core.scene.skin.getDrawable(shown ? "icon-arrow-down" : "icon-arrow-up");
}
if(shown){
@@ -368,7 +368,7 @@ public class HudFragment extends Fragment{
IntFormat enemiesf = new IntFormat("text.wave.enemies");
table.clearChildren();
table.setTouchable(Touchable.enabled);
table.touchable(Touchable.enabled);
table.labelWrap(() ->
world.getSector() == null ?
@@ -403,8 +403,8 @@ public class HudFragment extends Fragment{
boolean vis = state.mode.disableWaveTimer && ((Net.server() || players[0].isAdmin) || !Net.active());
boolean paused = state.is(State.paused) || !vis;
l.getStyle().imageUp = Core.skin.getDrawable(vis ? "icon-play" : "clear");
l.setTouchable(!paused ? Touchable.enabled : Touchable.disabled);
l.getStyle().imageUp = Core.scene.skin.getDrawable(vis ? "icon-play" : "clear");
l.touchable(!paused ? Touchable.enabled : Touchable.disabled);
}).visible(() -> state.mode.disableWaveTimer && ((Net.server() || players[0].isAdmin) || !Net.active()) && unitGroups[Team.red.ordinal()].size() == 0);
}
}

14
core/src/io/anuke/mindustry/ui/fragments/LoadingFragment.java
View File

@@ -14,8 +14,8 @@ public class LoadingFragment extends Fragment{
@Override
public void build(Group parent){
parent.fill("loadDim", t -> {
t.setVisible(false);
t.setTouchable(Touchable.enabled);
t.visible(false);
t.touchable(Touchable.enabled);
t.add().height(70f).row();
t.addImage("white").growX().height(3f).pad(4f).growX().get().setColor(Palette.accent);
@@ -31,8 +31,8 @@ public class LoadingFragment extends Fragment{
}
public void setButton(Runnable listener){
button.setVisible(true);
button.getListeners().removeIndex(button.getListeners().size - 1);
button.visible(true);
button.getListeners().removeAt(button.getListeners().size - 1);
button.clicked(listener);
}
@@ -42,12 +42,12 @@ public class LoadingFragment extends Fragment{
public void show(String text){
table.<Label>find("namelabel").setText(text);
table.setVisible(true);
table.visible(true);
table.toFront();
}
public void hide(){
table.setVisible(false);
button.setVisible(false);
table.visible(false);
button.visible(false);
}
}

3
core/src/io/anuke/mindustry/ui/fragments/OverlayFragment.java
View File

@@ -12,11 +12,8 @@ public class OverlayFragment extends Fragment{
public final BlockConsumeFragment consume;
private Group group = new Group();
private InputHandler input;
public OverlayFragment(InputHandler input){
this.input = input;
inv = new BlockInventoryFragment(input);
config = new BlockConfigFragment(input);
consume = new BlockConsumeFragment();

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