Working on stuff

server/routes/games.ts

@@ -347,6 +347,7 @@ interface ResourceCount {
   sheep: number;
   wheat: number;
   stone: number;
+  desert: number;
 }
 
 type Received = Record<PlayerColor | "robber", ResourceCount>;
@@ -360,13 +361,21 @@ const distributeResources = (game: Game, roll: number): void => {
     if (staticData.pips?.[pipIndex] && staticData.pips[pipIndex].roll === roll) {
       /* TODO: Fix so it isn't hard coded to "wheat" and instead is the correct resource given
        * the resource distribution in shuffeled */
-      matchedTiles.push({ type: "wheat", robber: game.robber === pos, index: pos });
+      matchedTiles.push({
+        type: "wheat",
+        robber: game.robber === pos,
+        index: pos,
+        corners: [],
+        pip: 0,
+        roads: [],
+        asset: 0,
+      });
     }
   });
 
   const receives: Received = {} as Received;
   PLAYER_COLORS.forEach((color) => {
-    receives[color] = { wood: 0, brick: 0, sheep: 0, wheat: 0, stone: 0 };
+    receives[color] = { wood: 0, brick: 0, sheep: 0, wheat: 0, stone: 0, desert: 0 };
   });
 
   /* Find which corners are on each tile */
@@ -4649,7 +4658,6 @@ router.ws("/ws/:id", async (ws, req) => {
                 case "mostDeveloped":
                 case "mostPorts":
                 case "longestRoad":
-                case "tiles":
                 case "pipOrder":
                 case "signature":
                 case "borderOrder":
@@ -4657,6 +4665,9 @@ router.ws("/ws/:id", async (ws, req) => {
                 case "activities":
                   batchedUpdate[field] = game[field];
                   break;
+                case "tiles":
+                  batchedUpdate.tiles = staticData.tiles;
+                  break;
                 case "rules":
                   batchedUpdate[field] = game.rules ? game.rules : {};
                   break;
@@ -5296,7 +5307,7 @@ const resetGame = (game: any) => {
   shuffleArray(game.developmentCards);
 
   /* Reset all player data, and add in any missing colors */
-  ["R", "B", "W", "O"].forEach((color) => {
+  PLAYER_COLORS.forEach((color) => {
     if (color in game.players) {
       clearPlayer(game.players[color]);
     } else {
@@ -5379,15 +5390,9 @@ const createGame = async (id: any) => {
     pipOrder: [],
     borderOrder: [],
     tileOrder: [],
-    tiles: [],
-    pips: [],
     step: 0 /* used for the suffix # in game backups */,
   };
 
-  ["pips", "borders", "tiles"].forEach((field) => {
-    (game as any)[field] = (staticData as any)[field];
-  });
-
   setBeginnerGame(game);
   resetGame(game);
 
@@ -5457,16 +5462,13 @@ const shuffleBoard = (game: any): void => {
   game.pipOrder = [];
   game.animationSeeds = [];
   for (let i = 0, p = 0; i < sequence.length; i++) {
-    const target = sequence[i];
+    const target: number = sequence[i]!;
-    if (typeof target !== "number") {
-      continue;
-    }
     /* If the target tile is the desert (18), then set the
      * pip value to the robber (18) otherwise set
      * the target pip value to the currently incremeneting
      * pip value. */
-    const tileIdx = typeof game.tileOrder?.[target] === "number" ? game.tileOrder[target] : undefined;
+    const tileIdx = game.tileOrder[target];
-    const tileType = typeof tileIdx === "number" && game.tiles?.[tileIdx] ? game.tiles[tileIdx].type : undefined;
+    const tileType = staticData.tiles[tileIdx]?.type;
     if (!game.pipOrder) game.pipOrder = [];
     if (tileType === "desert") {
       game.robber = target;

server/routes/games/playerFactory.ts

@@ -1,7 +1,7 @@
 import { MAX_ROADS, MAX_CITIES, MAX_SETTLEMENTS } from "./constants";
-import type { Player } from "./types";
+import type { Player, PlayerColor } from "./types";
 
-export const newPlayer = (color: string): Player => {
+export const newPlayer = (color: PlayerColor): Player => {
   return {
     roads: MAX_ROADS,
     cities: MAX_CITIES,
@@ -24,7 +24,15 @@ export const newPlayer = (color: string): Player => {
     turnStart: 0,
     ports: 0,
     developmentCards: 0,
-  } as Player;
+    orderRoll: 0,
+    position: "",
+    orderStatus: "none",
+    tied: false,
+    mustDiscard: 0,
+    live: true,
+    turnNotice: "",
+    longestRoad: 0,
+  };
 };
 
 export default newPlayer;

server/routes/games/types.ts

@@ -118,8 +118,8 @@ export interface Offer {
   [key: string]: any;
 }
 
-type ResourceType = "wood" | "brick" | "sheep" | "wheat" | "stone";
+export type ResourceType = "wood" | "brick" | "sheep" | "wheat" | "stone" | "desert";
-export const RESOURCE_TYPES = ["wood", "brick", "sheep", "wheat", "stone"] as ResourceType[];
+export const RESOURCE_TYPES = ["wood", "brick", "sheep", "wheat", "stone", "desert"] as ResourceType[];
 
 export interface Tile {
   robber: boolean;
@@ -127,6 +127,10 @@ export interface Tile {
   type: ResourceType;
   resource?: ResourceKey | null;
   roll?: number | null;
+  corners: number[];
+  pip: number;
+  roads: number[];
+  asset: number;
 }
 
 export interface Game {
@@ -145,7 +149,6 @@ export interface Game {
   pipOrder: number[];
   tileOrder: number[];
   resources?: number;
-  tiles: Tile[];
   pips?: any[];
   dice?: number[];
   chat?: any[];

server/util/layout.ts

@@ -1,5 +1,7 @@
 "use strict";
 
+import { Tile } from "../routes/games/types";
+
 /* Board Tiles:
  *       0     1     2
  *    3      4     5     6
@@ -62,12 +64,17 @@
  *                     |
  *             12      |    11      10
  */
-const Tile = (corners: number[], roads: number[]) => {
+const newTile = (corners: number[], roads: number[]): Tile => {
   return {
-    corners: corners, /* 6 */
+    robber: false,
+    index: -1,
+    type: "desert",
+    resource: null,
+    roll: null,
+    corners: corners /* 6 */,
     pip: -1,
     roads: roads,
-    asset: -1
+    asset: -1,
   };
 };
 
@@ -76,44 +83,44 @@ const Tile = (corners: number[], roads: number[]) => {
 
 const Corner = (roads: number[], banks: number[]) => {
   return {
-    roads: roads, /* max of 3 */
+    roads: roads /* max of 3 */,
-    banks: banks, /* max of 2 */
+    banks: banks /* max of 2 */,
-    data: undefined
+    data: undefined,
   };
 };
 
 const Road = (corners: number[]) => {
   return {
-    corners: corners, /* 2 */
+    corners: corners /* 2 */,
-    data: undefined
+    data: undefined,
-  }
+  };
 };
 
 const layout = {
   tiles: [
-    Tile([  0,  1,  2, 10,  9,  8], [  0,  1,  5, 13, 11,  2]),
+    newTile([0, 1, 2, 10, 9, 8], [0, 1, 5, 13, 11, 2]),
-    Tile([  2,  3,  4, 12, 11, 10], [  3,  4,  8, 16, 14,  5]),
+    newTile([2, 3, 4, 12, 11, 10], [3, 4, 8, 16, 14, 5]),
-    Tile([  4,  5,  6, 14, 13, 12], [  6,  7,  9, 19, 17,  8]),
+    newTile([4, 5, 6, 14, 13, 12], [6, 7, 9, 19, 17, 8]),
 
-    Tile([  7,  8,  9, 19, 18, 17], [ 10, 11, 15, 26, 24, 12]),
+    newTile([7, 8, 9, 19, 18, 17], [10, 11, 15, 26, 24, 12]),
-    Tile([  9, 10, 11, 21, 20, 19], [ 13, 14, 18, 29, 27, 15]),
+    newTile([9, 10, 11, 21, 20, 19], [13, 14, 18, 29, 27, 15]),
-    Tile([ 11, 12, 13, 23, 22, 21], [ 16, 17, 21, 32, 30, 18]),
+    newTile([11, 12, 13, 23, 22, 21], [16, 17, 21, 32, 30, 18]),
-    Tile([ 13, 14, 15, 25, 24, 23], [ 19, 20, 22, 35, 33, 21]),
+    newTile([13, 14, 15, 25, 24, 23], [19, 20, 22, 35, 33, 21]),
 
-    Tile([ 16, 17, 18, 29, 28, 27], [ 23, 24, 28, 40, 39, 25]),
+    newTile([16, 17, 18, 29, 28, 27], [23, 24, 28, 40, 39, 25]),
-    Tile([ 18, 19, 20, 31, 30, 29], [ 26, 27, 31, 43, 41, 28]),
+    newTile([18, 19, 20, 31, 30, 29], [26, 27, 31, 43, 41, 28]),
-    Tile([ 20, 21, 22, 33, 32, 31], [ 29, 30, 34, 46, 44, 31]),
+    newTile([20, 21, 22, 33, 32, 31], [29, 30, 34, 46, 44, 31]),
-    Tile([ 22, 23, 24, 35, 34, 33], [ 32, 33, 37, 49, 47, 34]),
+    newTile([22, 23, 24, 35, 34, 33], [32, 33, 37, 49, 47, 34]),
-    Tile([ 24, 25, 26, 37, 36, 35], [ 35, 36, 38, 53, 50, 37]),
+    newTile([24, 25, 26, 37, 36, 35], [35, 36, 38, 53, 50, 37]),
 
-    Tile([ 28, 29, 30, 40, 39, 38], [ 40, 41, 45, 55, 54, 42]),
+    newTile([28, 29, 30, 40, 39, 38], [40, 41, 45, 55, 54, 42]),
-    Tile([ 30, 31, 32, 42, 41, 40], [ 43, 44, 48, 58, 56, 45]),
+    newTile([30, 31, 32, 42, 41, 40], [43, 44, 48, 58, 56, 45]),
-    Tile([ 32, 33, 34, 44, 43, 42], [ 46, 47, 51, 61, 59, 48]),
+    newTile([32, 33, 34, 44, 43, 42], [46, 47, 51, 61, 59, 48]),
-    Tile([ 34, 35, 36, 46, 45, 44], [ 49, 50, 52, 65, 62, 51]),
+    newTile([34, 35, 36, 46, 45, 44], [49, 50, 52, 65, 62, 51]),
 
-    Tile([ 39, 40, 41, 49, 48, 47], [ 55, 56, 60, 67, 66, 57]),
+    newTile([39, 40, 41, 49, 48, 47], [55, 56, 60, 67, 66, 57]),
-    Tile([ 41, 42, 43, 51, 50, 49], [ 58, 59, 63, 69, 68, 60]),
+    newTile([41, 42, 43, 51, 50, 49], [58, 59, 63, 69, 68, 60]),
-    Tile([ 43, 44, 45, 53, 52, 51], [ 61, 62, 64, 71, 70, 63])
+    newTile([43, 44, 45, 53, 52, 51], [61, 62, 64, 71, 70, 63]),
   ],
   roads: [
     /* 0 */
@@ -258,9 +265,13 @@ const layout = {
     /* 51 */ Corner([69, 70, 63], [10]),
     /* 52 */ Corner([70, 71], [9]),
     /* 53 */ Corner([64, 71], [9]),
-  ]
+  ],
 };
 
+interface StaticDataTile {
+  type: ResourceType;
+  card: number;
+}
 const staticData = {
   tiles: [
     { type: "desert", card: 0 },
@@ -281,8 +292,8 @@ const staticData = {
     { type: "sheep", card: 3 },
     { type: "brick", card: 0 },
     { type: "brick", card: 1 },
-    { type: "brick", card: 2 }
+    { type: "brick", card: 2 },
-  ],
+  ] as StaticDataTile[],
   pips: [
     { roll: 5, pips: 4 },
     { roll: 2, pips: 1 },
@@ -302,7 +313,7 @@ const staticData = {
     { roll: 6, pips: 5 },
     { roll: 3, pips: 2 },
     { roll: 11, pips: 2 },
-    { roll: 7, pips: 0 }, /* Robber is at the end or indexing gets off */
+    { roll: 7, pips: 0 } /* Robber is at the end or indexing gets off */,
   ],
   borders: [
     ["bank", undefined, "sheep"],
@@ -310,8 +321,8 @@ const staticData = {
     ["bank", undefined, "brick"],
     [undefined, "wood", undefined],
     ["bank", undefined, "wheat"],
-    [undefined, "stone", undefined]
+    [undefined, "stone", undefined],
-  ]
+  ],
 };
 
 export {