move addOrder to an action and make state mutation immutable

src/logic/ai/aiCalculator.ts

@@ -9,7 +9,7 @@ import AiPlayer from './aiPlayer';
 import RecruitingRules from '../board/gameRules/recruitingRules';
 import {OrderToken} from '../orderToken/orderToken';
 import {gameStore, GameStoreState} from '../board/gameState/reducer';
-import {moveUnits} from '../board/gameState/actions';
+import {moveUnits, placeOrder} from '../board/gameState/actions';
 export default class AiCalculator {
 
     public executeOrder(aiPlayer: AiPlayer) {
@@ -65,7 +65,7 @@ export default class AiCalculator {
         });
 
         for (let bestMove of bestMovesForAllPlaceableToken) {
-            TokenPlacementRules.addOrderToken(new OrderToken(aiPlayer.house, bestMove.orderTokenType), bestMove.sourceArea.key);
+            gameStore.dispatch(placeOrder(bestMove.sourceArea.key, new OrderToken(aiPlayer.house, bestMove.orderTokenType) ));
         }
     }
 

src/logic/board/gameRules/AreaRules.ts

@@ -1,6 +1,7 @@
 import {Area} from '../area';
 import {TSMap} from 'typescript-map';
 import {AreaKey} from '../areaKey';
+import {OrderToken} from '../../orderToken/orderToken';
 export default class AreaRules {
 
     public static isConnectedArea(source: Area, target: Area): boolean {
@@ -19,4 +20,16 @@ export default class AreaRules {
         });
         return newAreasMap;
     }
+
+    public static addOrderToken(areas: Area[], ordertoken: OrderToken, areaKey: AreaKey): TSMap<AreaKey, Area> {
+        const newAreaMap = new TSMap<AreaKey, Area>();
+        areas.forEach(area => {
+            const newArea = area.copy();
+            if (newArea.key === areaKey) {
+                newArea.orderToken = ordertoken;
+            }
+            newAreaMap.set(newArea.key, newArea);
+        });
+        return newAreaMap;
+    }
 }

src/logic/board/gameRules/tokenPlacementRules.ts

@@ -7,6 +7,7 @@ import {AreaKey} from '../areaKey';
 import {OrderTokenType} from '../../orderToken/orderTokenType';
 import {gameStore, GameStoreState} from '../gameState/reducer';
 import {nextPlayer} from '../gameState/actions';
+import {TSMap} from 'typescript-map';
 export default class TokenPlacementRules {
 
     public static RAID_ORDER_TOKENS = [OrderTokenType.raid_0, OrderTokenType.raid_1, OrderTokenType.raid_special];
@@ -34,12 +35,6 @@ export default class TokenPlacementRules {
         });
     }
 
