Merge pull request #302 from Ido-Barnea/feature/add-secret-rules

Feature/add secret rules

Author: Ido-Barnea

chess-but-better/src/controller/events/handlers/PieceKilledEventHandler.ts

@@ -38,13 +38,14 @@ export class PieceKilledEventHandler extends BaseEventHandler {
     }
 
     handle(context: Record<string, any>): void {
-        const attackedPiece: BasePiece = context['piece'];
+        const killer: BasePiece | undefined = context['killer'];
+        const victim: BasePiece = context['victim'];
         const causeOfDeath: CauseOfDeath = context['causeOfDeath'];
 
-        const nextBoard = this.determinePieceNextBoard(attackedPiece, causeOfDeath);
-        attackedPiece.position.board = nextBoard;
+        const nextBoard = this.determinePieceNextBoard(victim, causeOfDeath);
+        victim.position.board = nextBoard;
 
-        this.eventEmitter.emit(EventType.PIECE_SPAWNED, {piece: attackedPiece});
-        this.eventEmitter.emit(EventType.AFTER_PIECE_KILLED);
+        this.eventEmitter.emit(EventType.PIECE_SPAWNED, {piece: victim});
+        this.eventEmitter.emit(EventType.AFTER_PIECE_KILLED, {killer, victim});
     }
 }

chess-but-better/src/controller/events/handlers/PieceMovedEventHandler.ts

@@ -40,7 +40,11 @@ export class PieceMovedEventHandler extends BaseEventHandler {
             piece.stats.kills += 1;
             attackedPiece.position = this.boardService.copyPosition(attackedPiece.position); // Trigger component render
 
-            this.eventEmitter.emit(EventType.PIECE_KILLED, {piece: attackedPiece, causeOfDeath: CauseOfDeath.PLAYER});
+            this.eventEmitter.emit(EventType.PIECE_KILLED, {
+                killer: piece,
+                victim: attackedPiece,
+                causeOfDeath: CauseOfDeath.PLAYER,
+            });
         }
     }
 

chess-but-better/src/controller/events/handlers/end-of-move-handlers/TurnCounterHandler.ts

