Merge pull request #303 from Ido-Barnea/feature/inventory-system

Feature/inventory system

Author: Ido-Barnea

chess-but-better/package-lock.json

@@ -15,7 +15,8 @@
     "react": "^18.3.1",
     "react-dnd": "^16.0.1",
     "react-dnd-html5-backend": "^16.0.1",
-    "react-dom": "^18.3.1"
+    "react-dom": "^18.3.1",
+    "uuid": "^11.1.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",

chess-but-better/package.json

@@ -6,4 +6,7 @@ export enum EventType {
   AFTER_PIECE_KILLED,
   PIECE_SPAWNED,
   AFTER_PIECE_SPAWNED,
+  ITEM_PLACED,
+  AFTER_ITEM_PLACED,
+  ITEM_TRIGGERED,
 }

chess-but-better/src/assets/images/items/PiggyBankResource.svg

@@ -0,0 +1,42 @@
+import { Position } from "../../../model/piece/utilities/position/Position";
+import { BaseEventHandler } from "../abstract/BaseEventHandler";
+import { BaseItem } from "../../../model/player/inventory/abstract/BaseItem";
+import { TileOccupantType } from "../../game-state/services/board/TileOccupantType";
+import { IPiecesService } from "../../game-state/services/pieces/abstract/IPiecesService";
+import { IItemsService } from "../../game-state/services/items/abstract/IItemsService";
+import { GameEventEmitter } from "../GameEventEmitter";
+import { EventType } from "../Events";
+
+export class ItemPlacedEventHandler extends BaseEventHandler {
+    private eventEmitter: GameEventEmitter;
+    private piecesService: IPiecesService;
+    private itemsService: IItemsService;
+
+    constructor(eventEmitter: GameEventEmitter, piecesService: IPiecesService, itemsService: IItemsService) {
+        super();
+        this.eventEmitter = eventEmitter;
+        this.piecesService = piecesService;
+        this.itemsService = itemsService;
+    }
+    
+    determineTileOccupantByPosition(position: Position): TileOccupantType {
+        const matchingPiece = this.piecesService.getPieceByPosition(position);
+        if (matchingPiece) TileOccupantType.PIECE;
+
+        const matchingItem = this.itemsService.getItemByPosition(position);
+        if (matchingItem) return TileOccupantType.ITEM;
+
+        return TileOccupantType.EMPTY;
+    }
+
+    handle(context: Record<string, any>): void {
+        const item: BaseItem = context['item'];
+        const position: Position = context['position'];
+
+        const occupantType = this.determineTileOccupantByPosition(position);
+        if (item.isValidPlacement(occupantType)) {
+            item.position = position;
+            this.eventEmitter.emit(EventType.AFTER_ITEM_PLACED);
+        }
+    }
+}

chess-but-better/src/controller/events/Events.ts

@@ -1,23 +1,25 @@
-import { isEqual } from "lodash";
 import { BasePiece } from "../../../model/piece/abstract/BasePiece";
-import { IPiecesStorage } from "../../storages/pieces-storage/abstract/IPiecesStorage";
 import { Position } from "../../../model/piece/utilities/position/Position";
 import { EventType } from "../Events";
 import { GameEventEmitter } from "../GameEventEmitter";
 import { BaseEventHandler } from "../abstract/BaseEventHandler";
 import { CauseOfDeath } from "./PieceKilledEventHandler";
 import { IBoardService } from "../../game-state/services/board/abstract/IBoardService";
