Plumbed all functions in server

Signed-off-by: James Ketrenos <james_eikona@ketrenos.com>

client/src/App.js

@@ -291,30 +291,23 @@ const Table = () => {
               <Button onClick={() => { setError("")}}>dismiss</Button>
             </Paper>
           </div> }
-          { warning && <div className="WarningDialog"><Paper className="Warning">{ warning }</Paper></div> }
+          { warning && <div className="WarningDialog">
+            <Paper className="Warning">{ warning }</Paper>
+          </div> }
           { state === 'normal' && <SelectPlayer/> }
           { color && state === 'game-order' && <GameOrder/> }
+          { /* state === 'normal' && <Trade/> */ }
+          { /* state === 'winner' &&  <Winner color={winner}/>  */ }
+          { /* cardActive && <ViewCard card={cardActive}/> */ }
+
+          { /*isTurn && turn && turn.actions && game.turn.actions.indexOf('select-resources') !== -1 &&
+            <ChooseCard type={turn.active}/>
+          */ }
 
           <Board/>          
           <PlayersStatus/>
           <PlayersStatus active={true}/>
           <Hand {...{buildActive, setBuildActive}}/>
-          { /* state === 'winner' && 
-            <Winner color={winner}/>
-          }
-
-          { state === 'normal' &&
-            turn && turn.actions && turn.actions.indexOf('trade') !== -1 &&
-            <Trade/>
-          }
-
-          { cardActive &&
-            <ViewCard card={cardActive}/>
-          }
-
-          { isTurn && turn && turn.actions && game.turn.actions.indexOf('select-resources') !== -1 &&
-            <ChooseCard type={turn.active}/>
-        */  }
         </div>
         <div className="Sidebar">
           { name !== "" && <PlayerList/> }

client/src/Trade.js

@@ -16,7 +16,11 @@ const empty = {
   sheep: 0
 };
 
-const Trade = ({table}) => {
+/*
+&& turn && turn.actions 
+          && turn.actions.indexOf('trade') !== -1 &&
+*/
+const Trade = () => {
   const [gives, setGives] = useState(Object.assign({}, empty));
   const [gets, setGets] = useState(Object.assign({}, empty));
   const player = (table.game && table.game.player) ? table.game.player : undefined;

server/routes/games.js

@@ -808,7 +808,7 @@ const setPlayerName = (game, session, name) => {
         rejoin = true;
         /* Update the session object from tmp, but retain websocket
          * from active session */
-        Object.assign(session, tmp, { ws: session.ws });
+        Object.assign(session, tmp, { ws: session.ws, id: session.id });
         console.log(`${info}: ${name} has been reallocated to a new session.`);
         delete game.sessions[id];
       } else {
@@ -1252,7 +1252,7 @@ const calculateRoadLengths = (game, session) => {
     }
   });
 
-  console.log('Graphs A:', graphs);
+  if (debug.road) console.log('Graphs A:', graphs);
   
   clearRoadWalking(game);
   graphs.forEach(graph => {
@@ -1268,9 +1268,9 @@ const calculateRoadLengths = (game, session) => {
     });
   });
 
-  console.log('Graphs B:', graphs);
+  if (debug.road) console.log('Graphs B:', graphs);
   