-    // TODO use action
-    public static addOrderToken(ordertoken: OrderToken, areaKey: AreaKey) {
-        const area = GameRules.getAreaByKey(areaKey);
-        area.orderToken = ordertoken;
-    }
-
     public static executeRaidOrder(source: AreaKey, target: AreaKey) {
         let sourceArea = GameRules.getAreaByKey(source);
         sourceArea.orderToken = null;

src/logic/board/gameState/actions.ts

@@ -5,12 +5,15 @@ import {Area} from '../area';
 import {UnitType} from '../../units/unitType';
 import Unit from '../../units/units';
 import {AreaKey} from '../areaKey';
+import {OrderToken} from '../../orderToken/orderToken';
+import Order = jasmine.Order;
 export enum TypeKeys {
     NEXT_PHASE = 'NEXT_PHASE',
     INCREASE_WILDLINGCOUNT = 'INCREASE_WILDLINGCOUNT',
     START_RECRUITING = 'START_RECRUITING',
     RECRUIT_UNITS = 'RECRUIT_UNITS',
     MOVE_UNITS = 'MOVE_UNITS',
+    PLACE_ORDER = 'PLACE_ORDER',
     RESET_GAME = 'RESET_GAME',
     LOAD_GAME = 'LOAD_GAME',
     NEW_GAME = 'NEW_GAME',
@@ -21,6 +24,11 @@ export enum TypeKeys {
     OTHER_ACTION = '__any_other_action_type__'
 }
 
+export interface  PlaceOrderAction {
+    type: TypeKeys.PLACE_ORDER;
+    areaKey: AreaKey;
+    orderToken: OrderToken;
+}
 export interface  RecruitUnitsAction {
     type: TypeKeys.RECRUIT_UNITS;
     area: Area;
@@ -86,12 +94,19 @@ export type ActionTypes =
     | StartRecruitingAction
     | RecruitUnitsAction
     | MoveUnitsAction
+    | PlaceOrderAction
     | IncreaseWildlingCountAction
     | RestrictOrderTokenTypesAction
     | UpdateSupplyAction
     | OtherAction
     | NextPlayerAction;
 
+
+export const placeOrder = (areaKey: AreaKey, orderToken: OrderToken): PlaceOrderAction => ({
+    type: TypeKeys.PLACE_ORDER,
+    areaKey,
+    orderToken
+});
 export const startRecruiting = (): StartRecruitingAction => ({
     type: TypeKeys.START_RECRUITING,
 });

src/logic/board/gameState/reducer.ts

@@ -17,8 +17,8 @@ import {OrderTokenType} from '../../orderToken/orderTokenType';
 import {Area} from '../area';
 import RecruitingRules from '../gameRules/recruitingRules';
 import {AreaKey} from '../areaKey';
-import AreaRules from '../gameRules/AreaRules';
 import MovementRules from '../gameRules/movementRules';
+import AreaRules from '../gameRules/AreaRules';
 
 class GameStoreState {
     areas?: TSMap<AreaKey, Area>;
@@ -157,6 +157,12 @@ const gameStateReducer = (state: GameStoreState = initialState, action: ActionTy
                 newState = {...state, gamePhase: state.gamePhase + 1};
             }
             break;
+        case TypeKeys.PLACE_ORDER:
+            newState = {
+                ...state,
+                areas: AreaRules.addOrderToken(state.areas.values(), action.orderToken, action.areaKey)
+            };
+            break;
         case TypeKeys.NEXT_PLAYER:
             newState = {...state, currentHouse: GamePhaseService.nextHouse(state)};
             break;

src/ui/orderToken/orderTokenMenuRenderer.ts

@@ -6,6 +6,7 @@ import DragAndDropSupport from '../../utils/dragAndDropSupport';
 import AssetLoader from '../../utils/assetLoader';
 import TokenPlacementRules from '../../logic/board/gameRules/tokenPlacementRules';
 import {gameStore} from '../../logic/board/gameState/reducer';
+import {placeOrder} from '../../logic/board/gameState/actions';
 export class OrderTokenMenuRenderer {
 
     private static placableOrderTokens: Phaser.Group;
@@ -51,7 +52,7 @@ export class OrderTokenMenuRenderer {
             let relativeY = area.y - currentSprite.game.camera.y;
             let boundsB = new Phaser.Rectangle(relativeX * scale.x, relativeY * scale.y, area.width * scale.x, area.height * scale.y);
             if (Phaser.Rectangle.intersects(boundsA, boundsB) && TokenPlacementRules.isAllowedToPlaceOrderToken(House.stark, area.name)) {
-                TokenPlacementRules.addOrderToken(new OrderToken(gameStore.getState().currentHouse, currentSprite.frame), area.name);
+                gameStore.dispatch(placeOrder(area.name, new OrderToken(gameStore.getState().currentHouse, currentSprite.frame)));
             }
         });
     }

test/logic/board/gameRules/areaRules.spec.ts

@@ -2,9 +2,13 @@ import AreaRules from '../../../../src/logic/board/gameRules/AreaRules';
 import AreaBuilder from '../../../areaBuilder';
 import {AreaKey} from '../../../../src/logic/board/areaKey';
 import {gameStore} from '../../../../src/logic/board/gameState/reducer';
-import {loadGame} from '../../../../src/logic/board/gameState/actions';
+import {loadGame, placeOrder} from '../../../../src/logic/board/gameState/actions';
 import {Area} from '../../../../src/logic/board/area';
 import {TSMap} from 'typescript-map';
+import {OrderToken} from '../../../../src/logic/orderToken/orderToken';
+import {OrderTokenType} from '../../../../src/logic/orderToken/orderTokenType';
+import {House} from '../../../../src/logic/board/house';
+import {UnitType} from '../../../../src/logic/units/unitType';
 
 describe('AreaRules', () => {
 
@@ -45,4 +49,22 @@ describe('AreaRules', () => {
 
     });
 
+    it('should add OrderToken', () => {
+
+        const orderToken: OrderToken = new OrderToken(House.stark, OrderTokenType.march_minusOne);
+        const winterfell = new AreaBuilder(AreaKey.Winterfell)
+            .withHouse(House.lannister)
+            .withUnits([UnitType.Footman])
+            .build();
+        const areas = new TSMap<AreaKey, Area>();
+        areas.set(AreaKey.Winterfell, winterfell);
+        let gameStoreState = {areas: areas};
+        gameStore.dispatch(loadGame(gameStoreState));
+        gameStore.dispatch(placeOrder(winterfell.key, orderToken));
+        const actual = gameStore.getState();
+        expect(actual.areas).not.toBe(areas);
+        expect(gameStore.getState().areas.get(AreaKey.Winterfell).orderToken).toBe(orderToken);
+
+    });
+
 });

test/logic/board/gameRules/recruitingRules.spec.ts

@@ -16,7 +16,7 @@ describe('RecruitingRules', () => {
             // when
             const actual = RecruitingRules.addUnitsToArea(area, unitTypes);
 
-            //then
+            // then
             expect(actual).not.toBe(area);
             expect(actual.units.length).toBe(2);
         });
@@ -28,7 +28,7 @@ describe('RecruitingRules', () => {
             // when
             const actual = RecruitingRules.addUnitsToArea(area, unitTypes);
 
-            //then
+            // then
             expect(actual).not.toBe(area);
             expect(actual.units.length).toBe(3);
         });

test/logic/board/gameRules/tokenPlacementRules.spec.ts

@@ -65,22 +65,6 @@ describe('TokenPlacementRules', () => {
         expect(actual).toBe(false);
     });
 
-    it('should add OrderToken', () => {
-
-        const orderToken: OrderToken = new OrderToken(House.stark, OrderTokenType.march_minusOne);
-        const winterfell = new AreaBuilder(AreaKey.Winterfell)
-            .withHouse(House.lannister)
-            .withUnits([UnitType.Footman])
-            .build();
-        const areas = new TSMap<AreaKey, Area>();
-        areas.set(AreaKey.Winterfell, winterfell);
-        let gameStoreState = {players: [playerStark, playerLannister], areas: areas};
-        gameStore.dispatch(loadGame(gameStoreState));
-        TokenPlacementRules.addOrderToken(orderToken, AreaKey.Winterfell);
-        expect(winterfell.orderToken).toBe(orderToken);
-
-    });
-
     describe('skipOrder', () => {
         it('should remove orderToken and switch to Next Player', () => {
             const area = new AreaBuilder(AreaKey.Winterfell).withOrderToken(OrderTokenType.consolidatePower_0).withHouse(House.stark).build();