+import { IPiecesService } from "../../game-state/services/pieces/abstract/IPiecesService";
+import { IItemsService } from "../../game-state/services/items/abstract/IItemsService";
 
 export class PieceMovedEventHandler extends BaseEventHandler {
     private eventEmitter: GameEventEmitter;
-    private piecesStorage: IPiecesStorage;
+    private piecesService: IPiecesService;
     private boardService: IBoardService;
+    private itemsService: IItemsService;
 
-    constructor(eventEmitter: GameEventEmitter, piecesStorage: IPiecesStorage, boardService: IBoardService) {
+    constructor(eventEmitter: GameEventEmitter, piecesService: IPiecesService, boardService: IBoardService, itemsService: IItemsService) {
         super();
         this.eventEmitter = eventEmitter;
-        this.piecesStorage = piecesStorage;
+        this.piecesService = piecesService;
         this.boardService = boardService;
+        this.itemsService = itemsService;
     }
 
     calculateMovementDistance(from: Position, to: Position): number {
@@ -29,6 +31,12 @@ export class PieceMovedEventHandler extends BaseEventHandler {
 
     handleMove(piece: BasePiece, movedTo: Position) {
         piece.position = movedTo;
+
+        const itemInTargetPosition = this.itemsService.getItemByPosition(movedTo);
+        if (itemInTargetPosition) {
+            this.itemsService.useItem(itemInTargetPosition, piece);
+            this.eventEmitter.emit(EventType.ITEM_TRIGGERED);
+        }
     }
 
     handleAttack(piece: BasePiece, attackedPiece: BasePiece) {
@@ -55,11 +63,11 @@ export class PieceMovedEventHandler extends BaseEventHandler {
         const movementDistance = this.calculateMovementDistance(piece.position, movedTo);
         piece.stats.tilesMoved += movementDistance;
 
-        const piecesInTargetPosition = this.piecesStorage.getPieces((p) => isEqual(p.position, movedTo));
-        if (piecesInTargetPosition.length === 0) {
+        const pieceInTargetPosition = this.piecesService.getPieceByPosition(movedTo);
+        if (!pieceInTargetPosition) {
             this.handleMove(piece, movedTo);
         } else {
-            this.handleAttack(piece, piecesInTargetPosition[0]);
+            this.handleAttack(piece, pieceInTargetPosition);
         }
 
         this.eventEmitter.emit(EventType.AFTER_PIECE_MOVED);

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

@@ -36,6 +36,12 @@ import { FirstBloodHandler } from "../events/handlers/end-of-move-handlers/secre
 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";
+import { IItemsStorage } from "../storages/items-storage/abstract/IItemsStorage";
+import { ItemsStorage } from "../storages/items-storage/ItemsStorage";
+import { PiggyBank } from "../items/PiggyBank";
+import { ItemsService } from "./services/items/ItemsService";
+import { IItemsService } from "./services/items/abstract/IItemsService";
+import { ItemPlacedEventHandler } from "../events/handlers/ItemPlacedEventHandler";
 
 export class Game {
   // Teams
@@ -51,11 +57,13 @@ export class Game {
 
   // Storage
   public playersStorage: IPlayersStorage;
-  public piecesStorage: IPiecesStorage;
+  private piecesStorage: IPiecesStorage;
+  public itemsStorage: IItemsStorage;
 
   // Services
   public piecesService: IPiecesService;
   public boardService: IBoardService;
+  public itemsService: IItemsService;
 
   // Counters
   public turnCounter: ITurnCounter;
@@ -82,6 +90,7 @@ export class Game {
 
     // Storage
     this.playersStorage = new PlayersStorage([this.whitePlayer, this.blackPlayer]);
+    this.itemsStorage = new ItemsStorage([new PiggyBank(undefined)]);
 
     // Counters
     this.turnCounter = new TurnCounter(this.playersStorage);
@@ -128,6 +137,7 @@ export class Game {
     // Services
     this.piecesService = new PiecesService(this.piecesStorage, this.turnCounter);
     this.boardService = new BoardService(this.boards, this.piecesStorage, this.piecesService, this.eventEmitter);
+    this.itemsService = new ItemsService(this.itemsStorage);
 
     // Event Handlers - End Of Move
     const endOfMoveHandler = new EndOfMoveEventHandler();
@@ -136,7 +146,7 @@ export class Game {
     this.eventEmitter.on(EventType.END_OF_TURN, endOfMoveHandler.handle);
 
     // Event Handlers - Piece Moved
-    const pieceMovedHandler = new PieceMovedEventHandler(this.eventEmitter, this.piecesStorage, this.boardService);
+    const pieceMovedHandler = new PieceMovedEventHandler(this.eventEmitter, this.piecesService, this.boardService, this.itemsService);
     this.eventEmitter.on(EventType.PIECE_MOVED, pieceMovedHandler.handle);
 
     // Event Handlers - Piece Killed
@@ -147,6 +157,10 @@ export class Game {
     const pieceSpawnedHandler = new PieceSpawnedEventHandler(this.eventEmitter, this.piecesStorage);
     this.eventEmitter.on(EventType.PIECE_SPAWNED, pieceSpawnedHandler.handle);
 
+    // Event Handler - Item Placed
+    const itemPlacedHandler = new ItemPlacedEventHandler(this.eventEmitter, this.piecesService, this.itemsService);
+    this.eventEmitter.on(EventType.ITEM_PLACED, itemPlacedHandler.handle);
+
     // Event Handlers - Secret Rules
     const firstBloodHandler = new FirstBloodHandler();
     this.eventEmitter.on(EventType.AFTER_PIECE_KILLED, firstBloodHandler.handle);

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

@@ -7,6 +7,7 @@ import { BoardType } from "../../../../model/board/BoardTypes";
 import { IPiecesStorage } from "../../../storages/pieces-storage/abstract/IPiecesStorage";
 import { IPiecesService } from "../pieces/abstract/IPiecesService";
 import { GameEventEmitter } from "../../../events/GameEventEmitter";
+import { BaseItem } from "../../../../model/player/inventory/abstract/BaseItem";
 
 export class BoardService implements IBoardService {
   private boards: Record<BoardType, BaseBoard>;
@@ -41,7 +42,7 @@ export class BoardService implements IBoardService {
             }, [] as Array<BaseBoard>);
   }
 
-  movePiece(piece: BasePiece, to: Position) {
+  movePiece(piece: BasePiece, to: Position): void {
     if (!this.piecesService.isLegalMove(piece, to)) return;
 
     this.eventEmitter.emit(EventType.PIECE_MOVED, {piece, to});
@@ -57,4 +58,10 @@ export class BoardService implements IBoardService {
       board: this.getBoard(position.board.name),
     }
   }
+
+  placeItem(item: BaseItem, position: Position): void {
+    if (!item) return;
+
+    this.eventEmitter.emit(EventType.ITEM_PLACED, {item, position});
+  }
 }

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

@@ -0,0 +1,5 @@
+export enum TileOccupantType {
+  PIECE,
+  ITEM,
+  EMPTY,
+}

chess-but-better/src/controller/game-state/services/board/BoardService.ts

@@ -2,10 +2,12 @@ import { BaseBoard } from "../../../../../model/board/abstract/BaseBoard";
 import { BoardType } from "../../../../../model/board/BoardTypes";
 import { BasePiece } from "../../../../../model/piece/abstract/BasePiece";
 import { Position } from "../../../../../model/piece/utilities/position/Position";
+import { BaseItem } from "../../../../../model/player/inventory/abstract/BaseItem";
 
 export interface IBoardService {
   getBoard: (type: BoardType) => BaseBoard;
   retrievePopulatedBoards: () => Array<BaseBoard>;
   movePiece(piece: BasePiece, to: Position): void;
   copyPosition(position: Position): Position;
+  placeItem(item: BaseItem, position: Position): void;
 }