diff options
Diffstat (limited to 'core/src')
41 files changed, 1405 insertions, 1442 deletions
diff --git a/core/src/ch/asynk/rustanddust/engine/Board.java b/core/src/ch/asynk/rustanddust/engine/Board.java index ace94d6..f7fed7e 100644 --- a/core/src/ch/asynk/rustanddust/engine/Board.java +++ b/core/src/ch/asynk/rustanddust/engine/Board.java @@ -18,9 +18,6 @@ import ch.asynk.rustanddust.engine.util.IterableSet; import ch.asynk.rustanddust.engine.util.Collection; import ch.asynk.rustanddust.engine.gfx.Moveable; import ch.asynk.rustanddust.engine.gfx.Animation; -import ch.asynk.rustanddust.engine.gfx.animations.AnimationSequence; -import ch.asynk.rustanddust.engine.gfx.animations.RunnableAnimation; -import ch.asynk.rustanddust.engine.gfx.animations.MoveToAnimation.MoveToAnimationCb; public abstract class Board implements Disposable, Animation { @@ -404,7 +401,7 @@ public abstract class Board implements Disposable, Animation } } - return entry.opposite(); + return entry; } public int objectivesCount(Faction faction) @@ -491,7 +488,6 @@ public abstract class Board implements Disposable, Animation public Pawn setPawnOnto(Pawn pawn, Move move) { - pawn.move(move); return setPawnOnto(pawn, move.to, move.orientation); } @@ -502,54 +498,6 @@ public abstract class Board implements Disposable, Animation return pawn; } - private RunnableAnimation getSetPawnOntoAnimation(final Pawn pawn) - { - return RunnableAnimation.get(pawn, new Runnable() { - @Override - public void run() { - Tile to = pawn.move.to; - if (!to.isOffMap()) - setPawnOnto(pawn, to, pawn.move.orientation); - } - }); - } - - protected void movePawn(final Pawn pawn, Move move, MoveToAnimationCb cb) - { - pawn.move(move); - removePawn(pawn); - - AnimationSequence seq = pawn.getMoveAnimation(move.iterator(), (move.steps() + 1), cb); - seq.addAnimation(getSetPawnOntoAnimation(pawn)); - addAnimation(seq); - } - - protected void enterPawn(final Pawn pawn, Move move) - { - pawn.move(move); - setPawnOnto(pawn, move.to, move.orientation); - } - - protected void revertLastPawnMove(final Pawn pawn, final Move move) - { - removePawn(pawn); - - revertclaim(pawn, move.to); - for (Tile tile : move.tiles) - revertclaim(pawn, tile); - claim(pawn, move.from); - - AnimationSequence seq = pawn.getRevertLastMoveAnimation(1); - seq.addAnimation(RunnableAnimation.get(pawn, new Runnable() { - @Override - public void run() { - pushPawnOnto(pawn, pawn.getTile()); - } - })); - addAnimation(seq); - pawn.revertLastMove(); - } - public void attack(final Pawn pawn, final Pawn target, boolean clearVisibility) { if (!pawn.canEngage(target) || !searchBoard.canAttack(pawn, target, clearVisibility)) diff --git a/core/src/ch/asynk/rustanddust/engine/Move.java b/core/src/ch/asynk/rustanddust/engine/Move.java index 09e7330..ff927c0 100644 --- a/core/src/ch/asynk/rustanddust/engine/Move.java +++ b/core/src/ch/asynk/rustanddust/engine/Move.java @@ -49,11 +49,10 @@ public class Move extends Path implements Iterable<Vector3>, Iterator movePool.clear(); } - public static Move getEnter(Pawn pawn, Tile to, Orientation orientation) + public static Move getEnter(Pawn pawn, Tile from, Tile to, Orientation orientation, Path path) { - Move m = get(pawn, null, to, orientation, null); + Move m = get(pawn, from, to, orientation, path); m.type = MoveType.ENTER; - m.cost = to.costFrom(pawn, orientation); return m; } @@ -122,11 +121,6 @@ public class Move extends Path implements Iterable<Vector3>, Iterator return (type == MoveType.REGULAR); } - public boolean isFinal() - { - return (type != MoveType.ENTER); - } - public int steps() { int steps = 0; diff --git a/core/src/ch/asynk/rustanddust/engine/PathBuilder.java b/core/src/ch/asynk/rustanddust/engine/PathBuilder.java index edac1c3..609fe8b 100644 --- a/core/src/ch/asynk/rustanddust/engine/PathBuilder.java +++ b/core/src/ch/asynk/rustanddust/engine/PathBuilder.java @@ -294,6 +294,18 @@ public class PathBuilder implements Disposable return Move.get(pawn, from, to, orientation, getPath(0)); } + public Move getEnterMove(Pawn pawn, Tile from) + { + // getPath(0).tiles.insert(this.from, 0); + // this.from = from; + int cost = pawn.getSpentMovementPoints(); + pawn.reset(); + Move move = getMove(); + move.type = Move.MoveType.ENTER; + move.cost = cost + ((this.from == this.to) ? 0 : move.cost); + return move; + } + public Move getExitMove() { Move move = getMove(); diff --git a/core/src/ch/asynk/rustanddust/engine/Pawn.java b/core/src/ch/asynk/rustanddust/engine/Pawn.java index fc0323f..d7c8749 100644 --- a/core/src/ch/asynk/rustanddust/engine/Pawn.java +++ b/core/src/ch/asynk/rustanddust/engine/Pawn.java @@ -115,20 +115,14 @@ public abstract class Pawn implements Moveable, Disposable { switch(move.type) { - case REGULAR: - if ((this.move != null) && (!this.move.isEnter())) - throw new RuntimeException("try to override an existing move instance"); + case SET: break; + case REGULAR: case ENTER: - if (this.move != null) - throw new RuntimeException("try to override an existing move instance"); - break; case EXIT: if (this.move != null) throw new RuntimeException("try to override an existing move instance"); break; - case SET: - break; default: throw new RuntimeException("unsupported MoveType"); } @@ -144,11 +138,6 @@ public abstract class Pawn implements Moveable, Disposable attack.distance = distance; } - public boolean justEntered() - { - return ((move != null) && move.isEnter()); - } - public boolean is(Faction faction) { return (this.faction == faction); @@ -333,28 +322,17 @@ public abstract class Pawn implements Moveable, Disposable return hasOverlayEnabled(); } - public AnimationSequence getRotateAnimation(float z, int size) - { - prevPosition.set(position); - AnimationSequence seq = AnimationSequence.get(1 + size); - seq.addAnimation(MoveToAnimation.get(this, position.x, position.y, z, MOVE_TIME)); - - return seq; - } - - public AnimationSequence getMoveAnimation(Iterator<Vector3> vectors, int size, MoveToAnimation.MoveToAnimationCb cb) + public AnimationSequence getMoveAnimation(Iterator<Vector3> vectors, AnimationSequence seq, MoveToAnimation.MoveToAnimationCb cb) { prevPosition.set(position); - AnimationSequence seq = AnimationSequence.get(size); while (vectors.hasNext()) seq.addAnimation(MoveToAnimation.get(this, vectors.next(), MOVE_TIME, cb)); return seq; } - public AnimationSequence getRevertLastMoveAnimation(int size) + public AnimationSequence getRevertLastMoveAnimation(AnimationSequence seq) { - AnimationSequence seq = AnimationSequence.get(2 + size); seq.addAnimation(MoveToAnimation.get(this, prevPosition, MOVE_TIME)); seq.addAnimation(RunnableAnimation.get(this, new Runnable() { @Override diff --git a/core/src/ch/asynk/rustanddust/game/Battle.java b/core/src/ch/asynk/rustanddust/game/Battle.java index 168f5ee..4ed139c 100644 --- a/core/src/ch/asynk/rustanddust/game/Battle.java +++ b/core/src/ch/asynk/rustanddust/game/Battle.java @@ -24,14 +24,12 @@ public interface Battle extends Marshal public Player getOpponent(); - public void init(); + public Map init(Ctrl ctrl); public void desinit(); public void initialDeployment(); - public boolean actionDone(); - public boolean turnDone(); public boolean isDeploymentDone(); diff --git a/core/src/ch/asynk/rustanddust/game/Config.java b/core/src/ch/asynk/rustanddust/game/Config.java index 318eae9..db7fb5c 100644 --- a/core/src/ch/asynk/rustanddust/game/Config.java +++ b/core/src/ch/asynk/rustanddust/game/Config.java @@ -37,9 +37,10 @@ public class Config public enum LoadMode { - LOAD("Load", 0), - REPLAY_LAST("Replay Last Turn", 1), - REPLAY_ALL("Full Replay", 2); + NEW("New", 0), + RESUME("Resume", 1), + REPLAY_CURRENT("Replay Current Turn", 2), + REPLAY_ALL("Full Replay", 3); public String s; public int i; LoadMode(String s, int i) @@ -101,9 +102,9 @@ public class Config public Config() { this.gameMode = GameMode.SOLO; - this.loadMode = LoadMode.LOAD; + this.loadMode = LoadMode.NEW; this.debug = false; - this.autoPath = true; + this.autoPath = false; this.revertAllMoves = false; this.showMoves = true; this.showTargets = true; diff --git a/core/src/ch/asynk/rustanddust/game/Ctrl.java b/core/src/ch/asynk/rustanddust/game/Ctrl.java index 6ec7184..9ff5d53 100644 --- a/core/src/ch/asynk/rustanddust/game/Ctrl.java +++ b/core/src/ch/asynk/rustanddust/game/Ctrl.java @@ -18,32 +18,54 @@ import ch.asynk.rustanddust.game.State.StateType; import ch.asynk.rustanddust.game.states.StateCommon; import ch.asynk.rustanddust.game.states.StateSelect; import ch.asynk.rustanddust.game.states.StateMove; -import ch.asynk.rustanddust.game.states.StateRotate; import ch.asynk.rustanddust.game.states.StatePromote; import ch.asynk.rustanddust.game.states.StateEngage; -import ch.asynk.rustanddust.game.states.StateBreak; import ch.asynk.rustanddust.game.states.StateAnimation; -import ch.asynk.rustanddust.game.states.StateReinforcement; import ch.asynk.rustanddust.game.states.StateDeployment; -import ch.asynk.rustanddust.game.states.StateWithdraw; +import ch.asynk.rustanddust.game.states.StateReinforcement; import ch.asynk.rustanddust.game.states.StateReplay; public abstract class Ctrl implements Disposable { - public enum EventType + enum Mode { - STATE_CHANGE, - HUD_ANSWER, + LOADING, + REPLAY, + PLAY, + } + + private static final boolean debugCtrl = false; + + public enum MsgType + { + OK, + CANCEL, + PROMOTE, ANIMATIONS_DONE, + UNIT_DOCK_SELECT, UNIT_DOCK_TOGGLE, - UNIT_DOCK_SELECT; + UNIT_DEPLOYED, + UNIT_UNDEPLOYED, + } + + public enum EventType + { + ORDER, + ORDER_DONE, + STATE_CHANGE, + ANIMATION, + REPLAY_DONE, + TURN_DONE, + ACTION_ABORTED, + EXIT_BATTLE, } class Event { public EventType type; public Object data; - public boolean status; + @Override + public String toString() { return String.format("Event : %s - %s", type, (data == null) ? "" : data); } } public final RustAndDust game; @@ -55,39 +77,37 @@ public abstract class Ctrl implements Disposable public Map map; public Hud hud; + private float blockEvents; public boolean blockMap; public boolean blockHud; private Hex touchedHex; + protected int gameId; protected boolean synched; private int depth; + private Order lastOrder; + private final State selectState; - private final State pathState; - private final State rotateState; + private final State moveState; private final State promoteState; private final State engageState; - private final State breakState; private final State animationState; - private final State reinforcementState; private final State deploymentState; - private final State withdrawState; + private final State reinforcementState; private final State replayState; - private int animationCount = 0; - + private Mode mode; private State state; private StateType stateType; private StateType stateAfterAnimation; public abstract void init(); - protected abstract void actionDoneCb(); - protected abstract void turnDoneCb(); - public abstract void orderProcessedCb(); public static Ctrl getCtrl(final RustAndDust game) { Ctrl ctrl = null; - switch(game.config.gameMode) { + switch(game.config.gameMode) + { case SOLO: ctrl = new Solo(game); break; @@ -102,57 +122,57 @@ public abstract class Ctrl implements Disposable this.battle = game.config.battle; this.hud = new Hud(game); - this.blockMap = false; + this.blockEvents = 0.5f; + this.blockMap = true; this.blockHud = false; this.touchedHex = null; + this.gameId = -1; this.synched = false; this.depth = 0; + this.lastOrder = null; + this.selectState = new StateSelect(); - this.pathState = new StateMove(); - this.rotateState = new StateRotate(); + this.moveState = new StateMove(); this.promoteState = new StatePromote(); this.engageState = new StateEngage(); - this.breakState = new StateBreak(); this.animationState = new StateAnimation(); - this.reinforcementState = new StateReinforcement(); this.deploymentState = new StateDeployment(); - this.withdrawState = new StateWithdraw(); + this.reinforcementState = new StateReinforcement(); this.replayState = new StateReplay(); - this.stateType = StateType.LOADING; + this.mode = Mode.LOADING; - battle.init(); - this.map = battle.getMap(); + this.map = battle.init(this); init(); StateCommon.set(game); hud.update(); - this.state = selectState; - this.stateType = StateType.DONE; - this.stateAfterAnimation = StateType.DONE; - - setState(battle.getState()); + this.stateType = StateType.WAIT_EVENT; + this.stateAfterAnimation = battle.getState(); - if (synched) { - this.hud.notify(battle.toString(), 2, Position.MIDDLE_CENTER, false); - return; - } + setState(StateType.ANIMATION); - switch(game.config.loadMode) { - case REPLAY_ALL: - // TODO REPLAY_ALL + switch(game.config.loadMode) + { + case NEW: + this.hud.notify(battle.toString(), 2, Position.MIDDLE_CENTER, false); break; - case REPLAY_LAST: - map.prepareReplayLastTurn(); - setState(StateType.REPLAY); + case RESUME: + if (!synched) { + map.prepareReplayLastAction(); + this.stateAfterAnimation = StateType.REPLAY; + } break; - case LOAD: - map.prepareReplayLastAction(); - setState(StateType.REPLAY); + case REPLAY_CURRENT: + map.prepareReplayCurrentTurn(); + this.stateAfterAnimation = StateType.REPLAY; + break; + case REPLAY_ALL: + // TODO REPLAY ALL + this.stateAfterAnimation = StateType.REPLAY; break; } - } @Override @@ -167,13 +187,9 @@ public abstract class Ctrl implements Disposable // JSON - protected boolean isLoading() - { - return (stateType == StateType.LOADING); - } - protected void load(Marshal.Mode mode, String payload) { + if (payload == null) return; JsonValue root = new JsonReader().parse(payload); battle.load(mode, root); } @@ -188,6 +204,27 @@ public abstract class Ctrl implements Disposable return writer.toString(); } + // DB + private void storeState() + { + game.db.storeGameState(gameId, battle.getTurnCount(), battle.getPlayer().id, unload(Marshal.Mode.PLAYERS), unload(Marshal.Mode.MAP)); + } + + private void storeOrders() + { + game.db.storeGameOrders(gameId, battle.getTurnCount(), battle.getPlayer().id, unload(Marshal.Mode.ORDERS)); + } + + private void clearOrders() + { + game.db.clearGameOrders(gameId); + } + + private void storeTurn() + { + game.db.storeCurrentTurn(gameId); + } + // INPUTS public boolean drag(float x, float y, int dx, int dy) @@ -199,9 +236,7 @@ public abstract class Ctrl implements Disposable public void touchDown(float hudX, float hudY, float mapX, float mapY) { - boolean inAnimation = (this.stateType == StateType.ANIMATION); - - if (!blockHud && hud.hit(hudX, hudY, inAnimation)) + if (!blockHud && hud.hit(hudX, hudY, inAnimation())) return; touchedHex = (blockMap ? null : map.getHexAt(mapX, mapY)); @@ -213,34 +248,64 @@ public abstract class Ctrl implements Disposable state.touch(touchedHex); } - // EVENTS + // MESSAGES - private Event getEvent() + public void sendMsg(MsgType msgType) { - Event evt = freeEvents.pop(); - if (evt == null) - evt = new Event(); - return evt; + sendMsg(msgType, null); } - public void postDone() { post(StateType.DONE); } - public void postAbort() { post(StateType.ABORT); } + public void sendMsg(MsgType msgType, Object data) + { + RustAndDust.debug(String.format("Msg : %s %s", msgType, data)); + switch(msgType) + { + case ANIMATIONS_DONE: animationsDone(); break; + case UNIT_DOCK_TOGGLE: unitDockToggle(); break; + case UNIT_DEPLOYED: deploymentState.processMsg(msgType, data); break; + default: + if (!this.state.processMsg(msgType, data)) + RustAndDust.error(String.format("%s does not handle msg : %s %s", this.state, msgType, data)); + break; + } + } + + // EVENTS + + public void postTurnDone() { postEvent(EventType.TURN_DONE); } + public void postActionAborted() { postEvent(EventType.ACTION_ABORTED); } + public void postReplayDone(StateType stateType) { postEvent(EventType.REPLAY_DONE, stateType); } public void post(StateType stateType) { - Event evt = getEvent(); - evt.type = EventType.STATE_CHANGE; - evt.data = stateType; - events.enqueue(evt); + postEvent(EventType.STATE_CHANGE, stateType); } - public void postAnswer(Hud.OkCancelAction what, boolean status) + public void postOrder(Order order) { - Event evt = getEvent(); - evt.type = EventType.HUD_ANSWER; - evt.data = what; - evt.status = status; - events.enqueue(evt); + postOrder(order, null); + } + + public void postInitOrder(Order order) + { + // postEvent(EventType.ORDER, order); + // postEvent(EventType.ORDER_DONE, stateType); + executeOrder(order); + orderDone(null); + } + + public void postOrder(Order order, StateType stateType) + { + postEvent(EventType.ORDER, order); + switch(order.type) + { + case END: + case REVERT: + break; + default: + postEvent(EventType.ANIMATION, StateType.WAIT_EVENT); + } + postEvent(EventType.ORDER_DONE, stateType); } public void postEvent(EventType type) @@ -250,33 +315,39 @@ public abstract class Ctrl implements Disposable public void postEvent(EventType type, Object data) { - Event evt = getEvent(); + Event evt = freeEvents.pop(); + if (evt == null) + evt = new Event(); evt.type = type; evt.data = data; events.enqueue(evt); } - public void processEvent() + public void processEvent(float delta) { - if (events.size() <= 0) + if (blockEvents > 0f) { + blockEvents -= delta; + if (blockEvents > 0f) + return; + } + if ((events.size() <= 0) || inAnimation()) return; Event evt = events.dequeue(); - switch(evt.type) { - case STATE_CHANGE: - setState((StateType) evt.data); - break; - case HUD_ANSWER: - handleHudAnswer(evt); - break; - case ANIMATIONS_DONE: - animationsDone(); - break; - case UNIT_DOCK_TOGGLE: - unitDockToggle(); - break; - case UNIT_DOCK_SELECT: - unitDockSelect((Unit) evt.data); + RustAndDust.debug(evt.toString()); + + switch(evt.type) + { + case ORDER: executeOrder((Order) evt.data); break; + case ORDER_DONE: orderDone((StateType) evt.data); break; + case STATE_CHANGE: setState((StateType) evt.data); break; + case REPLAY_DONE: replayDone((StateType) evt.data); break; + case TURN_DONE: turnDone(); break; + case ACTION_ABORTED: abortAction(); break; + case EXIT_BATTLE: exitBattle(); break; + case ANIMATION: + stateAfterAnimation = (StateType) evt.data; + setState(StateType.ANIMATION); break; default: RustAndDust.error(String.format("Unhandled Event Type : %s %s", evt.type, evt.data)); @@ -284,243 +355,244 @@ public abstract class Ctrl implements Disposable freeEvents.push(evt); } - // State callbacks - - public void setAfterAnimationState(StateType after) + private boolean inAnimation() { - stateAfterAnimation = after; - } - - // Event handlers - - private void handleHudAnswer(Event evt) - { - switch((Hud.OkCancelAction) evt.data) { - case EXIT_BOARD: - if (evt.status) setState(StateType.DONE); - else setState(StateType.ABORT); - break; - case ABORT_TURN: - if (evt.status) { - this.state.abort(); - turnDone(); - } - break; - case END_DEPLOYMENT: - if (evt.status) { - this.state.execute(); - turnDone(); - } - break; - case QUIT_BATTLE: - if (evt.status) - game.switchToMenu(); - break; - - } + return (this.stateType == StateType.ANIMATION); } private void animationsDone() { + if (debugCtrl) RustAndDust.debug(" ANIMATIONS DONE"); + if (hud.dialogActive()) hud.notifyAnimationsDone(); - if (stateType == StateType.ANIMATION) { - StateType tmp = stateAfterAnimation; - stateAfterAnimation = StateType.DONE; - setState(tmp); + + if (mode == Mode.LOADING) { + this.mode = ((stateAfterAnimation == StateType.REPLAY) ? Mode.REPLAY : Mode.PLAY); + if (game.config.loadMode == Config.LoadMode.NEW) { + storeState(); + storeTurn(); + } + if (mode == Mode.PLAY) + map.clear(true); } + this.blockMap = false; + StateType tmp = stateAfterAnimation; + stateAfterAnimation = StateType.WAIT_EVENT; + setState(tmp); } - private void unitDockSelect(Unit unit) + private void replayDone(StateType nextState) { - if ((stateType == StateType.DEPLOYMENT) || (stateType == StateType.REINFORCEMENT)) - state.touch(null); + if (debugCtrl) RustAndDust.debug(" REPLAY DONE"); + hud.notify("Replay Done", Position.MIDDLE_CENTER); + this.mode = Mode.PLAY; + if (nextState != null) { + setState(nextState); + } else { + if (!synched) { + storeState(); + synched = true; + } + if (battle.getPlayer().apExhausted()) + postTurnDone(); + else if (!battle.getPlayer().canDoSomething()) + postTurnDone(); + else + setState(battle.getState()); + } } - private void unitDockToggle() + private void executeOrder(Order order) { - if (this.stateType == StateType.SELECT) - setState(StateType.REINFORCEMENT); - else if (this.stateType == StateType.REINFORCEMENT) - setState(StateType.SELECT); + if (debugCtrl) RustAndDust.debug(" EXECUTE ORDER"); + lastOrder = order; + map.execute(order); + if ((order.type == Order.OrderType.ENGAGE) && !order.replay) { + game.ctrl.hud.engagementSummary(order.engagement); + } + if (this.mode == Mode.PLAY) + storeOrders(); + hud.update(); } - // - - private void turnDone() + private void orderDone(StateType nextState) { - if (battle.turnDone()) - hud.victory(battle.getPlayer(), battle.getOpponent()); - else { - if (battle.getPlayer().hasReinforcement()) - hud.notify("You have reinforcement", 2, Position.MIDDLE_CENTER, true); - hud.update(); - if (!battle.getPlayer().canDoSomething()) { - hud.notify("No available Actions"); - setState(StateType.TURN_OVER); - } else - setState(battle.getState()); - } - } + if (debugCtrl) RustAndDust.debug(" ORDER DONE -> " + nextState); + Order order = this.lastOrder; + this.lastOrder = null; + if (nextState == null) + nextState = battle.getState(); - // + completeOrder(order); - private void setState(StateType nextState) - { - depth += 1; - if (depth > 1) - RustAndDust.error(String.format("***!!!*** STATE DEPTH : %d", depth)); + if (mode == Mode.LOADING) + return; - if (nextState == StateType.ABORT) - nextState = abortAction(); - else if (nextState == StateType.DONE) { - nextState = complete(); + if (mode == Mode.REPLAY) { + if (order.cost > 0) + battle.getPlayer().burnDownOneAp(); + hud.update(); + blockEvents = 0.2f; + post(nextState); + return; } - if (stateType == StateType.ANIMATION) { - this.blockMap = hud.dialogActive(); - if (nextState == StateType.REPLAY) - completeReplayStep(); + if (order.cost == 0) { + post(nextState); + return; } - hud.playerInfo.blockEndOfTurn(nextState != StateType.SELECT); - - if (nextState == stateType) - RustAndDust.debug(String.format("***!!!*** STATE LOOP : %s", stateType)); - - this.state.leaveFor(nextState); - - this.state = getNextState(nextState); - - StateType tmp = stateType; - stateType = nextState; + battle.getPlayer().burnDownOneAp(); + hud.notify("1 Action Point burnt"); + hud.update(); - this.state.enterFrom(tmp); + if (battle.getPlayer().apExhausted()) { + hud.notify("No more Action Points"); + postTurnDone(); + } else if (!battle.getPlayer().canDoSomething()) { + hud.notify("No available Actions"); + postTurnDone(); + } else { + post(nextState); + } - if (nextState == StateType.TURN_OVER) - turnDone(); - depth -= 1; + storeState(); } - private StateType complete() + private void completeOrder(Order order) { - switch(stateType) { - case DEPLOYMENT: - return completeDeployment(); - case REPLAY: - return completeReplay(); - default: - return completeAction(); + switch(order.type) + { + case MOVE: completeMoveOrder(order, (Unit) order.move.pawn); break; + case ENGAGE: completeEngagementOrder(order, order.engagement.defender); break; + case PROMOTE: battle.getPlayer().promote(order.leader); break; + case REVERT: break; + case END: break; + default: break; } } - private StateType completeDeployment() + private void completeEngagementOrder(Order order, Unit unit) { - if (battle.isDeploymentDone()) - hud.askEndDeployment(); - battle.actionDone(); - return StateType.DEPLOYMENT; + if (order.engagement.success) { + battle.getPlayer().engagementWon += 1; + battle.getOpponent().casualty(unit); + } else { + battle.getPlayer().engagementLost += 1; + } } - private StateType abortAction() + private void completeMoveOrder(Order order, Unit unit) { - hud.notify("Action canceled"); - StateType nextState = this.state.abort(); - - if (nextState == StateType.ABORT) - nextState = battle.getState(); - - return nextState; + switch(order.move.type) + { + case EXIT: battle.getPlayer().unitWithdraw(unit); break; + case SET: battle.getPlayer().unitEntry(unit); break; + case ENTER: battle.getPlayer().unitEntry(unit); break; + case REGULAR: break; + default: break; + } } - private StateType completeAction() + private void turnDone() { - StateType nextState = this.state.execute(); + if (debugCtrl) RustAndDust.debug(" TURN DONE"); - if (nextState == StateType.DONE) { - if (battle.actionDone()) { - hud.notify("1 Action Point burnt"); - hud.update(); - } - if (battle.getPlayer().apExhausted()) { - hud.notify("No more Action Points"); - nextState = StateType.TURN_OVER; - } else if (!battle.getPlayer().canDoSomething()) { + setState(StateType.WAIT_EVENT); + + if (battle.turnDone()) + hud.victory(battle.getPlayer(), battle.getOpponent()); + else { + hud.update(); + if (battle.getPlayer().hasReinforcement()) + hud.notify("You have reinforcement", 2, Position.MIDDLE_CENTER, true); + if (!battle.getPlayer().canDoSomething()) { hud.notify("No available Actions"); - nextState = StateType.TURN_OVER; - } else - nextState = battle.getState(); + postTurnDone(); + } else { + post(battle.getState()); + } } - return nextState; + storeState(); + storeTurn(); + map.clear(true); + clearOrders(); } - private StateType completeReplay() + private void abortAction() { - if (battle.getPlayer().apExhausted()) { - return StateType.TURN_OVER; - } else if (!battle.getPlayer().canDoSomething()) { - return StateType.TURN_OVER; - } else - return battle.getState(); + if (debugCtrl) RustAndDust.debug(" ABORT ACTION"); + post(battle.getState()); } - private void completeReplayStep() + private void exitBattle() { - StateType nextState = replayState.execute(); + if (debugCtrl) RustAndDust.debug(" EXIT BATTLE"); + game.switchToMenu(); + } - if (nextState == StateType.DONE) { - battle.getPlayer().burnDownOneAp(); - hud.update(); + private void unitDockToggle() + { + if (this.stateType == StateType.SELECT) + post(StateType.REINFORCEMENT); + else if (this.stateType == StateType.REINFORCEMENT) { + sendMsg(MsgType.OK); + post(StateType.SELECT); } } - private State getNextState(StateType nextState) + // + + private void setState(StateType nextState) { - RustAndDust.debug("Ctrl", String.format(" %s -> %s : %s", stateType, nextState, battle.getPlayer())); + if (stateType == nextState) + RustAndDust.error("***!!!*** STATE LOOP ********************************************************************** " + stateType); - State state = this.state; + if (nextState == StateType.WAIT_EVENT) { + stateType = nextState; + if (debugCtrl) RustAndDust.debug(" WAIT_EVENT"); + return; + } - switch(nextState) { - case SELECT: - state = selectState; - break; - case MOVE: - state = pathState; - break; - case ROTATE: - state = rotateState; - break; - case PROMOTE: - state = promoteState; - break; - case ENGAGE: - state = engageState; - break; - case BREAK: - state = breakState; - break; - case WITHDRAW: - state = withdrawState; - break; - case ANIMATION: - state = animationState; - this.blockMap = true; - break; - case REINFORCEMENT: - state = reinforcementState; - break; - case DEPLOYMENT: - state = deploymentState; - break; - case REPLAY: - state = replayState; - break; + depth += 1; + if (depth > 1) + RustAndDust.error(String.format("***!!!*** STATE DEPTH : %d", depth)); + + if (nextState == StateType.DEPLOYMENT) { + if (battle.isDeploymentDone()) + hud.askEndDeployment(); + } + + hud.playerInfo.blockEndOfTurn(nextState != StateType.SELECT); + + this.state = getNextState(nextState); + StateType tmp = stateType; + stateType = nextState; + this.state.enterFrom(tmp); + + depth -= 1; + } + + private State getNextState(StateType nextState) + { + RustAndDust.debug(" State Change", String.format("%s -> %s", stateType, nextState)); + + switch(nextState) + { + case SELECT: return selectState; + case MOVE: return moveState; + case PROMOTE: return promoteState; + case ENGAGE: return engageState; + case ANIMATION: return animationState; + case DEPLOYMENT: return deploymentState; + case REINFORCEMENT: return reinforcementState; + case REPLAY: return replayState; default: RustAndDust.error(String.format("Unhandled State : %s", nextState)); - break; } - return state; + return this.state; } } diff --git a/core/src/ch/asynk/rustanddust/game/Engagement.java b/core/src/ch/asynk/rustanddust/game/Engagement.java index b9630b8..4c29c3d 100644 --- a/core/src/ch/asynk/rustanddust/game/Engagement.java +++ b/core/src/ch/asynk/rustanddust/game/Engagement.java @@ -35,6 +35,7 @@ public class Engagement implements Disposable, Pool.Poolable public Unit defender; public UnitList assists; public boolean success; + public int cost; public int d1; public int d2; public int d3; diff --git a/core/src/ch/asynk/rustanddust/game/Hex.java b/core/src/ch/asynk/rustanddust/game/Hex.java index 34ccdb3..ea988be 100644 --- a/core/src/ch/asynk/rustanddust/game/Hex.java +++ b/core/src/ch/asynk/rustanddust/game/Hex.java @@ -103,10 +103,10 @@ public class Hex extends Tile public int costFrom(Pawn pawn, Orientation side) { if (side == Orientation.KEEP) return 0; - if (hasUnits()) return (Integer.MAX_VALUE / 2); + if (hasUnits()) return Integer.MAX_VALUE; if (roadFrom(side)) return 1; - int c = 0; + int c = Integer.MAX_VALUE; switch(terrain) { case CLEAR: case HILLS: @@ -118,7 +118,6 @@ public class Hex extends Tile break; case OFFMAP: case BLOCKED: - c = (Integer.MAX_VALUE / 2); break; } diff --git a/core/src/ch/asynk/rustanddust/game/Hud.java b/core/src/ch/asynk/rustanddust/game/Hud.java index b58c8f1..936d8b0 100644 --- a/core/src/ch/asynk/rustanddust/game/Hud.java +++ b/core/src/ch/asynk/rustanddust/game/Hud.java @@ -218,12 +218,22 @@ public class Hud implements Disposable, Animation dialog.visible = false; if (dialog == okCancel) { - if (okCancel.ok) game.playEnter(); - else game.playType(); - ctrl.postAnswer(okCancelAction, okCancel.ok); + boolean ok = false; + if (okCancel.ok) { + ok = true; + game.playEnter(); + } else + game.playType(); + if (ok) { + if (this.okCancelAction == OkCancelAction.EXIT_BATTLE) + ctrl.postEvent(Ctrl.EventType.EXIT_BATTLE); + else + ctrl.sendMsg(Ctrl.MsgType.OK); + } else + ctrl.sendMsg(Ctrl.MsgType.CANCEL); } else if (dialog == stats) { game.playEnter(); - ctrl.postAnswer(OkCancelAction.EXIT_BATTLE, true); + ctrl.postEvent(Ctrl.EventType.EXIT_BATTLE); } else game.playType(); diff --git a/core/src/ch/asynk/rustanddust/game/Map.java b/core/src/ch/asynk/rustanddust/game/Map.java index f55b8fd..6a0bb03 100644 --- a/core/src/ch/asynk/rustanddust/game/Map.java +++ b/core/src/ch/asynk/rustanddust/game/Map.java @@ -24,33 +24,17 @@ public abstract class Map extends Map5Marshal meteorology = new Meteorology(); } - public void clearAll() + public void clear() { clear(false); } + public void clear(boolean orders) { + if (orders) { + RustAndDust.debug(" Map", String.format("Clearder Orders : %d", ordersSize())); + ordersClear(); + } clearMoves(); clearUnits(); } - public void actionDone() - { - incActionId(); - game.ctrl.actionDoneCb(); - } - - public void turnDone() - { - RustAndDust.debug("TurnDone", String.format(" Processed Orders : %d", ordersSize())); - game.ctrl.turnDoneCb(); - ordersClear(); - } - - @Override - protected int engagementCost(Engagement e) - { - if ((activatedUnits.size() == 1) && e.attacker.isA(Unit.UnitType.AT_GUN) && e.defender.isHardTarget()) - return 0; - return 1; - } - @Override protected void resolveEngagement(Engagement e) { @@ -116,6 +100,15 @@ public abstract class Map extends Map5Marshal e.d4 = 0; } + activableUnits.clear(); + if (success) { + for (Unit unit : activatedUnits) { + if (unit.canBreak()) + activableUnits.add(unit); + } + } + + e.cost = (((cnt == 1) && e.attacker.isA(Unit.UnitType.AT_GUN) && e.defender.isHardTarget()) ? 0 : 1); e.set(cnt, flk, def, tdf, wdf); e.success = success; } diff --git a/core/src/ch/asynk/rustanddust/game/Order.java b/core/src/ch/asynk/rustanddust/game/Order.java index b959628..528d4d7 100644 --- a/core/src/ch/asynk/rustanddust/game/Order.java +++ b/core/src/ch/asynk/rustanddust/game/Order.java @@ -10,6 +10,7 @@ public class Order implements Disposable, Pool.Poolable, Comparable<Unit> public static int orderId = 1; public static final Order END = new Order(OrderType.END); + public static final Order REVERT = new Order(OrderType.REVERT); public enum OrderType { @@ -18,6 +19,7 @@ public class Order implements Disposable, Pool.Poolable, Comparable<Unit> ENGAGE, PROMOTE, END, + REVERT, } private static final Pool<Order> orderPool = new Pool<Order>() @@ -64,6 +66,8 @@ public class Order implements Disposable, Pool.Poolable, Comparable<Unit> @Override public void dispose() { + if ((type == OrderType.END) || (type == OrderType.REVERT)) + throw new RuntimeException(String.format("call dispose() on a static Order %s", type)); orderPool.free(this); } @@ -102,32 +106,44 @@ public class Order implements Disposable, Pool.Poolable, Comparable<Unit> @Override public String toString() { - if (type == OrderType.END) - return String.format("[00] END"); - else - return String.format("[%d] %s(%d) : %s", id, type, cost, leader.code); + switch (type) + { + case END: + return String.format("[00] END"); + case REVERT: + return String.format("%s[%d]", type, id); + default: + return String.format("[%d] %s(%d) : %s", id, type, cost, leader.code); + } } public void setMove(Unit unit, Move move) { - this.leader = unit; this.type = OrderType.MOVE; + this.leader = unit; this.move = move; } public void setPromote(Unit unit) { - this.leader = unit; this.type = OrderType.PROMOTE; + this.leader = unit; } public void setEngage(Unit unit, Unit target) { - this.leader = unit; this.type = OrderType.ENGAGE; + this.leader = unit; this.engagement = Engagement.get(unit, target); } + public void setRevert(int id) + { + this.type = OrderType.REVERT; + this.id = id; + this.cost = 0; + } + public void setActivables(UnitList l) { for(Unit u : l) diff --git a/core/src/ch/asynk/rustanddust/game/Player.java b/core/src/ch/asynk/rustanddust/game/Player.java index c5d3473..0018e1a 100644 --- a/core/src/ch/asynk/rustanddust/game/Player.java +++ b/core/src/ch/asynk/rustanddust/game/Player.java @@ -193,12 +193,12 @@ public class Player public void turnEnd() { apSpent = ap; - for (Unit unit : units) - unit.reset(); } public void turnStart(int aps) { + for (Unit unit : units) + unit.reset(); if (isDeploymentDone()) { ap = aps; apSpent = 0; diff --git a/core/src/ch/asynk/rustanddust/game/State.java b/core/src/ch/asynk/rustanddust/game/State.java index a3a6fec..9ab1576 100644 --- a/core/src/ch/asynk/rustanddust/game/State.java +++ b/core/src/ch/asynk/rustanddust/game/State.java @@ -1,32 +1,25 @@ package ch.asynk.rustanddust.game; +import ch.asynk.rustanddust.game.Ctrl.MsgType; + public interface State { - enum StateType { - LOADING, + enum StateType + { REPLAY, + WAIT_EVENT, SELECT, MOVE, - ROTATE, ENGAGE, - BREAK, PROMOTE, ANIMATION, REINFORCEMENT, DEPLOYMENT, - WITHDRAW, - ABORT, - DONE, - TURN_OVER }; - public void enterFrom(StateType prevState); - - public void leaveFor(StateType nextState); - - public StateType abort(); + public void touch(Hex hex); - public StateType execute(); + public void enterFrom(StateType prevState); - public void touch(Hex hex); + public boolean processMsg(MsgType msg, Object data); } diff --git a/core/src/ch/asynk/rustanddust/game/Unit.java b/core/src/ch/asynk/rustanddust/game/Unit.java index 7a9f2e2..4dd04ee 100644 --- a/core/src/ch/asynk/rustanddust/game/Unit.java +++ b/core/src/ch/asynk/rustanddust/game/Unit.java @@ -315,7 +315,7 @@ public class Unit extends HeadedPawn if (cost > mpLeft) RustAndDust.debug("ERROR: Movement point exceeded: " + cost + "/" + mpLeft + " please report"); - if ((cost > 0) && move.isFinal()) + if (cost > 0) setMoved(); spendMovementPoints(cost); diff --git a/core/src/ch/asynk/rustanddust/game/battles/BattleCommon.java b/core/src/ch/asynk/rustanddust/game/battles/BattleCommon.java index e7bcac5..a70698b 100644 --- a/core/src/ch/asynk/rustanddust/game/battles/BattleCommon.java +++ b/core/src/ch/asynk/rustanddust/game/battles/BattleCommon.java @@ -6,6 +6,7 @@ import com.badlogic.gdx.utils.Json; import com.badlogic.gdx.utils.JsonValue; import ch.asynk.rustanddust.util.Marshal; +import ch.asynk.rustanddust.game.Ctrl; import ch.asynk.rustanddust.game.Battle; import ch.asynk.rustanddust.game.Player; import ch.asynk.rustanddust.game.State; @@ -13,6 +14,7 @@ import ch.asynk.rustanddust.game.Map; import ch.asynk.rustanddust.game.Zone; import ch.asynk.rustanddust.game.Unit; import ch.asynk.rustanddust.game.Unit.UnitCode; +import ch.asynk.rustanddust.game.Order; import ch.asynk.rustanddust.game.Factory; import ch.asynk.rustanddust.game.State.StateType; import ch.asynk.rustanddust.engine.Orientation; @@ -21,6 +23,7 @@ public abstract class BattleCommon implements Battle { protected final static Random random = new Random(System.currentTimeMillis()); + private Ctrl ctrl; protected final Factory factory; protected int _id; @@ -67,12 +70,14 @@ public abstract class BattleCommon implements Battle @Override public Factory.MapType getMapType() { return mapType; } @Override - public void init() + public Map init(Ctrl ctrl) { + this.ctrl = ctrl; this.map = factory.getMap(getMapType()); setup(); this.turnCount = 0; this.currentPlayer = players[0]; + return this.map; } @Override @@ -90,52 +95,49 @@ public abstract class BattleCommon implements Battle { this.currentPlayer = players[0]; deployPlayer(); - currentPlayer.turnEnd(); this.currentPlayer = players[1]; deployPlayer(); - currentPlayer.turnEnd(); this.currentPlayer = players[0]; - map.turnDone(); } public void load(Marshal.Mode mode, JsonValue value) { - map.load(mode, value); - if((mode == Marshal.Mode.FULL) || (mode == Marshal.Mode.STATE)) { - JsonValue v = value.get("battle"); - this.turnCount = v.getInt("turnCount"); + if (mode == Marshal.Mode.PLAYERS) { map.loadPlayers(value, players); + this.currentPlayer = players[0]; + } else { + if (mode == Marshal.Mode.MAP) { + JsonValue v = value.get("battle"); + this.turnCount = v.getInt("turnCount"); + Unit.unitId = v.getInt("unitId"); + Order.orderId = v.getInt("orderId"); + } + map.load(mode, value); } - this.currentPlayer = players[0]; } @Override public void unload(Marshal.Mode mode, Json json) { json.writeObjectStart(); - if((mode == Marshal.Mode.FULL) || (mode == Marshal.Mode.STATE)) { - json.writeObjectStart("battle"); - json.writeValue("turnCount", turnCount); - json.writeObjectEnd(); + if (mode == Marshal.Mode.PLAYERS) map.unloadPlayers(json, getPlayer(), getOpponent()); + else { + if (mode == Marshal.Mode.MAP) { + json.writeObjectStart("battle"); + json.writeValue("turnCount", this.turnCount); + json.writeValue("unitId", Unit.unitId); + json.writeValue("orderId", Order.orderId); + json.writeObjectEnd(); + } + map.unload(mode, json); } - map.unload(mode, json); json.writeObjectEnd(); } @Override - public boolean actionDone() - { - boolean burn = (map.unitsActivatedSize() > 0); - if (burn) - currentPlayer.burnDownOneAp(); - map.actionDone(); - return burn; - } - - @Override public boolean turnDone() { boolean ret = false; @@ -150,7 +152,7 @@ public abstract class BattleCommon implements Battle } turnCount += 1; setNextTurn(); - map.turnDone(); + map.clear(); return ret; } @@ -260,7 +262,7 @@ public abstract class BattleCommon implements Battle { Unit unit = factory.getUnit(unitCode, hq, ace); if (exitZone != null) unit.exitZone = exitZone; - map.setOnBoard(unit, map.getHex(col, row), orientation); + ctrl.postInitOrder(map.getSetOrder(unit, map.getHex(col, row), orientation)); return unit; } } diff --git a/core/src/ch/asynk/rustanddust/game/ctrl/Solo.java b/core/src/ch/asynk/rustanddust/game/ctrl/Solo.java index 54d2310..29a8755 100644 --- a/core/src/ch/asynk/rustanddust/game/ctrl/Solo.java +++ b/core/src/ch/asynk/rustanddust/game/ctrl/Solo.java @@ -7,8 +7,6 @@ import ch.asynk.rustanddust.game.Ctrl; public class Solo extends Ctrl { - private int gameId; - public Solo(final RustAndDust game) { super(game); @@ -17,8 +15,8 @@ public class Solo extends Ctrl @Override public void init() { - gameId = game.config.gameId; - if (gameId == game.db.NO_RECORD) { + GameRecord r = loadState(); + if (r == null) { int me = game.backend.getMyId(); int other = game.backend.getOpponentId(); gameId = game.db.storeGameGetId(other, battle.getId(), game.config.gameMode.i); @@ -27,68 +25,28 @@ public class Solo extends Ctrl battle.initialDeployment(); synched = true; } else { - GameRecord r = loadState(); - if (r != null) { - load(Marshal.Mode.STATE, r.state); - load(Marshal.Mode.ORDERS, r.orders); - battle.getMap().clearMarshalUnits(); - synched = r.synched; - r.dispose(); - } else - System.err.println("TODO : null GameRecord"); + load(Marshal.Mode.MAP, r.map); + load(Marshal.Mode.PLAYERS, r.players); + load(Marshal.Mode.ORDERS, r.orders); + battle.getMap().clearMarshalUnits(); + synched = r.synched; + r.dispose(); } } private GameRecord loadState() { GameRecord r = null; - switch (game.config.loadMode) { - case LOAD: - r = game.db.loadGame(gameId); - break; - case REPLAY_LAST: - r = game.db.loadLastTurn(gameId); - break; + gameId = game.config.gameId; + switch (game.config.loadMode) + { + case NEW: break; + case RESUME: r = game.db.loadGame(gameId); break; + case REPLAY_CURRENT: r = game.db.loadLastTurn(gameId); break; case REPLAY_ALL: // TODO REPLAY_ALL break; } return r; } - - @Override - public void orderProcessedCb() - { - if (!isLoading()) - storeOrders(); - } - - @Override - protected void actionDoneCb() - { - storeState(); - } - - @Override - protected void turnDoneCb() - { - storeOrders(); - storeState(); - storeTurn(); - } - - private void storeState() - { - game.db.storeGameState(gameId, battle.getTurnCount(), battle.getPlayer().id, unload(Marshal.Mode.STATE)); - } - - private void storeOrders() - { - game.db.storeGameOrders(gameId, battle.getTurnCount(), battle.getPlayer().id, unload(Marshal.Mode.ORDERS)); - } - - private void storeTurn() - { - game.db.storeLastTurn(gameId); - } } diff --git a/core/src/ch/asynk/rustanddust/game/hud/ActionButtons.java b/core/src/ch/asynk/rustanddust/game/hud/ActionButtons.java index 90ec017..e992867 100644 --- a/core/src/ch/asynk/rustanddust/game/hud/ActionButtons.java +++ b/core/src/ch/asynk/rustanddust/game/hud/ActionButtons.java @@ -6,7 +6,7 @@ import com.badlogic.gdx.graphics.glutils.ShapeRenderer; import ch.asynk.rustanddust.RustAndDust; import ch.asynk.rustanddust.game.Ctrl; -import ch.asynk.rustanddust.game.State.StateType; +import ch.asynk.rustanddust.game.Ctrl.MsgType; import ch.asynk.rustanddust.ui.Widget; import ch.asynk.rustanddust.ui.Bg; import ch.asynk.rustanddust.ui.Position; @@ -36,7 +36,7 @@ public class ActionButtons extends Widget private Sprite bg; private Bg buttons []; - private StateType states []; + private MsgType msgs []; public ActionButtons(RustAndDust game) { @@ -50,10 +50,10 @@ public class ActionButtons extends Widget this.buttons[Buttons.ABORT.i] = new Bg(game.factory.getHudRegion(game.factory.ACT_ABORT)); this.buttons[Buttons.PROMOTE.i] = new Bg(game.factory.getHudRegion(game.factory.ACT_PROMOTE)); - this.states = new StateType[Buttons.LAST.i]; - this.states[Buttons.DONE.i] = StateType.DONE; - this.states[Buttons.ABORT.i] = StateType.ABORT; - this.states[Buttons.PROMOTE.i] = StateType.PROMOTE; + this.msgs = new MsgType[Buttons.LAST.i]; + this.msgs[Buttons.DONE.i] = MsgType.OK; + this.msgs[Buttons.ABORT.i] = MsgType.CANCEL; + this.msgs[Buttons.PROMOTE.i] = MsgType.PROMOTE; } @Override @@ -135,7 +135,7 @@ public class ActionButtons extends Widget for (int i = 0; i < Buttons.LAST.i; i++) { if (buttons[i].hit(x, y)) { - ctrl.post(states[i]); + ctrl.sendMsg(msgs[i]); return true; } } diff --git a/core/src/ch/asynk/rustanddust/game/hud/PlayerInfo.java b/core/src/ch/asynk/rustanddust/game/hud/PlayerInfo.java index e96856f..9f86b13 100644 --- a/core/src/ch/asynk/rustanddust/game/hud/PlayerInfo.java +++ b/core/src/ch/asynk/rustanddust/game/hud/PlayerInfo.java @@ -141,12 +141,12 @@ public class PlayerInfo implements Disposable, Drawable, Animation return true; } else if (reinforcement.hit(x, y)) { - ctrl.postEvent(Ctrl.EventType.UNIT_DOCK_TOGGLE); + ctrl.sendMsg(Ctrl.MsgType.UNIT_DOCK_TOGGLE); return true; } else if (unitDock.hit(x, y)) { - ctrl.hud.notify(unitDock.selectedUnit.toString(), Position.TOP_CENTER); - ctrl.postEvent(Ctrl.EventType.UNIT_DOCK_SELECT, unitDock.selectedUnit); + ctrl.hud.notify(unitDock.selectedUnit.toString()); + ctrl.sendMsg(Ctrl.MsgType.UNIT_DOCK_SELECT, unitDock.selectedUnit); return true; } diff --git a/core/src/ch/asynk/rustanddust/game/map/Map1Units.java b/core/src/ch/asynk/rustanddust/game/map/Map1Units.java index 3aa0c8d..b490042 100644 --- a/core/src/ch/asynk/rustanddust/game/map/Map1Units.java +++ b/core/src/ch/asynk/rustanddust/game/map/Map1Units.java @@ -79,13 +79,13 @@ public abstract class Map1Units extends Map0Hex } } - public Unit unitsMoveableGet(int i) { return activableUnits.get(i); } + public Unit getFirstActivable() { return activableUnits.get(0); } public void unitsTargetClear() { targetUnits.clear(); } public void unitsActivatedClear() { activatedUnits.clear(); } public int unitsActivatedSize() { return activatedUnits.size(); } - public int unitsActivableSize() { return activableUnits.size(); } + public int unitsActivableSize() { return activableUnits.size(); } public boolean unitsTargetContains(Unit unit) { return targetUnits.contains(unit); } public boolean unitsActivableContains(Unit unit) { return activableUnits.contains(unit); } @@ -94,8 +94,8 @@ public abstract class Map1Units extends Map0Hex public void unitsTargetHide() { unitsShowOverlay(targetUnits, Unit.TARGET, false); } public void unitsAssistShow() { unitsShowOverlay(activableUnits, Unit.MAY_FIRE, true); } public void unitsAssistHide() { unitsShowOverlay(activableUnits, Unit.MAY_FIRE, false); unitsShowOverlay(activableUnits, Unit.FIRE, false); } - public void unitsActivableShow() { unitsShowOverlay(activableUnits, Unit.ACTIVEABLE, true); } - public void unitsActivableHide() { unitsShowOverlay(activableUnits, Unit.ACTIVEABLE, false); } + public void unitsActivableShow() { unitsShowOverlay(activableUnits, Unit.ACTIVEABLE, true); } + public void unitsActivableHide() { unitsShowOverlay(activableUnits, Unit.ACTIVEABLE, false); } private void unitsShowOverlay(UnitList units, int overlay, boolean on) { diff --git a/core/src/ch/asynk/rustanddust/game/map/Map2Moves.java b/core/src/ch/asynk/rustanddust/game/map/Map2Moves.java index e7ba8ce..e092fea 100644 --- a/core/src/ch/asynk/rustanddust/game/map/Map2Moves.java +++ b/core/src/ch/asynk/rustanddust/game/map/Map2Moves.java @@ -51,21 +51,10 @@ public abstract class Map2Moves extends Map1Units return 0; } - public void collectUpdate(Unit unit) - { - movesHide(); - unitsActivableHide(); - movesCollect(unit); - collectMoveable(unit); - movesShow(); - unitsActivableShow(); - activatedUnits.clear(); - } - public int pathsSize() { return paths.size(); } public void pathsClear() { paths.clear(); } public void pathsInit(Unit unit) { paths.init(unit); } - public void pathsInit(Unit unit, Hex hex) { paths.init(unit, hex); } + public void pathsInit(Unit unit, Hex from) { paths.init(unit, from); } public int pathsBuild(Hex hex) { return paths.build(hex); } public Hex pathsTo() { return (Hex) paths.to; } public void pathsSetOrientation(Orientation o) { paths.orientation = o; } diff --git a/core/src/ch/asynk/rustanddust/game/map/Map3Animations.java b/core/src/ch/asynk/rustanddust/game/map/Map3Animations.java index eba741b..d109366 100644 --- a/core/src/ch/asynk/rustanddust/game/map/Map3Animations.java +++ b/core/src/ch/asynk/rustanddust/game/map/Map3Animations.java @@ -4,6 +4,7 @@ import com.badlogic.gdx.audio.Sound; import com.badlogic.gdx.graphics.Texture; import ch.asynk.rustanddust.RustAndDust; +import ch.asynk.rustanddust.engine.Move; import ch.asynk.rustanddust.engine.SelectedTile; import ch.asynk.rustanddust.engine.gfx.Moveable; import ch.asynk.rustanddust.engine.gfx.animations.AnimationSequence; @@ -21,7 +22,7 @@ import ch.asynk.rustanddust.game.Hex; import ch.asynk.rustanddust.game.Unit; import ch.asynk.rustanddust.game.Army; import ch.asynk.rustanddust.game.Player; -import ch.asynk.rustanddust.game.Ctrl.EventType; +import ch.asynk.rustanddust.game.Ctrl.MsgType; public abstract class Map3Animations extends Map2Moves implements MoveToAnimationCb { @@ -31,6 +32,8 @@ public abstract class Map3Animations extends Map2Moves implements MoveToAnimatio private Sound sound; private long soundId = -1; + protected static final float BOUNCE_DURATION = 0.3f; + public Map3Animations(final RustAndDust game, Texture map, SelectedTile hex) { super(game, map, hex); @@ -92,18 +95,50 @@ public abstract class Map3Animations extends Map2Moves implements MoveToAnimatio // <- implement MoveToAnimationCb - protected void addBounceAnimation(final Unit unit, float duration) + protected void moveUnit(final Unit unit, final Move move, MoveToAnimationCb cb, boolean bounce) { - addAnimation(BounceAnimation.get(unit, duration)); + removePawn(unit); + + AnimationSequence seq = AnimationSequence.get(move.steps() + (bounce ? 2 : 1)); + if (bounce) seq.addAnimation(BounceAnimation.get(unit, BOUNCE_DURATION)); + unit.getMoveAnimation(move.iterator(), seq, cb); + seq.addAnimation(RunnableAnimation.get(unit, new Runnable() { + @Override + public void run() { + unit.move(move); + if (!move.to.isOffMap()) + setPawnOnto(unit, move.to, move.orientation); + } + })); + addAnimation(seq); } - protected void addPromoteAnimation(final Unit unit, final Player player, final Runnable after) + protected void revertLastUnitMove(final Unit unit, final Move move) { - Hex hex = unit.getHex(); - AnimationSequence seq = AnimationSequence.get(2); - seq.addAnimation(PromoteAnimation.get((unit.getArmy() == Army.US), hex.getX(), hex.getY(), game.config.fxVolume)); - seq.addAnimation(RunnableAnimation.get(unit, after)); + removePawn(unit); + revertClaim(unit, move); + + AnimationSequence seq = AnimationSequence.get(1); + unit.getRevertLastMoveAnimation(seq); + seq.addAnimation(RunnableAnimation.get(unit, new Runnable() { + @Override + public void run() { + setPawnOnto(unit, move.to, move.orientation); + } + })); addAnimation(seq); + unit.revertLastMove(); + } + + protected void addBounceAnimation(final Unit unit) + { + addAnimation(BounceAnimation.get(unit, BOUNCE_DURATION)); + } + + protected void addPromoteAnimation(final Unit unit, final Player player) + { + Hex hex = unit.getHex(); + addAnimation(PromoteAnimation.get((unit.getArmy() == Army.US), hex.getX(), hex.getY(), game.config.fxVolume)); } protected void addDestroyAnimation(Unit unit) @@ -142,6 +177,6 @@ public abstract class Map3Animations extends Map2Moves implements MoveToAnimatio addAnimation( SoundAnimation.get(SoundAnimation.Action.FADE_OUT, sound, soundId, game.config.fxVolume, 0.5f)); soundId = -1; } else - game.ctrl.postEvent(EventType.ANIMATIONS_DONE); + game.ctrl.sendMsg(MsgType.ANIMATIONS_DONE); } } diff --git a/core/src/ch/asynk/rustanddust/game/map/Map4Orders.java b/core/src/ch/asynk/rustanddust/game/map/Map4Orders.java index e3662e2..05cc569 100644 --- a/core/src/ch/asynk/rustanddust/game/map/Map4Orders.java +++ b/core/src/ch/asynk/rustanddust/game/map/Map4Orders.java @@ -6,8 +6,10 @@ import ch.asynk.rustanddust.RustAndDust; import ch.asynk.rustanddust.engine.Move; import ch.asynk.rustanddust.engine.SelectedTile; import ch.asynk.rustanddust.engine.Orientation; -import ch.asynk.rustanddust.game.Hex; +import ch.asynk.rustanddust.game.Ctrl.MsgType; import ch.asynk.rustanddust.game.Unit; +import ch.asynk.rustanddust.game.Hex; +import ch.asynk.rustanddust.game.Zone; import ch.asynk.rustanddust.game.Order; import ch.asynk.rustanddust.game.OrderList; import ch.asynk.rustanddust.game.Engagement; @@ -17,15 +19,12 @@ public abstract class Map4Orders extends Map3Animations protected final OrderList orders; protected final OrderList replayOrders; - protected int orderId; - protected abstract int engagementCost(Engagement e); protected abstract void resolveEngagement(Engagement e); public Map4Orders(final RustAndDust game, Texture map, SelectedTile hex) { super(game, map, hex); - this.orderId = 0; this.orders = new OrderList(10); this.replayOrders = new OrderList(10); } @@ -39,78 +38,126 @@ public abstract class Map4Orders extends Map3Animations Engagement.clearPool(); } - protected void incOrderId() { orderId += 1; } protected int ordersSize() { return orders.size(); } protected void ordersClear() { orders.dispose(); } // STATES ENTRY -> - public void showOnBoard(final Unit unit, Hex to, Orientation o) + public void setOnBoard(final Unit unit, Move move) { - setPawnOnto(unit, to, o); + setPawnOnto(unit, move); + addBounceAnimation(unit); } - public boolean setOnBoard(final Unit unit, Hex to, Orientation entry) + public void setOnBoard(final Unit unit, Hex to, Orientation o) { - orders.dispose(unit); - return process(getMoveOrder(unit, Move.getSet(unit, to, entry))); + setPawnOnto(unit, to, o); + addBounceAnimation(unit); } - public boolean enterBoard(final Unit unit, Hex to, int allowedMoves) + public boolean enterBoard(final Unit unit, Hex to, Zone entryZone) { - Orientation entry = findBestEntry(unit, to, allowedMoves); + Orientation entry = findBestEntry(unit, to, entryZone.allowedMoves); if (entry == Orientation.KEEP) return false; - - return process(getMoveOrder(unit, Move.getEnter(unit, to, entry))); + unit.spendMovementPoints(to.costFrom(unit, entry)); + setOnBoard(unit, to, entry.opposite()); + return true; } - public boolean exitBoard(final Unit unit) + public void revertEnter(final Unit unit) { - return process(getMoveOrder(unit, paths.getExitMove())); + removePawn(unit); + unit.reset(); } - public boolean moveUnit(final Unit unit) + public Order getSetOrder(final Unit unit, final Hex to, final Orientation o) { - return process(getMoveOrder(unit, paths.getMove())); + Order order = getMoveOrder(unit, Move.getSet(unit, to, o), false); + order.cost = 0; + + return order; } - public void revertMoves() + public Order getRevertSetOrder(Unit unit) { - for (Unit unit: activatedUnits) { - RustAndDust.debug(" revertMove() " + unit); - revertLastPawnMove(unit, ((Order) orders.get(unit, Order.OrderType.MOVE)).move); - orders.dispose(unit, Order.OrderType.MOVE); + Order o = orders.get(unit, Order.OrderType.MOVE); + if (o == null) { + RustAndDust.error(String.format("can't revert order : %s %s", Order.OrderType.MOVE, unit)); + return null; } - activatedUnits.clear(); + Order order = Order.REVERT; + order.setRevert(o.id); + + return order; } - public void revertEnter(final Unit unit) + public Order getExitOrder(final Unit unit, boolean hqMode) { - RustAndDust.debug(" revertEnter() "+ unit); + Order order = getMoveOrder(unit, paths.getExitMove(), hqMode); - revertclaim(unit, unit.getHex()); - removePawn(unit); - game.ctrl.battle.getPlayer().revertUnitEntry(unit); - orders.dispose(unit); - unit.reset(); + return order; } - public boolean engageUnit(final Unit unit, final Unit target) + public Order getEnterOrder(final Unit unit, boolean hqMode) { - attack(unit, target, true); + Order order = getMoveOrder(unit, paths.getEnterMove(unit, getAdjTileAt(unit.getTile(), unit.getOrientation().opposite())), hqMode); + + return order; + } + + public Order getMoveOrder(final Unit unit, boolean hqMode) + { + Order order = getMoveOrder(unit, paths.getMove(), hqMode); + return order; + } + + // FIXME revertMoves(...) + // public void revertMoves() + // { + // for (Unit unit: activatedUnits) { + // RustAndDust.debug(" revertMove() " + unit); + // revertLastPawnMove(unit, ((Order) orders.get(unit, Order.OrderType.MOVE)).move); + // orders.dispose(unit, Order.OrderType.MOVE); + // } + // activatedUnits.clear(); + // } + + public Order getEngageOrder(final Unit unit, final Unit target) + { + attack(unit, target, true); Order order = Order.get(); order.setEngage(unit, target); - process(order); - return order.engagement.success; + + Engagement e = order.engagement; + resolveEngagement(e); + order.setActivables(activableUnits); + if ((e.cost > 0) && order.activables.size() > 0) + order.cost = 0; + + return order; } - public boolean promoteUnit(final Unit unit) + public Order getPromoteOrder(final Unit unit) { Order order = Order.get(); order.setPromote(unit); - return process(order); + + return order; + } + + private Order getMoveOrder(Unit leader, Move move, boolean hqMode) + { + Order order = Order.get(); + order.setMove(leader, move); + activableUnits.remove((Unit) move.pawn); + activatedUnits.add((Unit) move.pawn); + order.setActivables(activableUnits); + if (hqMode && order.activables.size() > 0) + order.cost = 0; + + return order; } // STATES ENTRY <- @@ -120,22 +167,36 @@ public abstract class Map4Orders extends Map3Animations public void prepareReplayLastAction() { int s = orders.size(); - int a = orders.get(s - 1).id; - while (s > 0) { + if (s == 0) return; + + boolean more = true; + // int a = orders.get(s - 1).id; + while (more) { s -= 1; Order o = orders.get(s); - if (o.id != a) - break; + o.replay = true; replayOrders.add(o); + if (s == 0) { + more = false; + } else { + Order prev = orders.get(s - 1); + // first order cost=1 part of a group action + if ((o.cost > 0) && (s > 0) && replayOrders.size() == 1) + more = ((prev.cost == 0) && (prev.type == o.type)); + else // part of a group action + more = ((o.cost == 0) && (prev.cost == 0) && (prev.type == o.type)); + } } } - public void prepareReplayLastTurn() + public void prepareReplayCurrentTurn() { int s = orders.size(); while (s > 0) { s -= 1; - replayOrders.add(orders.get(s)); + Order o = orders.get(s); + o.replay = true; + replayOrders.add(o); } } @@ -147,154 +208,129 @@ public abstract class Map4Orders extends Map3Animations return replayOrders.remove(s - 1); } - public boolean replay(Order order) - { - return process(order, true); - } - // REPLAY <- - private Order getMoveOrder(Unit unit, Move move) + // EXECUTE -> + + public void execute(final Order order) { - Order order = Order.get(); - order.setMove(unit, move); - return order; + RustAndDust.debug(" Order", order.toString()); + + switch(order.type) + { + case MOVE: executeMove(order); break; + case ENGAGE: executeEngage(order); break; + case PROMOTE: executePromote(order); break; + case END: executeEnd(order); return; + case REVERT: executeRevert(order); return; + default: + RustAndDust.error(String.format("Unhandled Order Type %s", order.type)); + break; + } + + if (order.replay) { + activableUnits.clear(); + for (Unit u : order.activables) + activableUnits.add(u); + } else + orders.add(order); } - private boolean process(Order order) + private void executePromote(final Order order) { - return process(order, false); + addPromoteAnimation(order.leader, game.ctrl.battle.getPlayer()); } - private boolean process(Order order, boolean replay) + private void executeEngage(final Order order) { - RustAndDust.debug("Order", order.toString()); + Engagement e = order.engagement; - boolean r = false; + e.attacker.engage(); + for (Unit u : e.assists) + u.engage(); - switch(order.type) { - case MOVE: - r = doMove(order.unit, order.move, replay); - break; - case PROMOTE: - r = doPromote(order.unit, replay); - break; - case ENGAGE: - r = doEngagement(order.engagement, replay); - break; - default: - RustAndDust.error(String.format("Unhandled Order Type %s", order.type)); - break; - } - - if (r && !replay) { - order.id = orderId; - order.setActivable(activableUnits); - order.cost = ((activatedUnits.size() > 0) ? ((activableUnits.size() > 0) ? 0 : 1) : 0); - orders.add(order); - game.ctrl.orderProcessedCb(); + if (order.replay) { + activatedUnits.clear(); + activatedUnits.add(e.attacker); + addBounceAnimation(e.attacker); + for (Unit u : e.assists) { + activatedUnits.add(u); + addBounceAnimation(u); + } } - if (replay) { - activableUnits.clear(); - for (Unit u : order.activable) - activableUnits.add(u); - orderId = order.id; + if (e.success) { + unclaim(e.defender, e.defender.getHex()); + removePawn(e.defender); + addDestroyAnimation(e.defender); } - - return r; + addEngagementAnimation(e.defender); } - private boolean doMove(Unit unit, Move move, boolean replay) + private void executeMove(final Order order) { - RustAndDust.debug(" Move", String.format("%s %s", move.type, move.toString())); + final Unit leader = order.leader; + final Unit unit = (Unit) order.move.pawn; + final Move move = order.move; - switch(move.type) { + switch(move.type) + { case REGULAR: - initMove(unit); - movePawn(unit, move, this); - break; - case EXIT: - initMove(unit); - movePawn(unit, move, this); - game.ctrl.battle.getPlayer().unitWithdraw(unit); + playMoveSound(unit); + moveUnit(unit, move, this, order.replay); break; case SET: - setPawnOnto(unit, move); - game.ctrl.battle.getPlayer().unitEntry(unit); claim(unit, move.to); - addBounceAnimation(unit, 0.3f); + if (!order.replay) + orders.dispose(unit, Order.OrderType.MOVE); + setOnBoard(unit, move); break; case ENTER: - enterPawn(unit, move); - game.ctrl.battle.getPlayer().unitEntry(unit); - claim(unit, move.to); - addBounceAnimation(unit, 0.3f); + claim(unit, move.from); + if (order.replay) + unit.setOnTile(move.from, Orientation.NORTH.r()); + playMoveSound(unit); + moveUnit(unit, move, this, order.replay); + break; + case EXIT: + playMoveSound(unit); + moveUnit(unit, move, this, order.replay); break; default: - RustAndDust.error(String.format("Unhandled Move Type %s", move.type)); - return false; + RustAndDust.error(String.format("Unhandled Move Type %s", order.move.type)); } - - return true; - } - - private void initMove(Unit unit) - { - activableUnits.remove(unit); - activatedUnits.add(unit); - playMoveSound(unit); } - private boolean doPromote(final Unit unit, boolean replay) + private void executeRevert(Order order) { - activableUnits.remove(unit); - activatedUnits.add(unit); - addPromoteAnimation(unit, game.ctrl.battle.getPlayer(), new Runnable() { - @Override - public void run() { - game.ctrl.battle.getPlayer().promote(unit); - } - }); - return true; - } + int id = order.id; + order = orders.getId(id); + orders.remove(order); - private boolean doEngagement(Engagement e, boolean replay) - { - if (replay) { - activatedUnits.clear(); - for (Unit u : e.assists) { - u.engage(); - activatedUnits.add(u); - } - e.attacker.engage(); - activatedUnits.add(e.attacker); - } else { - resolveEngagement(e); - activableUnits.clear(); - if (e.success) { - for (Unit u : activatedUnits) { - u.engage(); - if (u.canBreak()) - activableUnits.add(u); - } - } + if (order.type != Order.OrderType.MOVE) { + RustAndDust.error(String.format("Unhandled Revert for Order Type %s", order.type)); + return; } - if (e.success) { - unclaim(e.defender, e.defender.getHex()); - removePawn(e.defender); - addDestroyAnimation(e.defender); + Unit unit = (Unit) order.move.pawn; + switch(order.move.type) + { + case SET: + removePawn(unit); + unclaim(unit, order.move.to); + game.ctrl.sendMsg(MsgType.UNIT_UNDEPLOYED, unit); + break; + case REGULAR: + case EXIT: + case ENTER: + default: + RustAndDust.error(String.format("Unhandled Move Type %s", order.move.type)); } - - if (!replay) - game.ctrl.hud.engagementSummary(e); - addEngagementAnimation(e.defender); - - if (engagementCost(e) == 0) - activatedUnits.clear(); - - return true; + order.dispose(); } + private void executeEnd(Order order) + { + orders.get(orders.size() - 1).cost = 1; + } } diff --git a/core/src/ch/asynk/rustanddust/game/map/Map5Marshal.java b/core/src/ch/asynk/rustanddust/game/map/Map5Marshal.java index 9447c38..b291062 100644 --- a/core/src/ch/asynk/rustanddust/game/map/Map5Marshal.java +++ b/core/src/ch/asynk/rustanddust/game/map/Map5Marshal.java @@ -37,10 +37,11 @@ public abstract class Map5Marshal extends Map4Orders implements Marshal @Override public void unload(Marshal.Mode mode, Json json) { - if((mode == Marshal.Mode.FULL) || (mode == Marshal.Mode.STATE)) - unloadMap(json); - else if(mode == Marshal.Mode.ORDERS) - unloadOrders(json, orders); + switch(mode) + { + case MAP: unloadMap(json); break; + case ORDERS: unloadOrders(json, orders); break; + } } public void unloadPlayers(Json json, Player a, Player b) @@ -160,20 +161,15 @@ public abstract class Map5Marshal extends Map4Orders implements Marshal json.writeValue("id", o.id); json.writeValue("type", o.type); json.writeValue("cost", o.cost); - switch(o.type) { - case MOVE: - unloadMoveOrder(json, o.move); - break; - case ENGAGE: - unloadEngageOrder(json, o.engagement); - break; - case PROMOTE: - unloadPromoteOrder(json, o.unit); - break; + switch(o.type) + { + case MOVE: unloadMoveOrder(json, o.leader, o.move); break; + case ENGAGE: unloadEngageOrder(json, o.engagement); break; + case PROMOTE: unloadPromoteOrder(json, o.leader); break; } - if (o.activable.size() > 0) { + if (o.activables.size() > 0) { json.writeArrayStart("a"); - for(Unit u : o.activable) + for(Unit u : o.activables) json.writeValue(u.id()); json.writeArrayEnd(); } @@ -182,9 +178,11 @@ public abstract class Map5Marshal extends Map4Orders implements Marshal json.writeArrayEnd(); } - private void unloadMoveOrder(Json json, Move m) + private void unloadMoveOrder(Json json, Unit leader, Move m) { json.writeValue("mType", m.type); + json.writeValue("mCost", m.cost); + json.writeValue("l", leader.id()); json.writeValue("u", ((Unit) m.pawn).id()); if (m.from != null) { json.writeArrayStart("from"); @@ -267,10 +265,10 @@ public abstract class Map5Marshal extends Map4Orders implements Marshal @Override public void load(Marshal.Mode mode, JsonValue v) { - if((mode == Marshal.Mode.FULL) || (mode == Marshal.Mode.STATE)) - loadMap(v.get("map")); - else if(mode == Marshal.Mode.ORDERS) - loadOrders(v.get("orders")); + switch(mode) { + case MAP: loadMap(v.get("map")); break; + case ORDERS: loadOrders(v.get("orders")); break; + } } public void loadPlayers(JsonValue v, Player[] players) @@ -323,8 +321,7 @@ public abstract class Map5Marshal extends Map4Orders implements Marshal if (pos) { a = v.get("p"); Hex h = getHex(a.getInt(0), a.getInt(1)); - u.setRotation(a.getInt(2)); - showOnBoard(u, h, Orientation.fromRotation(a.getInt(2))); + setOnBoard(u, h, Orientation.fromRotation(a.getInt(2))); } units.add(u); return u; @@ -366,23 +363,18 @@ public abstract class Map5Marshal extends Map4Orders implements Marshal for (int i = 0; i < v.size; i++) { JsonValue o = v.get(i); Order order = null; - switch(Order.OrderType.valueOf(o.getString("type"))) { - case MOVE: - order = loadMoveOrder(o); - break; - case ENGAGE: - order = loadEngageOrder(o); - break; - case PROMOTE: - order = loadPromoteOrder(o); - break; + switch(Order.OrderType.valueOf(o.getString("type"))) + { + case MOVE: order = loadMoveOrder(o); break; + case ENGAGE: order = loadEngageOrder(o); break; + case PROMOTE: order = loadPromoteOrder(o); break; } order.id = o.getInt("id"); order.cost = o.getInt("cost"); JsonValue a = o.get("a"); if (a != null) { for (int j = 0; j < a.size; j++) { - order.activable.add(findById(a.getInt(j))); + order.activables.add(findById(a.getInt(j))); } } orders.add(order); @@ -391,6 +383,7 @@ public abstract class Map5Marshal extends Map4Orders implements Marshal private Order loadMoveOrder(JsonValue v) { + Unit leader = findById(v.getInt("l")); Unit unit = findById(v.getInt("u")); if (unit == null) return null; Hex from = loadHex(v, "from"); @@ -408,24 +401,20 @@ public abstract class Map5Marshal extends Map4Orders implements Marshal } Move m = null; - switch(Move.MoveType.valueOf(v.getString("mType"))) { - case REGULAR: - m = Move.get(unit, from, to, orientation, path); - break; - case ENTER: - m = Move.getEnter(unit, to, orientation); - break; - case SET: - m = Move.getSet(unit, to, orientation); - break; + switch(Move.MoveType.valueOf(v.getString("mType"))) + { + case REGULAR: m = Move.get(unit, from, to, orientation, path); break; + case ENTER: m = Move.getEnter(unit, from, to, orientation, path); break; + case SET: m = Move.getSet(unit, to, orientation); break; case EXIT: m = Move.get(unit, from, to, orientation, path); m.type = Move.MoveType.EXIT; break; } + m.cost = v.getInt("mCost"); Order o = Order.get(); - o.setMove(unit, m); + o.setMove(leader, m); return o; } diff --git a/core/src/ch/asynk/rustanddust/game/states/StateAnimation.java b/core/src/ch/asynk/rustanddust/game/states/StateAnimation.java index c19f16b..4c6a965 100644 --- a/core/src/ch/asynk/rustanddust/game/states/StateAnimation.java +++ b/core/src/ch/asynk/rustanddust/game/states/StateAnimation.java @@ -5,23 +5,7 @@ public class StateAnimation extends StateCommon @Override public void enterFrom(StateType prevState) { + ctrl.blockMap = true; ctrl.hud.actionButtons.hide(); } - - @Override - public void leaveFor(StateType nextState) - { - } - - @Override - public StateType abort() - { - return StateType.ABORT; - } - - @Override - public StateType execute() - { - return StateType.DONE; - } } diff --git a/core/src/ch/asynk/rustanddust/game/states/StateBreak.java b/core/src/ch/asynk/rustanddust/game/states/StateBreak.java deleted file mode 100644 index 1dab40b..0000000 --- a/core/src/ch/asynk/rustanddust/game/states/StateBreak.java +++ /dev/null @@ -1,76 +0,0 @@ -package ch.asynk.rustanddust.game.states; - -import ch.asynk.rustanddust.engine.Orientation; -import ch.asynk.rustanddust.game.Hex; -import ch.asynk.rustanddust.game.Unit; -import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons; - -public class StateBreak extends StateCommon -{ - private Orientation o = Orientation.KEEP; - - @Override - public void enterFrom(StateType prevState) - { - activeUnit = null; - ctrl.hud.actionButtons.show(Buttons.DONE.b); - ctrl.hud.notify("Break Through possible"); - map.unitsActivableShow(); - } - - @Override - public void leaveFor(StateType nextState) - { - map.unitsActivableHide(); - map.hexMoveHide(to); - map.hexDirectionsHide(to); - if (activeUnit != null) map.hexMoveHide(activeUnit.getHex()); - } - - @Override - public StateType abort() - { - return StateType.ABORT; - } - - @Override - public StateType execute() - { - return StateType.DONE; - } - - @Override - public void touch(Hex hex) - { - // TODO : cancel preview move before showing rotation - if (activeUnit == null) { - Unit unit = hex.getUnit(); - if (map.unitsActivableContains(unit)) { - activeUnit = unit; - map.hexMoveShow(hex); - map.hexMoveShow(to); - map.hexDirectionsShow(to); - map.unitsActivableHide(); - } - } else { - o = Orientation.fromAdj(to, hex); - - if (o == Orientation.KEEP) return; - - doRotation(o); - ctrl.post(StateType.ANIMATION); - } - } - - private void doRotation(Orientation o) - { - if (activeUnit == null) return; - - map.pathsInit(activeUnit); - map.pathsBuild(to); - map.pathsChooseShortest(); - map.pathsSetOrientation(o); - map.moveUnit(activeUnit); - ctrl.setAfterAnimationState(StateType.DONE); - } -} diff --git a/core/src/ch/asynk/rustanddust/game/states/StateCommon.java b/core/src/ch/asynk/rustanddust/game/states/StateCommon.java index b894c0f..1614465 100644 --- a/core/src/ch/asynk/rustanddust/game/states/StateCommon.java +++ b/core/src/ch/asynk/rustanddust/game/states/StateCommon.java @@ -1,12 +1,13 @@ package ch.asynk.rustanddust.game.states; +import ch.asynk.rustanddust.RustAndDust; import ch.asynk.rustanddust.game.Map; import ch.asynk.rustanddust.game.Hex; import ch.asynk.rustanddust.game.Unit; import ch.asynk.rustanddust.game.Ctrl; +import ch.asynk.rustanddust.game.Ctrl.MsgType; import ch.asynk.rustanddust.game.State; import ch.asynk.rustanddust.game.Config; -import ch.asynk.rustanddust.RustAndDust; public abstract class StateCommon implements State { @@ -17,7 +18,6 @@ public abstract class StateCommon implements State protected static Hex selectedHex = null; protected static Hex to = null; - protected boolean isEnemy; protected static Unit activeUnit; protected static Unit selectedUnit; @@ -28,26 +28,12 @@ public abstract class StateCommon implements State map = game.ctrl.map; } - protected boolean hasUnit() - { - return (selectedUnit != null); - } - - protected void showPossibilities(Unit unit) - { - if (cfg.showMoves && unit.canMove()) map.movesShow(); - if (cfg.showTargets && unit.canEngage()) map.unitsTargetShow(); - if (cfg.showMoveAssists && unit.canMove()) map.unitsActivableShow(); - unit.hideActiveable(); - } + @Override + public void touch(Hex hex) { } - protected void hidePossibilities() + @Override + public boolean processMsg(MsgType state, Object data) { - map.movesHide(); - map.unitsTargetHide(); - map.unitsActivableHide(); + return false; } - - @Override - public void touch(Hex hex) { } } diff --git a/core/src/ch/asynk/rustanddust/game/states/StateDeployment.java b/core/src/ch/asynk/rustanddust/game/states/StateDeployment.java index f967917..27ed7b8 100644 --- a/core/src/ch/asynk/rustanddust/game/states/StateDeployment.java +++ b/core/src/ch/asynk/rustanddust/game/states/StateDeployment.java @@ -5,6 +5,7 @@ import ch.asynk.rustanddust.game.Hex; import ch.asynk.rustanddust.game.Zone; import ch.asynk.rustanddust.game.Unit; import ch.asynk.rustanddust.game.UnitList; +import ch.asynk.rustanddust.game.Ctrl.MsgType; import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons; public class StateDeployment extends StateCommon @@ -15,55 +16,48 @@ public class StateDeployment extends StateCommon @Override public void enterFrom(StateType prevState) { - if (selectedHex != null) - map.hexUnselect(selectedHex); - entryZone = null; - selectedHex = null; - selectedUnit = null; - ctrl.hud.actionButtons.hide(); + clear(); ctrl.hud.playerInfo.unitDock.show(); } @Override - public void leaveFor(StateType nextState) - { - selectedUnit = null; - if (selectedHex != null) - map.hexUnselect(selectedHex); - if (entryZone != null) - entryZone.enable(Hex.AREA, false); - ctrl.hud.playerInfo.unitDock.hide(); - } - - @Override - public StateType abort() + public boolean processMsg(MsgType msg, Object data) { - if (activeUnit != null) - undo(); - return StateType.DEPLOYMENT; - } + switch(msg) + { + case UNIT_DOCK_SELECT: + showEntryZone((Unit) data); + return true; + case CANCEL: + if (activeUnit != null) + undeployUnit(); + return true; + case OK: + deployedUnits.clear(); + ctrl.postTurnDone(); + return true; + case UNIT_DEPLOYED: + deployedUnits.add((Unit) data); + return true; + case UNIT_UNDEPLOYED: + ctrl.battle.getPlayer().revertUnitEntry((Unit) data); + return true; + } - @Override - public StateType execute() - { - deployedUnits.clear(); - return StateType.DONE; + return false; } @Override public void touch(Hex hex) { - Unit unit = ctrl.hud.playerInfo.unitDock.selectedUnit; - if (hex == null) { - showEntryZone(unit); - } else if (selectedUnit != null) { + if (activeUnit != null) { deployUnit(Orientation.fromAdj(selectedHex, hex)); - } else if (!ctrl.battle.isDeploymentDone() && (entryZone != null) && (hex != null)) { + } else if ((selectedUnit != null) && (entryZone != null)) { if (hex.isEmpty() && entryZone.contains(hex)) { - showUnit(activeUnit, hex); + showUnit(selectedUnit, hex); } } else { - unit = hex.getUnit(); + Unit unit = hex.getUnit(); if (deployedUnits.contains(unit)) showRotation(unit, hex); } @@ -71,28 +65,19 @@ public class StateDeployment extends StateCommon private void showEntryZone(Unit unit) { - activeUnit = unit; - if (entryZone != null) entryZone.enable(Hex.AREA, false); - entryZone = activeUnit.entryZone; + selectedUnit = unit; + if (entryZone != null) + entryZone.enable(Hex.AREA, false); + entryZone = unit.entryZone; entryZone.enable(Hex.AREA, true); } - private void undo() - { - map.hexUnselect(selectedHex); - map.hexDirectionsHide(selectedHex); - map.revertEnter(activeUnit); - activeUnit = null; - selectedUnit = null; - ctrl.hud.update(); - } - private void showUnit(Unit unit, Hex hex) { - selectedUnit = unit; + activeUnit = unit; selectedHex = hex; ctrl.battle.getPlayer().reinforcement.remove(unit); - map.showOnBoard(unit, hex, entryZone.orientation); + map.setOnBoard(unit, hex, entryZone.orientation); deployedUnits.add(unit); entryZone.enable(Hex.AREA, false); showRotation(unit, hex); @@ -102,7 +87,6 @@ public class StateDeployment extends StateCommon private void showRotation(Unit unit, Hex hex) { activeUnit = unit; - selectedUnit = unit; selectedHex = hex; map.hexSelect(selectedHex); map.hexDirectionsShow(selectedHex); @@ -113,16 +97,29 @@ public class StateDeployment extends StateCommon private void deployUnit(Orientation o) { if (o == Orientation.KEEP) - o = selectedUnit.getOrientation(); - map.setOnBoard(selectedUnit, selectedHex, o); + o = activeUnit.getOrientation(); + ctrl.postOrder(map.getSetOrder(activeUnit, selectedHex, o), StateType.DEPLOYMENT); + clear(); + } - entryZone = null; + private void undeployUnit() + { + ctrl.postOrder(map.getRevertSetOrder(activeUnit), StateType.DEPLOYMENT); + ctrl.hud.update(); + clear(); + ctrl.hud.playerInfo.unitDock.show(); + } + + private void clear() + { + if (selectedHex != null) { + map.hexUnselect(selectedHex); + map.hexDirectionsHide(selectedHex); + } activeUnit = null; + entryZone = null; + selectedHex = null; selectedUnit = null; - map.hexUnselect(selectedHex); - map.hexDirectionsHide(selectedHex); ctrl.hud.actionButtons.hide(); - ctrl.hud.playerInfo.unitDock.show(); - ctrl.post(StateType.DONE); } } diff --git a/core/src/ch/asynk/rustanddust/game/states/StateEngage.java b/core/src/ch/asynk/rustanddust/game/states/StateEngage.java index bfeced8..ccd79c7 100644 --- a/core/src/ch/asynk/rustanddust/game/states/StateEngage.java +++ b/core/src/ch/asynk/rustanddust/game/states/StateEngage.java @@ -1,89 +1,158 @@ package ch.asynk.rustanddust.game.states; +import ch.asynk.rustanddust.engine.Orientation; +import ch.asynk.rustanddust.ui.Position; import ch.asynk.rustanddust.game.Hex; import ch.asynk.rustanddust.game.Unit; +import ch.asynk.rustanddust.game.Order; +import ch.asynk.rustanddust.game.Ctrl.MsgType; +import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons; public class StateEngage extends StateCommon { + // selectedUnit -> fire leader + // activeUnit -> target / break + + private boolean breakMove = false; + @Override public void enterFrom(StateType prevState) { if (prevState == StateType.SELECT) { - // activeUnit will be target - activeUnit = null; - if (to != null) { - // quick fire -> replay touchUp - touch(to); + breakMove = false; + if ((to != null) && (activeUnit != null)) { + // quick fire + selectTarget(activeUnit, to); } selectedUnit.showAttack(); map.hexSelect(selectedHex); + } else { + breakMove = true; + activeUnit = null; + ctrl.hud.actionButtons.show(Buttons.DONE.b); + ctrl.hud.notify("Break Through possible", Position.MIDDLE_CENTER); + map.unitsActivableShow(); + map.hexUnselect(selectedHex); } } @Override - public void leaveFor(StateType nextState) + public boolean processMsg(MsgType msg, Object data) + { + switch(msg) + { + case OK: + if (breakMove) + abortBreakMove(); + return true; + } + + return false; + } + + @Override + public void touch(Hex hex) + { + Unit unit = hex.getUnit(); + + if (!breakMove) { + if (unit == selectedUnit) + abort(); + else if ((activeUnit == null) && map.unitsTargetContains(unit)) + selectTarget(unit, hex); + else if (unit == activeUnit) + engage(); + else if ((activeUnit != null) && map.unitsActivableContains(unit)) + map.toggleAssist(unit); + } else { + if (activeUnit == null) { + if (map.unitsActivableContains(unit)) + selectBreakUnit(unit); + } else { + Orientation o = Orientation.fromAdj(to, hex); + if (o == Orientation.KEEP) + unselectBreakUnit(); + else + doRotation(o); + } + + } + } + + private void selectTarget(Unit unit, Hex hex) + { + to = hex; + activeUnit = unit; + map.unitsTargetHide(); + activeUnit.showTarget(); + map.collectAssists(selectedUnit, activeUnit, ctrl.battle.getPlayer().units); + map.unitsAssistShow(); + } + + private void engage() { + activeUnit.hideTarget(); selectedUnit.hideAttack(); map.unitsAssistHide(); - map.unitsTargetHide(); map.hexUnselect(selectedHex); - if (to != null) - map.hexUnselect(to); + Order order = map.getEngageOrder(selectedUnit, activeUnit); + + if (order.cost == 0) + ctrl.postOrder(order, StateType.ENGAGE); + else { + order.cost = order.engagement.cost; + ctrl.postOrder(order); + } } - @Override - public StateType abort() + private void abort() { + map.unitsAssistHide(); + map.unitsTargetHide(); + activeUnit.hideTarget(); + selectedUnit.hideAttack(); + map.hexUnselect(selectedHex); map.unitsActivatedClear(); - return StateType.ABORT; + ctrl.postActionAborted(); } - @Override - public StateType execute() + private void selectBreakUnit(Unit unit) { - map.unitsAssistHide(); - StateType nextState = StateType.DONE; - if (map.engageUnit(selectedUnit, activeUnit)) { - ctrl.battle.getPlayer().engagementWon += 1; - ctrl.battle.getOpponent().casualty(activeUnit); - if (map.unitsActivableSize() > 0) { - nextState = StateType.BREAK; - } - } else { - ctrl.battle.getPlayer().engagementLost += 1; - } + activeUnit = unit; + map.hexMoveShow(to); + map.hexMoveShow(unit.getHex()); + map.hexDirectionsShow(to); + map.unitsActivableHide(); + } - activeUnit.showTarget(); - ctrl.setAfterAnimationState(nextState); - return StateType.ANIMATION; + private void unselectBreakUnit() + { + map.hexMoveHide(to); + map.hexMoveHide(activeUnit.getHex()); + map.hexDirectionsHide(to); + map.unitsActivableShow(); + activeUnit = null; } - @Override - public void touch(Hex hex) + private void doRotation(Orientation o) { - Unit unit = hex.getUnit(); + map.hexMoveHide(to); + map.hexMoveHide(activeUnit.getHex()); + map.hexDirectionsHide(to); + map.pathsInit(activeUnit); + map.pathsBuild(to); + map.pathsChooseShortest(); + map.pathsSetOrientation(o); + ctrl.postOrder(map.getMoveOrder(activeUnit, false)); + } - // activeUnit is the target, selectedTarget is the engagement leader - if (unit == selectedUnit) { - ctrl.post(StateType.ABORT); - } else if ((activeUnit == null) && map.unitsTargetContains(unit)) { - // ctrl.hud.notify("Engage " + unit); - map.unitsTargetHide(); - to = hex; - activeUnit = unit; - activeUnit.showTarget(); - map.collectAssists(selectedUnit, activeUnit, ctrl.battle.getPlayer().units); - map.unitsAssistShow(); - } - else if (unit == activeUnit) { - ctrl.post(StateType.DONE); - } - else if ((activeUnit != null) && map.unitsActivableContains(unit)) { - map.toggleAssist(unit); - // if (map.toggleAssist(unit)) - // ctrl.hud.notify(unit + " will fire"); - // else - // ctrl.hud.notify(unit + " wont fire"); - } + private void abortBreakMove() + { + if (activeUnit != null) + map.hexMoveHide(activeUnit.getHex()); + map.hexMoveHide(to); + map.hexDirectionsHide(to); + map.unitsActivableHide(); + ctrl.postOrder(Order.END); } } diff --git a/core/src/ch/asynk/rustanddust/game/states/StateMove.java b/core/src/ch/asynk/rustanddust/game/states/StateMove.java index 3aa684d..ae0c751 100644 --- a/core/src/ch/asynk/rustanddust/game/states/StateMove.java +++ b/core/src/ch/asynk/rustanddust/game/states/StateMove.java @@ -1,103 +1,125 @@ package ch.asynk.rustanddust.game.states; -import ch.asynk.rustanddust.ui.Position; +import ch.asynk.rustanddust.engine.Orientation; import ch.asynk.rustanddust.game.Hex; import ch.asynk.rustanddust.game.Unit; +import ch.asynk.rustanddust.game.Order; +import ch.asynk.rustanddust.game.Ctrl.MsgType; import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons; public class StateMove extends StateCommon { + enum State + { + SHOW, + PATH, + ROTATE, + EXIT + } + + private State state; + private boolean enter; + private boolean hqMode; + private boolean notFirst; + @Override public void enterFrom(StateType prevState) { - ctrl.hud.actionButtons.show( - ((map.unitsActivatedSize() > 0) ? Buttons.DONE.b : 0) - ); + state = State.SHOW; - if (prevState == StateType.WITHDRAW) { - completePath(map.pathsSize()); - return; - } + enter = false; + hqMode = false; + notFirst = false; map.pathsClear(); - if (prevState == StateType.SELECT) { - // use selectedHex and selectedUnit + map.hexSelect(selectedHex); + map.pathsInit(selectedUnit); activeUnit = selectedUnit; - map.pathsInit(activeUnit); - map.collectUpdate(activeUnit); - if (to != null) { - // quick move -> replay touchUp - touch(to); - } else - checkExit(activeUnit); - } else { - // back from rotation -> chose next Pawn - if (selectedUnit.canMove()) { - changeUnit(selectedUnit); + if (to == null) { + hqMode = true; + map.movesShow(); + } else { + collectPaths(to); + } + } else if (prevState == StateType.REINFORCEMENT) { + enter = true; + map.hexSelect(selectedHex); + map.pathsInit(selectedUnit); + if (selectedUnit.getMovementPoints() > 0) { + map.movesCollect(selectedUnit); + map.movesShow(); } else { - changeUnit(map.unitsMoveableGet(0)); + to = selectedHex; + showRotation(to); + collectPaths(to); } + } else { + notFirst = hqMode = true; + selectNextUnit(); } - map.unitsActivableShow(); + if (hqMode) + map.unitsActivableShow(); activeUnit.hideActiveable(); + int n = (notFirst ? Buttons.DONE.b : 0); + n |= (enter ? Buttons.ABORT.b : 0); + ctrl.hud.actionButtons.show(n); } @Override - public void leaveFor(StateType nextState) + public boolean processMsg(MsgType msg, Object data) { - if (nextState == StateType.WITHDRAW) - return; - - // hide all but assists : want them when in rotation - activeUnit.hideActiveable(); - map.movesHide(); - map.hexUnselect(activeUnit.getHex()); - if (to != null) - map.pathHide(to); - - if (nextState != StateType.SELECT) { - if (to == null) - to = activeUnit.getHex(); - } - } - - @Override - public StateType abort() - { - hideActivable(); - if (activeUnit.justEntered()) { - map.revertEnter(activeUnit); - return StateType.ABORT; + switch(msg) + { + case OK: + if (state == State.EXIT) { + exit(); + return true; + } + if (hqMode) { + endHqMode(); + return true; + } + break; + case CANCEL: + if (enter || (state == State.PATH) || (state == State.ROTATE)) { + abortMove(); + return true; + } + if (state == State.EXIT) { + abortExit(); + return true; + } + break; } - int n = map.unitsActivatedSize(); - if (n == 0) - return StateType.ABORT; - map.revertMoves(); - return StateType.ANIMATION; - } - @Override - public StateType execute() - { - hideActivable(); - // be sure that the hq is activated - if (selectedUnit.canMove() && (map.unitsActivatedSize() > 0)) - selectedUnit.setMoved(); - - return StateType.DONE; + return false; } @Override public void touch(Hex hex) { + if (state == State.ROTATE) { + if (hex == to) + abortMove(); + else { + Orientation o = Orientation.fromAdj(to, hex); + if (o != Orientation.KEEP) + move(o); + else if (hex == activeUnit.getHex()) + abortMove(); + } + return; + } + if (hex == activeUnit.getHex()) { if (to != null) map.pathHide(to); - to = null; + map.pathsHide(); map.pathsClear(); - ctrl.post(StateType.ROTATE); + map.pathsInit(activeUnit); + collectPaths(hex); return; } @@ -107,21 +129,29 @@ public class StateMove extends StateCommon if (map.unitsActivableContains(unit)) { if (unit != activeUnit) - changeUnit(unit); + selectUnit(unit); } else if ((s == 0) && map.movesContains(hex)) { collectPaths(hex); + } else if ((s > 1) && hex == to) { + s = map.pathsChooseBest(); + if (s == 1) + showRotation(to); } else if (map.pathsContains(hex)) { togglePoint(hex, s); } } - private void hideActivable() + private void selectNextUnit() { - map.unitsActivableHide(); + if (selectedUnit.canMove()) + selectUnit(selectedUnit); + else + selectUnit(map.getFirstActivable()); } - private void changeUnit(Unit unit) + private void selectUnit(Unit unit) { + state = State.SHOW; if (activeUnit != null ) { map.hexUnselect(activeUnit.getHex()); if (activeUnit.canMove()) @@ -130,70 +160,170 @@ public class StateMove extends StateCommon to = null; activeUnit = unit; activeUnit.hideActiveable(); - Hex hex = activeUnit.getHex(); - map.pathsInit(activeUnit, hex); + map.hexSelect(activeUnit.getHex()); + map.pathsClear(); + map.pathsInit(activeUnit); map.movesHide(); map.movesCollect(activeUnit); map.movesShow(); - map.hexSelect(hex); - ctrl.hud.notify(activeUnit.toString(), Position.TOP_CENTER); - checkExit(activeUnit); + ctrl.hud.notify(activeUnit.toString()); } private void collectPaths(Hex hex) { + state = State.PATH; to = hex; map.movesHide(); map.hexMoveShow(to); - int s = map.pathsBuild(to); - if (!checkExit(activeUnit, hex)) - completePath(s); + if (!checkExit(to)) + completePath(); + ctrl.hud.actionButtons.show(Buttons.ABORT.b); } - private void completePath(int s) + private void completePath() { + int s = map.pathsBuild(to); if (cfg.autoPath && (s > 1)) s = map.pathsChooseBest(); map.pathsShow(); if (s == 1) - ctrl.post(StateType.ROTATE); + showRotation(to); } private void togglePoint(Hex hex, int s) { - if (hex == activeUnit.getHex()) { - // - } else if (hex == to) { - // - } else { - map.pathsHide(); - s = map.pathsToggleHex(hex); - map.pathsShow(); - } - - if (s == 1) { - if (!checkExit(activeUnit, hex)) - ctrl.post(StateType.ROTATE); - } + map.pathsHide(); + s = map.pathsToggleHex(hex); + map.pathsShow(); + if (s == 1) + showRotation(to); } - private boolean checkExit(Unit unit) + private boolean checkExit(Hex hex) { - if (unit.justEntered()) + if (enter) return false; - if ((unit.exitZone == null) || !unit.exitZone.contains(unit.getHex())) + if ((activeUnit.exitZone == null) || !activeUnit.exitZone.contains(hex)) return false; - ctrl.post(StateType.WITHDRAW); + + int s = map.pathsBuild(to); + + if (!map.pathsCanExit(activeUnit.exitZone.orientation)) + return false; + + if (map.pathsChooseExit(activeUnit.exitZone.orientation) > 1) + throw new RuntimeException(String.format("pathsChooseExit() -> %d", map.pathsSize())); + map.pathShow(hex); + + state = State.EXIT; + ctrl.hud.askExitBoard(); return true; } - private boolean checkExit(Unit unit, Hex hex) + private void showRotation(Hex hex) { - if ((unit.exitZone == null) || !unit.exitZone.contains(hex)) - return false; - if (!map.pathsCanExit(unit.exitZone.orientation)) - return false; - ctrl.post(StateType.WITHDRAW); - return true; + state = State.ROTATE; + map.movesHide(); + map.pathsHide(); + map.pathShow(hex); + map.hexDirectionsShow(hex); + ctrl.hud.actionButtons.show(Buttons.ABORT.b); + } + + private void move(Orientation o) + { + map.pathsSetOrientation(o); + if (enter) + completeMove(map.getEnterOrder(selectedUnit, hqMode)); + else + completeMove(map.getMoveOrder(selectedUnit, hqMode)); + } + + private void exit() + { + if (map.pathsTo() == null) { + map.pathsBuild(to); + if (map.pathsChooseExit(activeUnit.exitZone.orientation) > 1) + throw new RuntimeException(String.format("pathsChooseExit() -> %d", map.pathsSize())); + } + + completeMove(map.getExitOrder(selectedUnit, hqMode)); + } + + private void completeMove(Order order) + { + map.pathHide(to); + map.hexDirectionsHide(to); + map.hexUnselect(selectedHex); + if (order.cost == 0) + ctrl.postOrder(order, StateType.MOVE); + else + ctrl.postOrder(order); + } + + private void endHqMode() + { + if (selectedUnit.canMove()) + selectedUnit.setMoved(); + clear(); + ctrl.postOrder(Order.END); + } + + private void abortMove() + { + if (enter) { + map.revertEnter(activeUnit); + ctrl.battle.getPlayer().revertUnitEntry(activeUnit); + ctrl.hud.update(); + } + clear(); + if (notFirst) { + // FIXME abortMove : cfg.revertAllMoves + // if (cfg.revertAllMoves) { + // map.revertMoves(); + // ctrl.postTransitionToAborted(); + // } else { + selectUnit(activeUnit); + abortCompleted(); + // } + } + else + ctrl.postActionAborted(); + } + + private void abortExit() + { + map.pathHide(to); + if (to == null) { + state = State.SHOW; + } else { + state = State.PATH; + map.hexMoveShow(to); + completePath(); + } + abortCompleted(); + } + + private void abortCompleted() + { + if (hqMode) + map.unitsActivableShow(); + activeUnit.hideActiveable(); + ctrl.hud.actionButtons.show((notFirst ? Buttons.DONE.b : 0)); + } + + private void clear() + { + state = State.SHOW; + map.movesHide(); + map.pathsHide(); + activeUnit.hideActiveable(); + map.hexUnselect(activeUnit.getHex()); + map.unitsActivableHide(); + if (to != null) { + map.pathHide(to); + map.hexDirectionsHide(to); + } + map.pathsClear(); } } diff --git a/core/src/ch/asynk/rustanddust/game/states/StatePromote.java b/core/src/ch/asynk/rustanddust/game/states/StatePromote.java index bfec208..774b1a9 100644 --- a/core/src/ch/asynk/rustanddust/game/states/StatePromote.java +++ b/core/src/ch/asynk/rustanddust/game/states/StatePromote.java @@ -5,26 +5,6 @@ public class StatePromote extends StateCommon @Override public void enterFrom(StateType prevState) { - ctrl.setAfterAnimationState(StateType.DONE); - ctrl.post(StateType.ANIMATION); - map.promoteUnit(selectedUnit); - } - - @Override - public void leaveFor(StateType nextState) - { - map.hexUnselect(selectedHex); - } - - @Override - public StateType abort() - { - return StateType.ABORT; - } - - @Override - public StateType execute() - { - return StateType.DONE; + ctrl.postOrder(map.getPromoteOrder(selectedUnit)); } } diff --git a/core/src/ch/asynk/rustanddust/game/states/StateReinforcement.java b/core/src/ch/asynk/rustanddust/game/states/StateReinforcement.java index e118924..ffb1f24 100644 --- a/core/src/ch/asynk/rustanddust/game/states/StateReinforcement.java +++ b/core/src/ch/asynk/rustanddust/game/states/StateReinforcement.java @@ -3,6 +3,7 @@ package ch.asynk.rustanddust.game.states; import ch.asynk.rustanddust.game.Hex; import ch.asynk.rustanddust.game.Zone; import ch.asynk.rustanddust.game.Unit; +import ch.asynk.rustanddust.game.Ctrl.MsgType; public class StateReinforcement extends StateCommon { @@ -11,70 +12,53 @@ public class StateReinforcement extends StateCommon @Override public void enterFrom(StateType prevState) { - map.clearAll(); - if (selectedHex != null) - map.hexUnselect(selectedHex); + map.clear(); entryZone = null; + activeUnit = null; selectedHex = null; + selectedUnit = null; ctrl.hud.playerInfo.unitDock.show(); } @Override - public void leaveFor(StateType nextState) + public boolean processMsg(MsgType msg, Object data) { - if (selectedHex != null) - map.hexUnselect(selectedHex); - if (entryZone != null) - entryZone.enable(Hex.AREA, false); - ctrl.hud.playerInfo.unitDock.hide(); - } - - @Override - public StateType abort() - { - return StateType.ABORT; - } + switch(msg) + { + case UNIT_DOCK_SELECT: + showEntryZone((Unit) data); + return true; + } - @Override - public StateType execute() - { - return StateType.DONE; + return false; } @Override public void touch(Hex hex) { - Unit unit = ctrl.hud.playerInfo.unitDock.selectedUnit; - if (hex == null) - changeUnit(unit); - else if ((entryZone != null) && hex.isEmpty() && entryZone.contains(hex)) - unitEnter(activeUnit, hex); - else - ctrl.post(StateType.SELECT); + if ((entryZone != null) && hex.isEmpty() && entryZone.contains(hex)) + unitEnter(selectedUnit, hex); } - private void changeUnit(Unit unit) + private void showEntryZone(Unit unit) { - activeUnit = unit; + selectedUnit = unit; if (entryZone != null) entryZone.enable(Hex.AREA, false); - entryZone = activeUnit.entryZone; + entryZone = unit.entryZone; entryZone.enable(Hex.AREA, true); } private void unitEnter(Unit unit, Hex hex) { - selectedUnit = unit; + activeUnit = unit; selectedHex = hex; - map.hexSelect(selectedHex); + map.enterBoard(unit, hex, entryZone); entryZone.enable(Hex.AREA, false); - if (map.enterBoard(unit, hex, entryZone.allowedMoves)) { - if (unit.getMovementPoints() > 0) - ctrl.post(StateType.MOVE); - else - ctrl.post(StateType.ROTATE); - } else { - ctrl.hud.notify("Can not enter the map at that position"); - } + ctrl.battle.getPlayer().reinforcement.remove(unit); + ctrl.hud.playerInfo.unitDock.hide(); + ctrl.hud.update(); + ctrl.post(StateType.MOVE); + entryZone = null; } } diff --git a/core/src/ch/asynk/rustanddust/game/states/StateReplay.java b/core/src/ch/asynk/rustanddust/game/states/StateReplay.java index ec8295d..22105fb 100644 --- a/core/src/ch/asynk/rustanddust/game/states/StateReplay.java +++ b/core/src/ch/asynk/rustanddust/game/states/StateReplay.java @@ -1,87 +1,111 @@ package ch.asynk.rustanddust.game.states; import ch.asynk.rustanddust.game.Order; +import ch.asynk.rustanddust.game.Ctrl.MsgType; public class StateReplay extends StateCommon { - private Order order; + private Order order = null; @Override public void enterFrom(StateType prevState) { + if (this.order != null) + replayStep(); + Order o = map.stepReplay(); if (o == null) { - StateType nextState = nextState(); + ctrl.postReplayDone(replayDone()); order = null; - ctrl.post(nextState); } else { this.order = o; setup(); - map.replay(order); - ctrl.setAfterAnimationState(StateType.REPLAY); - ctrl.post(StateType.ANIMATION); + ctrl.postOrder(o, StateType.REPLAY); } } private void setup() { - int s = order.activable.size(); + int s = order.activables.size(); - switch (order.type) { + switch (order.type) + { case MOVE: - selectedUnit = ((s > 0) ? order.activable.get(s - 1) : order.unit); + selectedUnit = order.leader; break; case ENGAGE: to = order.engagement.defender.getHex(); - if (order.engagement.success) { - ctrl.battle.getPlayer().engagementWon += 1; - ctrl.battle.getOpponent().casualty(order.engagement.defender); - } else { - ctrl.battle.getPlayer().engagementLost += 1; - } break; + case PROMOTE: default: break; } } - private StateType nextState() + private void replayStep() { - if (map.unitsActivableSize() <= 0) - return StateType.DONE; - - StateType next = null; - - switch (order.type) { + switch (order.type) + { case MOVE: - next = StateType.MOVE; + moveReplayStep(); break; case ENGAGE: - next = StateType.BREAK; - break; + case PROMOTE: default: - next = StateType.DONE; break; } - - return next; } - @Override - public void leaveFor(StateType nextState) + private void moveReplayStep() { + switch(order.move.type) + { + case SET: + ctrl.sendMsg(MsgType.UNIT_DEPLOYED, order.move.pawn); + break; + case REGULAR: + case EXIT: + case ENTER: + break; + } } - @Override - public StateType abort() + private StateType replayDone() { - return StateType.ABORT; + if (order == null) return null; + + boolean more = (order.activables.size() > 0); + StateType nextState = null; + switch (order.type) + { + case MOVE: + nextState = moveReplayDone(more); + break; + case ENGAGE: + if (more) nextState = StateType.ENGAGE; + break; + case PROMOTE: + default: + break; + } + return nextState; } - @Override - public StateType execute() + private StateType moveReplayDone(boolean more) { - // called at the end of animation DONE -> burn 1 AP - return ((order.cost == 0) ? StateType.REPLAY : StateType.DONE); + StateType nextState = null; + switch(order.move.type) + { + case REGULAR: + case EXIT: + if (more) nextState = StateType.MOVE; + break; + case SET: + nextState = StateType.DEPLOYMENT; + break; + case ENTER: + break; + } + return nextState; } } diff --git a/core/src/ch/asynk/rustanddust/game/states/StateRotate.java b/core/src/ch/asynk/rustanddust/game/states/StateRotate.java deleted file mode 100644 index 4aa9608..0000000 --- a/core/src/ch/asynk/rustanddust/game/states/StateRotate.java +++ /dev/null @@ -1,103 +0,0 @@ -package ch.asynk.rustanddust.game.states; - -import ch.asynk.rustanddust.engine.Orientation; -import ch.asynk.rustanddust.game.Hex; -import ch.asynk.rustanddust.RustAndDust; - -public class StateRotate extends StateCommon -{ - private boolean rotateOnly; - private boolean rotationSet; - - @Override - public void enterFrom(StateType prevState) - { - if (!cfg.showMoveAssists) map.unitsActivableHide(); - - if (activeUnit == null) - activeUnit = selectedUnit; - if (to == null) - to = activeUnit.getHex(); - - if (!map.pathsIsSet()) { - map.pathsInit(activeUnit); - map.pathsBuild(to); - } - - if (map.pathsSize() > 1) - RustAndDust.debug("ERROR: Rotate pathsSize() == " + map.pathsSize()); - - rotateOnly = (to == activeUnit.getHex()); - - if (!rotateOnly) - map.pathShow(to); - map.hexSelect(activeUnit.getHex()); - map.hexDirectionsShow(to); - - rotationSet = false; - } - - @Override - public void leaveFor(StateType nextState) - { - map.hexUnselect(activeUnit.getHex()); - map.pathHide(to); - map.hexDirectionsHide(to); - map.pathsClear(); - to = null; - } - - @Override - public StateType abort() - { - StateType nextState = StateType.ABORT; - ctrl.hud.actionButtons.hide(); - if (activeUnit.justEntered()) { - map.revertEnter(activeUnit); - nextState = StateType.ABORT; - } else if (map.unitsActivatedSize() == 0) { - map.unitsActivableHide(); - } else { - nextState = StateType.MOVE; - } - return nextState; - } - - @Override - public StateType execute() - { - if (!rotationSet) - return StateType.DONE; - - StateType whenDone = StateType.DONE; - - if (map.moveUnit(activeUnit)) { - if (map.unitsActivableSize() > 0) - whenDone = StateType.MOVE; - } else - RustAndDust.debug("rotate failed"); - - ctrl.setAfterAnimationState(whenDone); - return StateType.ANIMATION; - } - - @Override - public void touch(Hex hex) - { - if (rotationSet) return; - - Orientation o = Orientation.fromAdj(to, hex); - if (o == Orientation.KEEP) { - ctrl.post(StateType.ABORT); - return; - } - - if (!activeUnit.justEntered() && rotateOnly && (o == activeUnit.getOrientation())) - return; - - map.pathsSetOrientation(o); - rotationSet = true; - execute(); - ctrl.post(StateType.ANIMATION); - } -} diff --git a/core/src/ch/asynk/rustanddust/game/states/StateSelect.java b/core/src/ch/asynk/rustanddust/game/states/StateSelect.java index 518258f..f6c42c3 100644 --- a/core/src/ch/asynk/rustanddust/game/states/StateSelect.java +++ b/core/src/ch/asynk/rustanddust/game/states/StateSelect.java @@ -1,120 +1,131 @@ package ch.asynk.rustanddust.game.states; +import ch.asynk.rustanddust.RustAndDust; import ch.asynk.rustanddust.ui.Position; import ch.asynk.rustanddust.game.Hex; import ch.asynk.rustanddust.game.Unit; +import ch.asynk.rustanddust.game.Ctrl.MsgType; import ch.asynk.rustanddust.game.hud.ActionButtons.Buttons; -import ch.asynk.rustanddust.RustAndDust; public class StateSelect extends StateCommon { - @Override - public void enterFrom(StateType prevState) - { - to = null; - selectedHex = null; - selectedUnit = null; - activeUnit = null; - map.clearAll(); - ctrl.hud.actionButtons.hide(); - } + private boolean isEnemy; @Override - public void leaveFor(StateType nextState) + public void enterFrom(StateType prevState) { - hidePossibilities(); + clear(); } @Override - public StateType abort() + public boolean processMsg(MsgType msg, Object data) { - if (selectedHex != null) - map.hexUnselect(selectedHex); - hidePossibilities(); - map.clearAll(); - return StateType.ABORT; - } + switch(msg) + { + case OK: + ctrl.postTurnDone(); + return true; + case PROMOTE: + changeTo(StateType.PROMOTE); + return true; + } - @Override - public StateType execute() - { - return StateType.DONE; + return false; } @Override public void touch(Hex hex) { - if (!isEnemy) { + Unit unit = hex.getUnit(); + + if (!isEnemy && (selectedUnit != null)) { if (map.movesContains(hex)) { // quick move to = hex; - ctrl.post(StateType.MOVE); + changeTo(StateType.MOVE); return; } - if (map.unitsTargetContains(hex.getUnit())) { + if (map.unitsTargetContains(unit)) { // quick fire to = hex; - ctrl.post(StateType.ENGAGE); + activeUnit = unit; + changeTo(StateType.ENGAGE); return; } } - if (selectedHex != null) - map.hexUnselect(selectedHex); + hide(); - hidePossibilities(); - if (hex.isOffMap()) { - selectedUnit = null; - return; - } - - Unit unit = hex.getUnit(); - - if (unit == null) { - isEnemy = false; - ctrl.hud.actionButtons.hide(); - map.clearAll(); + if ((unit == null) || hex.isOffMap()) { selectedUnit = null; return; } isEnemy = ctrl.battle.getPlayer().isEnemy(unit); - if (!isEnemy && (unit == selectedUnit) && unit.canMove()) { + + if (!isEnemy && (selectedUnit == unit) && unit.canMove()) { if (unit.isHq() && (map.unitsActivableSize() > 1)) { - ctrl.hud.notify("HQ activation"); - select(hex, unit, isEnemy); - ctrl.post(StateType.MOVE); - } else { - // quick rotate + ctrl.hud.notify("HQ activation", Position.MIDDLE_CENTER); + to = null; + } else to = hex; - ctrl.post(StateType.ROTATE); - } + changeTo(StateType.MOVE); } else { - select(hex, unit, isEnemy); - ctrl.hud.notify(selectedUnit.toString(), Position.TOP_CENTER); + select(hex, unit); + ctrl.hud.notify(selectedUnit.toString()); } } - private void select(Hex hex, Unit unit, boolean isEnemy) + private void select(Hex hex, Unit unit) { selectedHex = hex; selectedUnit = unit; + RustAndDust.debug(String.format(" %s - %s", selectedUnit, selectedHex)); + + map.hexSelect(selectedHex); if (isEnemy && !cfg.showEnemyPossibilities) return; - int moves = map.movesCollect(selectedUnit); - int targets = map.collectTargets(selectedUnit, (isEnemy ? ctrl.battle.getPlayer() : ctrl.battle.getOpponent()).units); - - if (moves > 0) + if(map.movesCollect(selectedUnit) > 0) { map.collectMoveable(selectedUnit); + if (cfg.showMoves) map.movesShow(); + if (cfg.showMoveAssists) map.unitsActivableShow(); + unit.hideActiveable(); + } - if ((moves > 0) || (targets > 0)) { - map.hexSelect(selectedHex); - showPossibilities(selectedUnit); + if (map.collectTargets(selectedUnit, (isEnemy ? ctrl.battle.getPlayer() : ctrl.battle.getOpponent()).units) > 0) { + if (cfg.showTargets) map.unitsTargetShow(); + unit.hideActiveable(); } ctrl.hud.actionButtons.show((ctrl.battle.getPlayer().canPromote(selectedUnit)) ? Buttons.PROMOTE.b : 0 ); - RustAndDust.debug("Select", selectedHex.toString() + " " + selectedUnit + (isEnemy ? " enemy " : " friend ")); + } + + private void changeTo(StateType nextState) + { + hide(); + ctrl.post(nextState); + } + + private void hide() + { + if (selectedHex != null) + map.hexUnselect(selectedHex); + map.movesHide(); + map.unitsTargetHide(); + map.unitsActivableHide(); + ctrl.hud.actionButtons.hide(); + } + + private void clear() + { + hide(); + map.clear(); + to = null; + isEnemy = false; + selectedHex = null; + selectedUnit = null; + activeUnit = null; } } diff --git a/core/src/ch/asynk/rustanddust/game/states/StateWithdraw.java b/core/src/ch/asynk/rustanddust/game/states/StateWithdraw.java deleted file mode 100644 index f21fbed..0000000 --- a/core/src/ch/asynk/rustanddust/game/states/StateWithdraw.java +++ /dev/null @@ -1,64 +0,0 @@ -package ch.asynk.rustanddust.game.states; - -import ch.asynk.rustanddust.game.Hex; -import ch.asynk.rustanddust.game.Unit; -import ch.asynk.rustanddust.RustAndDust; - -public class StateWithdraw extends StateCommon -{ - @Override - public void enterFrom(StateType prevState) - { - ctrl.hud.askExitBoard(); - } - - @Override - public void leaveFor(StateType nextState) - { - } - - @Override - public StateType abort() - { - return StateType.MOVE; - } - - @Override - public StateType execute() - { - if (activeUnit == null) - activeUnit = selectedUnit; - - ctrl.setAfterAnimationState(withdraw(activeUnit)); - return StateType.ANIMATION; - } - - private StateType withdraw(Unit unit) - { - Hex hex = unit.getHex(); - - // rotation - if (map.pathsTo() == null) - map.pathsBuild(hex); - - Hex exitHex = (Hex) map.pathsTo(); - if (!unit.exitZone.contains(exitHex)) - throw new RuntimeException(String.format("%s not in exitZone", exitHex)); - - if (map.pathsChooseExit(unit.exitZone.orientation) > 1) - RustAndDust.debug("ERROR: Withdraw pathsSize() == " + map.pathsSize()); - - unit.hideActiveable(); - if (to != null) - map.pathHide(to); - map.movesHide(); - map.hexUnselect(hex); - - if (map.exitBoard(unit)) { - if (map.unitsActivableSize() > 0) - return StateType.MOVE; - } else - RustAndDust.debug("exit failed"); - return StateType.DONE; - } -} diff --git a/core/src/ch/asynk/rustanddust/menu/PlayMenu.java b/core/src/ch/asynk/rustanddust/menu/PlayMenu.java index 78fbe85..3fd0d4e 100644 --- a/core/src/ch/asynk/rustanddust/menu/PlayMenu.java +++ b/core/src/ch/asynk/rustanddust/menu/PlayMenu.java @@ -142,11 +142,11 @@ public class PlayMenu extends Patch implements MenuCtrl.Panel return MenuCtrl.MenuType.OKKO; } else if (resumeBtn.hit(x, y)) { game.playType(); - return setConfig(Config.LoadMode.LOAD); + return setConfig(Config.LoadMode.RESUME); } else if (replayBtn.hit(x, y)) { game.playType(); - // TODO chose between : REPLAY_LAST / REPLAY_ALL - return setConfig(Config.LoadMode.REPLAY_LAST); + // TODO chose between : REPLAY_CURRENT / REPLAY_ALL + return setConfig(Config.LoadMode.REPLAY_CURRENT); } else if (list.hit(x, y)) { if (i != getList().getIdx()) game.playType(); diff --git a/core/src/ch/asynk/rustanddust/screens/GameScreen.java b/core/src/ch/asynk/rustanddust/screens/GameScreen.java index e2aa8a2..b3d2457 100644 --- a/core/src/ch/asynk/rustanddust/screens/GameScreen.java +++ b/core/src/ch/asynk/rustanddust/screens/GameScreen.java @@ -149,7 +149,7 @@ public class GameScreen implements Screen blocked = false; } - ctrl.processEvent(); + ctrl.processEvent(delta); ctrl.hud.animate(delta); ctrl.map.animate(delta); diff --git a/core/src/ch/asynk/rustanddust/util/DB.java b/core/src/ch/asynk/rustanddust/util/DB.java index 994e5d3..c5c68c3 100644 --- a/core/src/ch/asynk/rustanddust/util/DB.java +++ b/core/src/ch/asynk/rustanddust/util/DB.java @@ -42,7 +42,8 @@ public class DB + " ,mode integer not null, battle integer not null, opponent integer not null" + " ,turn integer not null, currentPlayer integer default null" + " ,ts datetime default current_timestamp, synched integer default 0" - + " ,state text default null, stateH text default null" + + " ,players text default null, playersH text default null" + + " ,map text default null, mapH text default null" + " ,orders text default null, ordersH text default null" + " ,foreign key (battle) references battles(_id)" + " ,foreign key (opponent) references players(_id)" @@ -53,7 +54,8 @@ public class DB private static final String TBL_TURNS_CRT = "create table if not exists" + " turns ( _id integer primary key autoincrement" + " ,game integer not null, turn integer not null, currentPlayer integer not null" - + " ,state text default null, stateH text default null" + + " ,players text default null, playersH text default null" + + " ,map text default null, mapH text default null" + " ,orders text default null, ordersH text default null" + " ,foreign key (game) references games(_id)" + " ,foreign key (currentPlayer) references players(_id)" @@ -126,6 +128,7 @@ public class DB private boolean checkDigest(String what, int id, String payload, String digest) { + if (payload == null) return true; if (digest.equals(getDigest(payload))) return true; RustAndDust.error(String.format("corrupted %s(%d)", what, id)); @@ -258,15 +261,18 @@ public class DB return getGameId(opponent, battle, mode); } - private static final String STORE_GAME_STATE = "update games set ts=current_timestamp, turn=%d, currentPlayer=%d, state='%s', stateH='%s', synched=1 where _id=%d;"; + private static final String STORE_GAME_STATE = "update games set ts=current_timestamp, turn=%d, currentPlayer=%d," + + " players='%s', playersH='%s', map='%s', mapH='%s', synched=1 where _id=%d;"; - public boolean storeGameState(int game, int turn, int player, String state) + public boolean storeGameState(int game, int turn, int player, String players, String map) { RustAndDust.debug("storeGameState"); try { - String hash = getDigest(state); - if (hash == null) return false; - exec(String.format(STORE_GAME_STATE, turn, player, state, hash, game)); + String playersH = getDigest(players); + if (playersH == null) return false; + String mapH = getDigest(map); + if (mapH == null) return false; + exec(String.format(STORE_GAME_STATE, turn, player, players, playersH, map, mapH, game)); } catch (SQLiteGdxException e) { RustAndDust.error("storeGameState"); return false; @@ -280,9 +286,9 @@ public class DB { RustAndDust.debug("storeGameOrders"); try { - String hash = getDigest(orders); - if (hash == null) return false; - exec(String.format(STORE_GAME_ORDERS, turn, player, orders, hash, game)); + String ordersH = getDigest(orders); + if (ordersH == null) return false; + exec(String.format(STORE_GAME_ORDERS, turn, player, orders, ordersH, game)); } catch (SQLiteGdxException e) { RustAndDust.error("storeGameOrders"); return false; @@ -290,15 +296,28 @@ public class DB return true; } - private static final String COPY_TURN = "insert into turns(game, turn, currentPlayer, state, stateH, orders, ordersH)" - + " select _id, turn, currentPlayer, state, stateH, orders, ordersH from games where _id=%d;"; + private static final String COPY_TURN = "insert into turns(game, turn, currentPlayer, players, playersH, map, mapH, orders, ordersH)" + + " select _id, turn, currentPlayer, players, playersH, map, mapH, orders, ordersH from games where _id=%d;"; - public boolean storeLastTurn(int game) + public boolean storeCurrentTurn(int game) { + RustAndDust.debug("storeCurrentTurn"); try { exec(String.format(COPY_TURN, game)); } catch (SQLiteGdxException e) { - RustAndDust.error("storeLastTurn"); + RustAndDust.error("storeCurrentTurn"); + return false; + } + return true; + } + + public boolean clearGameOrders(int game) + { + RustAndDust.debug("clearGameOrders"); + try { + exec(String.format("update games set orders=null, ordersH=null, synched=1 where _id=%d;", game)); + } catch (SQLiteGdxException e) { + RustAndDust.error("clearGameOrders"); return false; } return true; @@ -306,7 +325,7 @@ public class DB private static final String LOAD_BASE = "select g._id, g.mode, g.battle, g.opponent, g.turn, g.currentPlayer, g.ts, g.synched"; - private static final String LOAD_GAMES = LOAD_BASE + ", null, null, null, null, p.name, b.name" + private static final String LOAD_GAMES = LOAD_BASE + ", null, null, null, null, null, null, p.name, b.name" + " from games g inner join players p on (p._id=g.opponent) inner join battles b on (b._id=g.battle);"; public void loadGames() @@ -325,46 +344,40 @@ public class DB } catch (SQLiteGdxException e) { RustAndDust.error("loadGames"); } } - private static final String LOAD_GAME = LOAD_BASE + ", g.state, g.stateH, g.orders, g.ordersH, null, null from games g where g._id=%d;"; + private static final String LOAD_GAME = LOAD_BASE + ", g.players, g.playersH, g.map, g.mapH, g.orders, g.ordersH, null, null from games g where g._id=%d;"; public GameRecord loadGame(int game) { RustAndDust.debug("loadGame"); - GameRecord r = null; - try { - DatabaseCursor cursor = query(String.format(LOAD_GAME, game)); - if (cursor.getCount() > 0) { - cursor.next(); - r = gameRecordFrom(cursor); - if (!checkDigest("GameState", game, r.state, r.stateH)) - r = null; - else if(!checkDigest("GameOrders", game, r.orders, r.ordersH)) - r = null; - } - } catch (SQLiteGdxException e) { RustAndDust.error("loadGame"); } - if (r == null) - deleteGame(game); - return r; + return loadGame(game, LOAD_GAME, "loadGAME"); } - private static final String LOAD_LAST_TURN = "select g._id, g.mode, g.battle, g.opponent, t.turn, t.currentPlayer, g.ts, g.synched" - + ", t.state, t.stateH, g.orders, g.ordersH, null, null from games g inner join turns t on (g._id = t.game) where g._id=%d order by t.turn desc limit 1;"; + private static final String LOAD_LAST_TURN = "select g._id, g.mode, g.battle, g.opponent, g.turn, g.currentPlayer, g.ts, g.synched" + + ", t.players, t.playersH, t.map, t.mapH, g.orders, g.ordersH, null, null" + +" from games g inner join turns t on (g._id = t.game) where g._id=%d order by t.turn desc limit 1;"; public GameRecord loadLastTurn(int game) { RustAndDust.debug("loadLastTurn"); + return loadGame(game, LOAD_LAST_TURN, "loadLastTurn"); + } + + private GameRecord loadGame(int game, String sql, String errMsg) + { GameRecord r = null; try { - DatabaseCursor cursor = query(String.format(LOAD_LAST_TURN, game)); + DatabaseCursor cursor = query(String.format(sql, game)); if (cursor.getCount() > 0) { cursor.next(); r = gameRecordFrom(cursor); - if (!checkDigest("GameState", game, r.state, r.stateH)) + if (!checkDigest("GameState", game, r.players, r.playersH)) + r = null; + if (!checkDigest("GameState", game, r.map, r.mapH)) r = null; else if(!checkDigest("GameOrders", game, r.orders, r.ordersH)) r = null; } - } catch (SQLiteGdxException e) { RustAndDust.error("loadLastTurn"); } + } catch (SQLiteGdxException e) { RustAndDust.error(errMsg); } if (r == null) deleteGame(game); return r; @@ -404,13 +417,15 @@ public class DB RustAndDust.error(String.format("can't parse", cursor.getString(6))); } r.synched = ((cursor.getInt(7) == 1) ? true : false); - r.state = cursor.getString(8); - r.stateH = cursor.getString(9); - r.orders = cursor.getString(10); - r.ordersH = cursor.getString(11); + r.players = cursor.getString(8); + r.playersH = cursor.getString(9); + r.map = cursor.getString(10); + r.mapH = cursor.getString(11); + r.orders = cursor.getString(12); + r.ordersH = cursor.getString(13); // - r.oName = cursor.getString(12); - r.bName = cursor.getString(13); + r.oName = cursor.getString(14); + r.bName = cursor.getString(15); } catch (Exception e) { r.dispose(); RustAndDust.error("GameRecord from cursor"); } diff --git a/core/src/ch/asynk/rustanddust/util/GameRecord.java b/core/src/ch/asynk/rustanddust/util/GameRecord.java index 5693a3e..4a540ba 100644 --- a/core/src/ch/asynk/rustanddust/util/GameRecord.java +++ b/core/src/ch/asynk/rustanddust/util/GameRecord.java @@ -21,8 +21,10 @@ public class GameRecord implements List.ListElement, Disposable, Pool.Poolable public int currentPlayer; public Date ts; public boolean synched; - public String state; - public String stateH; + public String players; + public String playersH; + public String map; + public String mapH; public String orders; public String ordersH; // diff --git a/core/src/ch/asynk/rustanddust/util/Marshal.java b/core/src/ch/asynk/rustanddust/util/Marshal.java index 513c87b..f805fa1 100644 --- a/core/src/ch/asynk/rustanddust/util/Marshal.java +++ b/core/src/ch/asynk/rustanddust/util/Marshal.java @@ -7,9 +7,9 @@ public interface Marshal { public enum Mode { - FULL, - STATE, - ORDERS + PLAYERS, + MAP, + ORDERS, } public void unload(Mode mode, Json json); |