-  console.log('Pre update:', game.placements.roads.filter(road => road.color));
+  if (debug.road) console.log('Pre update:', game.placements.roads.filter(road => road.color));
 
   for (let color in game.players) {
     if (game.players[color] === 'Not active') {
@@ -1292,11 +1292,11 @@ const calculateRoadLengths = (game, session) => {
 
   game.placements.roads.forEach(road => delete road.walking);
 
-  console.log('Post update:', game.placements.roads.filter(road => road.color));
+  if (debug.road) console.log('Post update:', game.placements.roads.filter(road => road.color));
 
   let checkForTies = false;
   
-  console.log(currentLongest, currentLength);
+  if (debug.road) console.log(currentLongest, currentLength);
 
   if (currentLongest && game.players[currentLongest].longestRoad < currentLength) {
     const _session = sessionFromColor(game, currentLongest);
@@ -1320,7 +1320,7 @@ const calculateRoadLengths = (game, session) => {
     }
   }
 
-  console.log({ longestPlayers });
+  if (debug.road) console.log({ longestPlayers });
   
   if (longestPlayers.length > 0) {
     if (longestPlayers.length === 1) {
@@ -1344,8 +1344,6 @@ const calculateRoadLengths = (game, session) => {
     game.longestRoad = null;
     game.longestRoadLength = 0;
   }
-
-  
 };
 
 const getValidCorners = (game, color, type) => {
@@ -1667,7 +1665,7 @@ router.put("/:id/:action/:value?", async (req, res) => {
   return res.status(400).send(error);
 });
 
-const trade = (game, session, { offer, value }) => {
+const trade = (game, session, action, offer) => {
   const name = session.name;
 
   if (game.state !== "normal") {
@@ -1691,7 +1689,7 @@ const trade = (game, session, { offer, value }) => {
   }
 
   /* Only the active player can cancel trading */
-  if (value === 'cancel') {
+  if (action === 'cancel') {
     /* TODO: Perhaps 'cancel' is how a player can remove an offer... */
     if (game.turn.name !== name) {
       return `Only the active player can cancel trading negotiations.`;
@@ -1703,7 +1701,7 @@ const trade = (game, session, { offer, value }) => {
   }
 
   /* Any player can make an offer */
-  if (value === 'offer') {
+  if (action === 'offer') {
      error = checkPlayerOffer(game, session.player, offer);
     if (error) {
       return error;
@@ -1746,7 +1744,7 @@ const trade = (game, session, { offer, value }) => {
   }
 
   /* Any player can reject an offer */
-  if (value === 'reject') {
+  if (action === 'reject') {
     /* If the active player rejected an offer, they rejected another player */
     const other = game.players[offer.color];
     if (!other.offerRejected) {
@@ -1758,7 +1756,7 @@ const trade = (game, session, { offer, value }) => {
   }
 
   /* Only the active player can accept an offer */
-  if (value === 'accept') {
+  if (action === 'accept') {
     if (game.turn.name !== name) {
       return `Only the active player can accept an offer.`;
     }
@@ -2000,7 +1998,9 @@ const stealResource = (game, session, color) => {
   });
 }
 
-const buyDevelopment = (game, session, value) => {
+const buyDevelopment = (game, session) => {
+  const player = session.player;
+  
   if (game.state !== 'normal') {
     return `You cannot purchase a development card unless the game is active.`;
   }
@@ -2052,8 +2052,8 @@ const buyDevelopment = (game, session, value) => {
   });
 }
 
-const playCard = (game, session, { card }) => {
+const playCard = (game, session, card) => {
-  const name = session.name;
+  const name = session.name, player = session.player;
 
   if (game.state !== 'normal') {
     return `You cannot play a development card unless the game is active.`;
@@ -2444,7 +2444,9 @@ const placeRoad = (game, session, index) => {
       game.state = 'normal';
     }
   }
-  
+  sendUpdateToPlayer(session, {
+    private: game.player
+  });
   sendUpdateToPlayers(game, {
     placements: game.placements,
     turn: game.turn,
@@ -2453,9 +2455,7 @@ const placeRoad = (game, session, index) => {
     longestRoad: game.longestRoad,
     longestRoadLength: game.longestRoadLength
   });
-  sendUpdateToPlayer(session, {
+
-    private: game.player
-  });
 }
 
 const discard = (game, session, discards) => {
@@ -2515,29 +2515,56 @@ const discard = (game, session, discards) => {
   });
 }
 
-const asdf = () => {
+const buyRoad = (game, session) => {
-  const game = 0, session = 0;
+  const player = session.player;
-  switch (game) {
+
-  case 'select-resources':
+  if (game.state !== 'normal') {
+    return `You cannot purchase a road unless the game is active.`;
+  }
+  if (session.color !== game.turn.color) {
+    return `It is not your turn! It is ${game.turn.name}'s turn.`;
+  }
+  if (!game.turn.roll) {
+    return `You cannot build until you have rolled.`;
+  }
+  
+  if (game.turn && game.turn.robberInAction) {
+    return `Robber is in action. You can not purchase until all Robber tasks are resolved.`;
+  }
+
+  if (player.brick < 1 || player.wood < 1) {
+    return `You have insufficient resources to build a road.`;
+  }
+  if (player.roads < 1) {
+    return `You have already built all of your roads.`;
+  }
+  const roads = getValidRoads(game, session.color);
+  if (roads.length === 0) {
+    return `There are no valid locations for you to place a road.`;
+  }
+  setForRoadPlacement(game, roads);
+  addActivity(game, session, `${game.turn.name} is considering building a road.`);
+  sendUpdateToPlayers(game, {
+    turn: game.turn,
+    chat: game.chat
+  });
+}
+
+const selectResources = (game, session, cards) => {
+  const player = session.player;
   if (!game || !game.turn || !game.turn.actions || 
       game.turn.actions.indexOf('select-resources') === -1) {
     return `Please, let's not cheat. Ok?`;
-      console.log(game);
-      break;
   }
 
   if (session.color !== game.turn.color) {
     return `It is not your turn! It is ${game.turn.name}'s turn.`;
-      break;
   }
 
   const count = (game.turn.active === 'monopoly') ? 1 : 2;
 
-    cards = req.body;
-
   if (!cards || cards.length > count || cards.length === 0) {
     return `You have chosen the wrong number of cards!`;
-      break;
   }
 
   const isValidCard = (type) => {
@@ -2556,7 +2583,7 @@ const asdf = () => {
   const selected = {};
   cards.forEach(card => {
     if (!isValidCard(card)) {
-        error = `Invalid resource type!`;
+      return `Invalid resource type!`;
     }
     if (card in selected) {
       selected[card]++;
@@ -2569,10 +2596,6 @@ const asdf = () => {
     display.push(`${selected[card]} ${card}`);
   }
 
-    if (error) {
-      break;
-    }
-
   addActivity(game, session, `${session.name} has chosen ${display.join(', ')}!`);
 
   switch (game.turn.active) {
@@ -2615,117 +2638,117 @@ const asdf = () => {
   }
   delete game.turn.active;
   game.turn.actions = [];
-    break;
+  sendUpdateToPlayer(session, {
+    private: game.player
+  });
+  sendUpdateToPlayers(game, {
+    turn: game.turn,
+    chat: game.chat,
+    activities: game.activities
+  });
+}
 
-  case 'buy-settlement':
+const buySettlement = (game, session) => {
+  const player = session.player;
   if (game.state !== 'normal') {
-      error = `You cannot purchase a settlement unless the game is active.`;
+    return `You cannot purchase a settlement unless the game is active.`;
-      break;
   }
   if (session.color !== game.turn.color) {
-      error = `It is not your turn! It is ${game.turn.name}'s turn.`;
+    return `It is not your turn! It is ${game.turn.name}'s turn.`;
-      break;
   }
   if (!game.turn.roll) {
-      error = `You cannot build until you have rolled.`;
+    return `You cannot build until you have rolled.`;
-      break;
   }
   
   if (game.turn && game.turn.robberInAction) {
-      error = `Robber is in action. You can not purchase until all Robber tasks are resolved.`;
+    return `Robber is in action. You can not purchase until all Robber tasks are resolved.`;
-      break;
   }
 
   if (player.brick < 1 || player.wood < 1 || player.wheat < 1 || player.sheep < 1) {
-      error = `You have insufficient resources to build a settlement.`;
+    return `You have insufficient resources to build a settlement.`;
-      break;
   }
   if (player.settlements < 1) {
-      error = `You have already built all of your settlements.`;
+    return `You have already built all of your settlements.`;
-      break;
   }
   corners = getValidCorners(game, session.color);
   if (corners.length === 0) {
-      error = `There are no valid locations for you to place a settlement.`;
+    return `There are no valid locations for you to place a settlement.`;
-      break;
   }
   setForSettlementPlacement(game, corners);
   addActivity(game, session, `${game.turn.name} is considering placing a settlement.`);
-    break;
 
-    case 'buy-city':
+  sendUpdateToPlayers(game, {
+    turn: game.turn,
+    chat: game.chat,
+    activities: game.activities
+  });
+}
+
+const buyCity = (game, session) => {
+  const player = session.player;
   if (game.state !== 'normal') {
-        error = `You cannot purchase a city unless the game is active.`;
+    return `You cannot purchase a city unless the game is active.`;
-        break;
   }
   if (session.color !== game.turn.color) {
-        error = `It is not your turn! It is ${game.turn.name}'s turn.`;
+    return `It is not your turn! It is ${game.turn.name}'s turn.`;
-        break;
   }
   if (!game.turn.roll) {
-        error = `You cannot build until you have rolled.`;
+    return `You cannot build until you have rolled.`;
-        break;
   }  
   if (player.wheat < 2 || player.stone < 3) {
-        error = `You have insufficient resources to build a city.`;
+    return `You have insufficient resources to build a city.`;
-        break;
   }
   
   if (game.turn && game.turn.robberInAction) {
-        error = `Robber is in action. You can not purchase until all Robber tasks are resolved.`;
+    return `Robber is in action. You can not purchase until all Robber tasks are resolved.`;
-        break;
   }
 
   if (player.city < 1) {
-        error = `You have already built all of your cities.`;
+    return `You have already built all of your cities.`;
-        break;
   }
   corners = getValidCorners(game, session.color, 'settlement');
   if (corners.length === 0) {
-        error = `There are no valid locations for you to place a city.`;
+    return `There are no valid locations for you to place a city.`;
-        break;
   }
   setForCityPlacement(game, corners);
   addActivity(game, session, `${game.turn.name} is considering upgrading a settlement to a city.`);
-      break;
+  sendUpdateToPlayers(game, {
+    turn: game.turn,
+    chat: game.chat,
+    activities: game.activities
+  });
+}
 
-    case 'place-city':
+const placeCity = (game, session, index) => {
+  const player = session.player;
+  index = parseInt(value);
   if (game.state !== 'normal') {
-        error = `You cannot place an item unless the game is active.`;
+    return `You cannot place an item unless the game is active.`;
-        break;
   }
   if (session.color !== game.turn.color) {
-        error = `It is not your turn! It is ${game.turn.name}'s turn.`;
+    return `It is not your turn! It is ${game.turn.name}'s turn.`;
-        break;
   }
-      index = parseInt(value);
   if (game.placements.corners[index] === undefined) {
-        error = `You have requested to place a city illegally!`;
+    return `You have requested to place a city illegally!`;
-        break;
   }
   /* If this is not a placement the turn limits, discard it */
   if (game.turn && game.turn.limits && game.turn.limits.corners && game.turn.limits.corners.indexOf(index) === -1) {
-        error = `You tried to cheat! You should not try to break the rules.`;
+    return `You tried to cheat! You should not try to break the rules.`;
-        break;
   }
-      corner = game.placements.corners[index];
+  const corner = game.placements.corners[index];
   if (corner.color !== session.color) {
-        error = `This location already has a settlement belonging to ${game.players[corner.color].name}!`;
+    return `This location already has a settlement belonging to ${game.players[corner.color].name}!`;
-        break;
   }
   if (corner.type !== 'settlement') {
-        error = `This location already has a city!`;
+    return `This location already has a city!`;
-        break;
   }
   if (!game.turn.free) {
     if (player.wheat < 2 || player.stone < 3) {
-          error = `You have insufficient resources to build a city.`;
+      return `You have insufficient resources to build a city.`;
-          break;
     }
   }
   if (player.city < 1) {
-        error = `You have already built all of your cities.`;
+    return `You have already built all of your cities.`;
-        break;
   }
   
   corner.color = session.color;
@@ -2748,50 +2771,16 @@ const asdf = () => {
   debugChat(game, 'After city purchase');
   game.turn.actions = [];
   game.turn.limits = {};
-      addActivity(game, session, `${name} upgraded a settlement to a city!`);
+  addActivity(game, session, `${session.name} upgraded a settlement to a city!`);
-      break;
+  sendUpdateToPlayer(session, {
-
+    private: session.player
-  case 'buy-road':
+  });
-    if (game.state !== 'normal') {
+  sendUpdateToPlayers(game, {
-      error = `You cannot purchase a road unless the game is active.`;
+    turn: game.turn,
-      break;
+    chat: game.chat,
+    activities: game.activities
+  });
 }
-    if (session.color !== game.turn.color) {
-      error = `It is not your turn! It is ${game.turn.name}'s turn.`;
-      break;
-    }
-    if (!game.turn.roll) {
-      error = `You cannot build until you have rolled.`;
-      break;
-    }
-    
-    if (game.turn && game.turn.robberInAction) {
-      error = `Robber is in action. You can not purchase until all Robber tasks are resolved.`;
-      break;
-    }
-
-    if (player.brick < 1 || player.wood < 1) {
-      error = `You have insufficient resources to build a road.`;
-      break;
-    }
-    if (player.roads < 1) {
-      error = `You have already built all of your roads.`;
-      break;
-    }
-    let roads = getValidRoads(game, session.color);
-    if (roads.length === 0) {
-      error = `There are no valid locations for you to place a road.`;
-      break;
-    }
-    setForRoadPlacement(game, roads);
-    addActivity(game, session, `${game.turn.name} is considering building a road.`);
-    break;
-
-    break;
-  
-    break;
-  }
-};
 
 const ping = (session) => {
   if (!session.ws) {
@@ -2892,7 +2881,6 @@ const join = (peers, session, id) => {
   peers[session.name] = ws;
 };
 
-
 const part = (peers, session, id) => {
   const ws = session.ws;
 
@@ -3036,7 +3024,6 @@ const sendUpdateToPlayers = async (game, update) => {
   await saveGame(game);
 }
 
-
 const sendUpdateToPlayer = async (session, update) => {
   if (debug.update) {
     console.log(`${session.id}: -> sendUpdateToPlayer:${getName(session)} - `, update);
@@ -3385,10 +3372,8 @@ const wsConnect = async (ws, req) => {
     case 'shuffle':
       console.log(`${short}: <- shuffle:${getName(session)}`);
       warning = shuffle(game, session);
-      if (error) {
+      if (warning) {
         warning(session, error);
-      } else {
-        warning(game);
       }
       break;
     case 'place-settlement':
@@ -3398,6 +3383,13 @@ const wsConnect = async (ws, req) => {
         sendWarning(session, warning);
       }
       break;
+    case 'place-city':
+      console.log(`${short}: <- place-city:${getName(session)} ${data.index}`);
+      warning = placeCity(game, session, data.index);
+      if (warning) {
+        sendWarning(session, warning);
+      }
+      break;
     case 'place-road':
       console.log(`${short}: <- place-road:${getName(session)} ${data.index}`);
       warning = placeRoad(game, session, data.index);
@@ -3433,6 +3425,65 @@ const wsConnect = async (ws, req) => {
         sendWarning(session, warning);
       }
       break;
+    case 'select-resources':
+      console.log(`${short}: <- select-resources:${getName(session)}`);
+      warning = selectResources(game, session, data.cards);
+      if (warning) {
+        sendWarning(session, warning);
+      }
+      break;
+    case 'buy-city':
+      console.log(`${short}: <- buy-city:${getName(session)}`);
+      warning = buyCity(game, session);
+      if (warning) {
+        sendWarning(session, warning);
+      }
+      break;
+    case 'buy-road':
+      console.log(`${short}: <- buy-road:${getName(session)}`);
+      warning = buyRoad(game, session);
+      if (warning) {
+        sendWarning(session, warning);
+      }
+      break;
+    case 'buy-settlement':
+      console.log(`${short}: <- buy-settlement:${getName(session)}`);
+      warning = buySettlement(game, session);
+      if (warning) {
+        sendWarning(session, warning);
+      }
+      break;
+    case 'buy-development':
+      console.log(`${short}: <- buy-development:${getName(session)}`);
+      warning = buyDevelopment(game, session);
+      if (warning) {
+        sendWarning(session, warning);
+      }
+      break;
+    case 'play-card':
+      console.log(`${short}: <- play-card:${getName(session)}`);
+      warning = playCard(game, session, data.card);
+      if (warning) {
+        sendWarning(session, warning);
+      }
+      break;
+    case 'trade':
+      console.log(`${short}: <- trade:${getName(session)}`);
+      warning = trade(game, session, data.action, data.offer);
+      if (warning) {
+        sendWarning(session, warning);
+      } else {
+        sendUpdateToPlayer(session, {
+          private: session.player
+        });
+        sendUpdateToPlayers(game, {
+          players: getFilteredPlayers(game),
+          turn: game.turn,
+          activities: game.activities,
+          chat: game.chat
+        });
+      }
+      break;
     default:
       console.warn(`Unsupported request: ${data.type}`);
       break;