@@ -2,7 +2,7 @@ import { ITurnCounter } from "../../../game-state/counters/turn-counter/abstract
 import { IEventHandler } from "../../abstract/IEventHandler";
 
 export class TurnCounterHandler implements IEventHandler {
-  turnCounter: ITurnCounter;
+  private turnCounter: ITurnCounter;
 
   constructor(turnCounter: ITurnCounter) {
     this.turnCounter = turnCounter;

chess-but-better/src/controller/events/handlers/end-of-move-handlers/secret-rules/Beggers.ts

@@ -0,0 +1,37 @@
+import { SecretRuleHandler } from "./abstract/SecretRuleHandler";
+import { IPlayersStorage } from "../../../../storages/players-storage/abstract/IPlayersStorage";
+import { Team } from "../../../../../model/player/team/Team";
+
+export class BeggersHandler extends SecretRuleHandler {
+  private playersStorage: IPlayersStorage;
+
+  constructor(playersStorage: IPlayersStorage) {
+    super('Beggers');
+    this.playersStorage = playersStorage;
+  }
+
+  getTeamsInDebt = (): Array<Team> => {
+    const teamsInDebt = new Set<Team>();
+  
+    this.playersStorage.getPlayers().forEach((player) => {
+      if (player.team.gold < 0) {
+        teamsInDebt.add(player.team);
+      }
+    });
+  
+    return Array.from(teamsInDebt);
+  };
+  
+
+  condition(): boolean {
+    const teamsInDebt = this.getTeamsInDebt();
+    return teamsInDebt.length > 0;
+  }
+
+  outcome(): void {
+    const teamsInDebt = this.getTeamsInDebt();
+    teamsInDebt.forEach((team) => {
+      team.experience -= 1;
+    });
+  }
+}

chess-but-better/src/controller/events/handlers/end-of-move-handlers/secret-rules/FirstBloodHandler.ts

@@ -0,0 +1,23 @@
+import { BasePiece } from "../../../../../model/piece/abstract/BasePiece";
+import { SecretRuleHandler } from "./abstract/SecretRuleHandler";
+
+export class FirstBloodHandler extends SecretRuleHandler {
+  private wasClaimed: boolean;
+
+  constructor() {
+    super('First Blood');
+    this.wasClaimed = false;
+  }
+
+  condition(context: Record<string, any>): boolean {
+    const killer: BasePiece = context['killer'];
+    return !this.wasClaimed && !!killer;
+  }
+
+  outcome(context: Record<string, any>): void {
+    const killer: BasePiece = context['killer'];
+    killer.team.experience += 1;
+
+    this.wasClaimed = true;
+  }
+}

chess-but-better/src/controller/events/handlers/end-of-move-handlers/secret-rules/FriendlyFireHandler.ts

@@ -0,0 +1,25 @@
+import { isEqual } from "lodash";
+import { BasePiece } from "../../../../../model/piece/abstract/BasePiece";
+import { SecretRuleHandler } from "./abstract/SecretRuleHandler";
+
+export class FriendlyFireHandler extends SecretRuleHandler {
+  constructor() {
+    super('Friendly Fire');
+  }
+
+  isFriendlyFire(killer: BasePiece, victim: BasePiece): boolean {
+    return isEqual(killer.team, victim.team);
+  }
+
+  condition(context: Record<string, any>): boolean {
+    const killer: BasePiece = context['killer'];
+    const victim: BasePiece = context['victim'];
+    return !!killer && !!victim && this.isFriendlyFire(killer, victim);
+  }
+
+  outcome(context: Record<string, any>): void {
+    const killer: BasePiece = context['killer'];
+
+    killer.team.gold -= 1;
+  }
+}

chess-but-better/src/controller/events/handlers/end-of-move-handlers/secret-rules/VeteranHandler.ts

@@ -0,0 +1,18 @@
+import { BasePiece } from "../../../../../model/piece/abstract/BasePiece";
+import { SecretRuleHandler } from "./abstract/SecretRuleHandler";
+
+export class VeteranHandler extends SecretRuleHandler {
+  constructor() {
+    super('Veteran');
+  }
+
+  condition(context: Record<string, any>): boolean {
+    const killer: BasePiece = context['killer'];
+    return !!killer;
+  }
+
+  outcome(context: Record<string, any>): void {
+    const killer: BasePiece = context['killer'];
+    killer.team.experience += 1;
+  }
+}

chess-but-better/src/controller/events/handlers/end-of-move-handlers/secret-rules/abstract/SecretRuleHandler.ts

@@ -0,0 +1,22 @@
+import { BaseEventHandler } from "../../../../abstract/BaseEventHandler";
+export abstract class SecretRuleHandler implements BaseEventHandler {
+  private message: string;
+
+  constructor(message: string) {
+    this.message = message;
+  }
+
+  abstract condition(context: Record<string, any>): boolean;
+  abstract outcome(context: Record<string, any>): void;
+
+  displayMessage(message: string): void {
+    console.log(message);
+  }
+
+  handle = (context: Record<string, any>): void => {
+    if (this.condition(context)) {
+      this.displayMessage(this.message);
+      this.outcome(context);
+    }
+  }
+}

chess-but-better/src/controller/game-state/Game.ts

@@ -32,6 +32,10 @@ import { PiecesService } from "./services/pieces/PiecesService";
 import { BoardType } from "../../model/board/BoardTypes";
 import { VoidBoard } from "../../model/board/boards/VoidBoard";
 import { PieceSpawnedEventHandler } from "../events/handlers/PieceSpawnedEventHandler";
+import { FirstBloodHandler } from "../events/handlers/end-of-move-handlers/secret-rules/FirstBloodHandler";
+import { FriendlyFireHandler } from "../events/handlers/end-of-move-handlers/secret-rules/FriendlyFireHandler";
+import { VeteranHandler } from "../events/handlers/end-of-move-handlers/secret-rules/VeteranHandler";
+import { BeggersHandler } from "../events/handlers/end-of-move-handlers/secret-rules/Beggers";
 
 export class Game {
   // Teams
@@ -126,21 +130,34 @@ export class Game {
     this.boardService = new BoardService(this.boards, this.piecesStorage, this.piecesService, this.eventEmitter);
 
     // Event Handlers - End Of Move
-    const endOfMoveEventHandler = new EndOfMoveEventHandler();
-    endOfMoveEventHandler.addHandler(new TurnCounterHandler(this.turnCounter));
+    const endOfMoveHandler = new EndOfMoveEventHandler();
+    endOfMoveHandler.addHandler(new TurnCounterHandler(this.turnCounter));
 
-    this.eventEmitter.on(EventType.END_OF_TURN, endOfMoveEventHandler.handle);
+    this.eventEmitter.on(EventType.END_OF_TURN, endOfMoveHandler.handle);
 
     // Event Handlers - Piece Moved
-    const pieceMovedEventHandler = new PieceMovedEventHandler(this.eventEmitter, this.piecesStorage, this.boardService);
-    this.eventEmitter.on(EventType.PIECE_MOVED, pieceMovedEventHandler.handle);
+    const pieceMovedHandler = new PieceMovedEventHandler(this.eventEmitter, this.piecesStorage, this.boardService);
+    this.eventEmitter.on(EventType.PIECE_MOVED, pieceMovedHandler.handle);
 
     // Event Handlers - Piece Killed
-    const pieceKilledEventHandler = new PieceKilledEventHandler(this.eventEmitter, this.boards);
-    this.eventEmitter.on(EventType.PIECE_KILLED, pieceKilledEventHandler.handle);
+    const pieceKilledHandler = new PieceKilledEventHandler(this.eventEmitter, this.boards);
+    this.eventEmitter.on(EventType.PIECE_KILLED, pieceKilledHandler.handle);
 
     // Event Handlers - Piece Spawned
-    const pieceSpawnedEventHandler = new PieceSpawnedEventHandler(this.eventEmitter, this.piecesStorage);
-    this.eventEmitter.on(EventType.PIECE_SPAWNED, pieceSpawnedEventHandler.handle);
+    const pieceSpawnedHandler = new PieceSpawnedEventHandler(this.eventEmitter, this.piecesStorage);
+    this.eventEmitter.on(EventType.PIECE_SPAWNED, pieceSpawnedHandler.handle);
+
+    // Event Handlers - Secret Rules
+    const firstBloodHandler = new FirstBloodHandler();
+    this.eventEmitter.on(EventType.AFTER_PIECE_KILLED, firstBloodHandler.handle);
+
+    const veteranHandler = new VeteranHandler();
+    this.eventEmitter.on(EventType.AFTER_PIECE_KILLED, veteranHandler.handle);
+
+    const friendlyFireHandler = new FriendlyFireHandler();
+    this.eventEmitter.on(EventType.AFTER_PIECE_KILLED, friendlyFireHandler.handle);
+
+    const beggersHandler = new BeggersHandler(this.playersStorage);
+    this.eventEmitter.on(EventType.END_OF_TURN, beggersHandler.handle);
   }
 }