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

Implemented desktop line placement

Browse Source
This commit is contained in:
Anuken
2018-05-30 12:40:51 -04:00
parent b5966afe25
commit 9d05cfba36
8 changed files with 168 additions and 457 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/src/io/anuke/mindustry/graphics/Palette.java
View File

@@ -42,7 +42,7 @@ public class Palette {
public static final Color accent = Color.valueOf("f4ba6e");
public static final Color place = Color.valueOf("6335f8");
public static final Color remove = Color.valueOf("e55454");
public static final Color placeRotate = Color.ORANGE;
public static final Color placeRotate = accent;
public static final Color breakInvalid = Color.valueOf("d44b3d");
public static final Color range = Color.valueOf("f4ba6e");
public static final Color power = Color.valueOf("fbd367");

8
core/src/io/anuke/mindustry/input/AndroidInput.java
View File

@@ -200,7 +200,7 @@ public class AndroidInput extends InputHandler implements GestureListener{
if(tile == null) continue;
if(validPlace(tile.x, tile.y, request.recipe.result)){
if(validPlace(tile.x, tile.y, request.recipe.result, request.rotation)){
request.scale = Mathf.lerpDelta(request.scale, 1f, 0.2f);
request.redness = Mathf.lerpDelta(request.redness, 0f, 0.2f);
}else{
@@ -231,7 +231,7 @@ public class AndroidInput extends InputHandler implements GestureListener{
int x = lineStartX + i * Mathf.sign(tile.x - lineStartX) * Mathf.bool(result.isX());
int y = lineStartY + i * Mathf.sign(tile.y - lineStartY) * Mathf.bool(!result.isX());
if(!checkOverlapPlacement(x, y, recipe.result) && validPlace(x, y, recipe.result)){
if(!checkOverlapPlacement(x, y, recipe.result) && validPlace(x, y, recipe.result, result.rotation)){
Draw.color();
TextureRegion[] regions = recipe.result.getBlockIcon();
@@ -306,7 +306,7 @@ public class AndroidInput extends InputHandler implements GestureListener{
int x = lineStartX + i * Mathf.sign(tile.x - lineStartX) * Mathf.bool(result.isX());
int y = lineStartY + i * Mathf.sign(tile.y - lineStartY) * Mathf.bool(!result.isX());
if(!checkOverlapPlacement(x, y, recipe.result) && validPlace(x, y, recipe.result)){
if(!checkOverlapPlacement(x, y, recipe.result) && validPlace(x, y, recipe.result, result.rotation)){
PlaceRequest request = new PlaceRequest(x * tilesize, y * tilesize, recipe, result.rotation);
request.scale = 1f;
placement.add(request);
@@ -352,7 +352,7 @@ public class AndroidInput extends InputHandler implements GestureListener{
//remove if request present
if(hasRequest(cursor)) {
removeRequest(getRequest(cursor));
}else if(isPlacing() && validPlace(cursor.x, cursor.y, recipe.result) && !checkOverlapPlacement(cursor.x, cursor.y, recipe.result)){
}else if(isPlacing() && validPlace(cursor.x, cursor.y, recipe.result, rotation) && !checkOverlapPlacement(cursor.x, cursor.y, recipe.result)){
//add to placement queue if it's a valid place position
placement.add(new PlaceRequest(cursor.worldx(), cursor.worldy(), recipe, rotation));
}

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

@@ -2,14 +2,19 @@ package io.anuke.mindustry.input;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Buttons;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import io.anuke.mindustry.core.GameState.State;
import io.anuke.mindustry.entities.Player;
import io.anuke.mindustry.input.PlaceUtils.NormalizeDrawResult;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.input.PlaceUtils.NormalizeResult;
import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.Tile;
import io.anuke.ucore.core.Inputs;
import io.anuke.ucore.core.Inputs.DeviceType;
import io.anuke.ucore.core.KeyBinds;
import io.anuke.ucore.core.Settings;
import io.anuke.ucore.graphics.Draw;
import io.anuke.ucore.graphics.Lines;
import io.anuke.ucore.scene.ui.layout.Unit;
import io.anuke.ucore.scene.utils.Cursors;
import io.anuke.ucore.util.Mathf;
@@ -20,7 +25,7 @@ public class DesktopInput extends InputHandler{
//controller info
private float controlx, controly;
private boolean controlling;
private boolean showCursor = false;
private boolean handCursor;
private final String section;
/**Position where the player started dragging a line.*/
@@ -57,6 +62,22 @@ public class DesktopInput extends InputHandler{
tile.block().tapped(tile, player);
}
void drawPlace(int x, int y, Block block, int rotation){
if(validPlace(x, y, block, rotation)){
Draw.color();
TextureRegion[] regions = block.getBlockIcon();
for(TextureRegion region : regions){
Draw.rect(region, x *tilesize + block.offset(), y * tilesize + block.offset(),
region.getRegionWidth() * selectScale, region.getRegionHeight() * selectScale, block.rotate ? rotation * 90 : 0);
}
}else{
Draw.color(Palette.remove);
Lines.square(x*tilesize + block.offset(), y*tilesize + block.offset(), block.size * tilesize/2f);
}
}
@Override
public void drawBottom(){
Tile cursor = tileAt(control.gdxInput().getX(), control.gdxInput().getY());
@@ -65,10 +86,32 @@ public class DesktopInput extends InputHandler{
//draw selection
if(selecting){
NormalizeDrawResult result = PlaceUtils.normalizeDrawArea(recipe.result, selectX, selectY, cursor.x, cursor.y, true, maxLength, selectScale);
NormalizeResult result = PlaceUtils.normalizeArea(selectX, selectY, cursor.x, cursor.y, rotation, true, maxLength);
for(int i = 0; i <= result.getLength(); i += recipe.result.size){
int x = selectX + i * Mathf.sign(cursor.x - selectX) * Mathf.bool(result.isX());
int y = selectY + i * Mathf.sign(cursor.y - selectY) * Mathf.bool(!result.isX());
}
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);
}
drawPlace(x, y, recipe.result, result.rotation);
}
Draw.reset();
}else if(isPlacing()){
if(recipe.result.rotate){
Draw.color(!validPlace(cursor.x, cursor.y, recipe.result, rotation) ? Palette.remove : Palette.placeRotate);
Draw.grect("place-arrow", cursor.worldx() + recipe.result.offset(),
cursor.worldy() + recipe.result.offset(), rotation * 90 - 90);
}
drawPlace(cursor.x, cursor.y, recipe.result, rotation);
}
Draw.reset();
}
@Override
@@ -80,8 +123,8 @@ public class DesktopInput extends InputHandler{
selecting = false;
}
//update select animation
if(selecting){
if(isPlacing()){
handCursor = true;
selectScale = Mathf.lerpDelta(selectScale, 1f, 0.2f);
}else{
selectScale = 0f;
@@ -100,18 +143,18 @@ public class DesktopInput extends InputHandler{
Tile cursor = tileAt(control.gdxInput().getX(), control.gdxInput().getY());
if(cursor != null && cursor.block().isConfigurable(cursor)){
showCursor = true;
handCursor = true;
}
if(!ui.hasMouse()) {
if (showCursor) {
if (handCursor) {
Cursors.setHand();
}else {
Cursors.restoreCursor();
}
}
showCursor = false;
handCursor = false;
}
@Override
@@ -137,6 +180,26 @@ public class DesktopInput extends InputHandler{
public boolean touchUp (int screenX, int screenY, int pointer, int button) {
if(player.isDead() || state.is(State.menu) || ui.hasDialog()) return false;
Tile cursor = tileAt(screenX, screenY);
if(cursor == null){
selecting = false;
return false;
}
if(selecting){
NormalizeResult result = PlaceUtils.normalizeArea(selectX, selectY, cursor.x, cursor.y, rotation, true, maxLength);
for(int i = 0; i <= result.getLength(); i += recipe.result.size){
int x = selectX + i * Mathf.sign(cursor.x - selectX) * Mathf.bool(result.isX());
int y = selectY + i * Mathf.sign(cursor.y - selectY) * Mathf.bool(!result.isX());
rotation = result.rotation;
tryPlaceBlock(x, y);
}
}
selecting = false;
return false;

4
core/src/io/anuke/mindustry/input/InputHandler.java
View File

@@ -169,7 +169,7 @@ public abstract class InputHandler extends InputAdapter{
}
public boolean tryPlaceBlock(int x, int y){
if(recipe != null && validPlace(x, y, recipe.result) && cursorNear()){
if(recipe != null && validPlace(x, y, recipe.result, rotation) && cursorNear()){
placeBlock(x, y, recipe, rotation);
@@ -186,7 +186,7 @@ public abstract class InputHandler extends InputAdapter{
return false;
}
public boolean validPlace(int x, int y, Block type){
public boolean validPlace(int x, int y, Block type, int rotation){
for(Tile tile : state.teams.get(player.team).cores){
if(tile.distanceTo(x * tilesize, y * tilesize) < coreBuildRange){
return Build.validPlace(player.team, x, y, type, rotation) &&

359
core/src/io/anuke/mindustry/input/PlaceMode.java
View File

@@ -1,359 +0,0 @@
package io.anuke.mindustry.input;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.math.MathUtils;
import io.anuke.mindustry.graphics.Palette;
import io.anuke.mindustry.graphics.Shaders;
import io.anuke.mindustry.world.Block;
import io.anuke.mindustry.world.Build;
import io.anuke.mindustry.world.Tile;
import io.anuke.ucore.core.Graphics;
import io.anuke.ucore.core.Timers;
import io.anuke.ucore.graphics.Draw;
import io.anuke.ucore.graphics.Fill;
import io.anuke.ucore.graphics.Lines;
import io.anuke.ucore.util.Bundles;
import io.anuke.ucore.util.Mathf;
import io.anuke.ucore.util.Translator;
import static io.anuke.mindustry.Vars.*;
public enum PlaceMode{
cursor{
{
shown = true;
lockCamera = true;
pan = true;
}
public void draw(InputHandler input, int tilex, int tiley, int endx, int endy){
float x = tilex * tilesize;
float y = tiley * tilesize;
boolean valid = input.validPlace(tilex, tiley, input.recipe.result) && (mobile || input.cursorNear());
float offset = input.recipe.result.offset();
float si = MathUtils.sin(Timers.time() / 6f) + 1.5f;
Draw.color(valid ? Palette.place : Palette.remove);
Lines.stroke(2f);
Lines.crect(x + offset, y + offset, tilesize * input.recipe.result.size + si,
tilesize * input.recipe.result.size + si);
input.recipe.result.drawPlace(tilex, tiley, input.rotation, valid);
if(input.recipe.result.rotate){
Draw.color(Palette.placeRotate);
tr.trns(input.rotation * 90, 7, 0);
Lines.line(x, y, x + tr.x, y + tr.y);
}
}
public void tapped(InputHandler input, int tilex, int tiley){
input.tryPlaceBlock(tilex, tiley);
}
},
touch{
{
shown = true;
lockCamera = false;
showRotate = true;
showCancel = true;
}
public void tapped(InputHandler input, int x, int y){
input.tryPlaceBlock(x, y);
}
},
none{
{
delete = true;
shown = true;
both = true;
}
},
touchDelete{
{
shown = true;
lockCamera = false;
showRotate = true;
showCancel = true;
delete = true;
}
public void tapped(InputHandler input, int x, int y){
input.tryDeleteBlock(x, y);
}
},
areaDelete{
int rtilex;
int rtiley;
int rendx;
int rendy;
{
shown = true;
lockCamera = true;
delete = true;
}
public void draw(InputHandler input, int tilex, int tiley, int endx, int endy){
float t = tilesize;
process(tilex, tiley, endx, endy);
tilex = this.rtilex; tiley = this.rtiley;
endx = this.rendx; endy = this.rendy;
float x = this.rtilex * t, y = this.rtiley * t,
x2 = this.rendx * t, y2 = this.rendy * t;
if(x2 >= x){
x -= t/2;
x2 += t/2;
}
if(y2 >= y){
y -= t/2;
y2 += t/2;
}
Draw.color(Palette.remove);
Lines.stroke(1f);
for(int cx = tilex; cx <= endx; cx ++){
for(int cy = tiley; cy <= endy; cy ++){
Tile tile = world.tile(cx, cy);
if(tile != null && tile.getLinked() != null)
tile = tile.getLinked();
if(tile != null && input.validBreak(tile.x, tile.y)){
Lines.crect(tile.drawx(), tile.drawy(),
tile.block().size * t, tile.block().size * t);
}
}
}
Lines.stroke(2f);
Draw.color(Palette.remove);
Lines.rect(x, y, x2 - x, y2 - y);
Draw.alpha(0.3f);
Draw.crect("blank", x, y, x2 - x, y2 - y);
Draw.reset();
}
public void released(InputHandler input, int tilex, int tiley, int endx, int endy){
process(tilex, tiley, endx, endy);
tilex = this.rtilex; tiley = this.rtiley;
endx = this.rendx; endy = this.rendy;
input.player.clearBuilding();
for(int cx = tilex; cx <= endx; cx ++){
for(int cy = tiley; cy <= endy; cy ++){
input.tryDeleteBlock(cx, cy);
}
}
}
void process(int tilex, int tiley, int endx, int endy){
/*
if(Math.abs(x2 - tilex) > maxlen){
x2 = Mathf.sign(x2 - tilex) * maxlen + tilex;
}
if(Math.abs(y2 - tiley) > maxlen){
y2 = Mathf.sign(y2 - tiley) * maxlen + tiley;
}*/
if(endx < tilex){
int t = endx;
endx = tilex;
tilex = t;
}
if(endy < tiley){
int t = endy;
endy = tiley;
tiley = t;
}
this.rendx = endx;
this.rendy = endy;
this.rtilex = tilex;
this.rtiley = tiley;
}
},
hold{
int rtilex;
int rtiley;
int rendx;
int rendy;
int rotation;
{
lockCamera = true;
shown = true;
showCancel = true;
showRotate = true;
}
public void draw(InputHandler input, int tilex, int tiley, int endx, int endy){
if(mobile && !Gdx.input.isTouched(0) && !input.isCursorVisible()){
return;
}
float t = tilesize;
Block block = input.recipe.result;
float offset = block.offset();
process(input, tilex, tiley, endx, endy);
float x = rtilex * t, y = rtiley * t,
x2 = rendx * t, y2 = rendy * t;
if(x2 >= x){
x -= block.size * t/2;
x2 += block.size * t/2;
}
if(y2 >= y){
y -= block.size * t/2;
y2 += block.size * t/2;
}
x += offset;
y += offset;
x2 += offset;
y2 += offset;
if(tilex == endx && tiley == endy){
cursor.draw(input, tilex, tiley, endx, endy);
}else{
Draw.color(Palette.place);
Lines.stroke(1f);
Lines.rect(x, y, x2 - x, y2 - y);
Draw.alpha(0.3f);
Fill.crect(x, y, x2 - x, y2 - y);
Draw.alpha(0f);
Graphics.shader(Shaders.blockpreview, false);
for(int py = 0; py <= Math.abs(this.rendy - this.rtiley); py += block.size){
for(int px = 0; px <= Math.abs(this.rendx - this.rtilex); px += block.size){
int wx = tilex + px * Mathf.sign(endx - tilex),
wy = tiley + py * Mathf.sign(endy - tiley);
if(!Build.validPlace(input.player.team, wx, wy, block, rotation)){
Draw.color(Palette.remove);
}else{
Draw.color(Palette.accent);
}
drawPreview(block, wx * t + offset, wy * t + offset);
}
}
Graphics.shader();
Draw.reset();
}
}
public void drawPreview(Block block, float x, float y){
for(TextureRegion region : block.getBlockIcon()){
Shaders.blockpreview.region = region;
Shaders.blockpreview.color.set(Palette.accent);
Shaders.blockpreview.apply();
Draw.rect(region, x, y);
Graphics.flush();
}
}
public void released(InputHandler input, int tilex, int tiley, int endx, int endy){
process(input, tilex, tiley, endx, endy);
input.rotation = this.rotation;
input.player.clearBuilding();
boolean first = true;
for(int x = 0; x <= Math.abs(this.rendx - this.rtilex); x += input.recipe.result.size){
for(int y = 0; y <= Math.abs(this.rendy - this.rtiley); y += input.recipe.result.size){
input.tryPlaceBlock(
tilex + x * Mathf.sign(endx - tilex),
tiley + y * Mathf.sign(endy - tiley));
}
}
}
void process(InputHandler input, int tilex, int tiley, int endx, int endy){
//todo hold shift to snap
/*
if(Math.abs(tilex - x2) > Math.abs(tiley - y2)){
y2 = tiley;
}else{
x2 = tilex;
}
if(Math.abs(x2 - tilex) > maxlen){
x2 = Mathf.sign(x2 - tilex) * maxlen + tilex;
}
if(Math.abs(y2 - tiley) > maxlen){
y2 = Mathf.sign(y2 - tiley) * maxlen + tiley;
}*/
int dx = endx - tilex, dy = endy - tiley;
if(Math.abs(dx) > Math.abs(dy)){
if(dx >= 0){
rotation = 0;
}else{
rotation = 2;
}
}else if(Math.abs(dx) < Math.abs(dy)){
if(dy >= 0){
rotation = 1;
}else{
rotation = 3;
}
}else{
rotation = input.rotation;
}
if(endx < tilex){
int t = endx;
endx = tilex;
tilex = t;
}
if(endy < tiley){
int t = endy;
endy = tiley;
tiley = t;
}
this.rendx = endx;
this.rendy = endy;
this.rtilex = tilex;
this.rtiley = tiley;
}
};
public boolean lockCamera;
public boolean pan = false;
public boolean shown = false;
public boolean showRotate;
public boolean showCancel;
public boolean delete = false;
public boolean both = false;
private static final Translator tr = new Translator();
public void draw(InputHandler input, int tilex, int tiley, int endx, int endy){}
public void released(InputHandler input, int tilex, int tiley, int endx, int endy){}
public void tapped(InputHandler input, int x, int y){}
@Override
public String toString(){
return Bundles.get("placemode."+name().toLowerCase()+".name");
}
}