Changeset b13f93b for pages/api

Timestamp:

07/03/22 22:59:15 (2 years ago)

Author:

anastasovv <simon@…>

Branches:

main

Children:

3a783f2

Parents:

ace7865

Message:

Made poker tables system and round 1

Location:

pages/api

Files:

• blackjack/gameStates.js (modified) (1 diff)
• poker/index.js (modified) (1 diff)
• roulette/index.js (modified) (1 diff)

pages/api/blackjack/gameStates.js

@@ -29 +29 @@
  */
 function checkDeckSize(game) {
-    if (game.deck.length === 0) {
-      game.deck = [...deck];
-    }
+  if (game.deck.length === 0) {
+    game.deck = [...deck];
   }
+}
   
 /**

pages/api/poker/index.js

@@ +1 @@
+import axios from 'axios';
+
+require('dotenv').config();
+
+import { v4 as uuidv4 } from 'uuid';
+
+const sampleTable = {
+    id: '',
+    name: '',
+    status: '_1_just_created',
+    creator: '',
+    started: false,
+    round: 0,
+    turnIdx: 0,
+    lastBet: 0,
+    turnsSinceLastBet: 0,
+    players: [],
+    deck: [],
+    cardsOnTable: [],
+}
+
+const samplePlayer = {
+    id: '',
+    table: '',
+    status: '_1_just_entered',
+    displayName: '',
+    cards: [],
+    betAmount: 0,
+    isSatDown: false,
+    isCoordinator: false,
+    isFolded: false,
+}
+
+let tables = []
+// contures -> { status, round, turnIdx, lastBet, turnsSinceLastBet,
+//
+//              players -> { id, table, status, displayName, cards,
+//                          betAmount, isSatDown, isCoordinator },
+//
+//              cardsOnTable }
+
+const singleDeck = ["SA", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9", "SX", "SJ", "SQ", "SK",
+                    "HA", "H2", "H3", "H4", "H5", "H6", "H7", "H8", "H9", "HX", "HJ", "HQ", "HK",
+                    "CA", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "CX", "CJ", "CQ", "CK",
+                    "DA", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "DX", "DJ", "DQ", "DK"    ];
+
+/* We are using 5 decks */
+const deck = singleDeck.concat(singleDeck).concat(singleDeck).concat(singleDeck).concat(singleDeck);
+
+/**
+ * Replace deck if empty
+ */
+function checkDeckSize(tableId) {
+    const tableIdx = tables.map(e=>e.id).indexOf(tableId);
+
+    if (tables[tableIdx] !== undefined) {
+        if (tables[tableIdx].deck.length === 0) {
+            tables[tableIdx].deck = [...deck];
+        }
+    }
+}
+
+/**
+ * Draw a SINGLE random card
+ */
+function drawASingleCard(tableId) {
+    const tableIdx = tables.map(e=>e.id).indexOf(tableId);
+
+    if (tables[tableIdx] !== undefined) {
+        checkDeckSize(tableId);
+        
+        let idx = Math.floor(Math.random() * tables[tableIdx].deck.length);
+        let card = tables[tableIdx].deck[idx];
+
+        tables[tableIdx].deck.splice(idx, 1);
+
+        return card;
+    }
+
+    return undefined;
+}
+
+function setNextPlayerIdx(tableId) {
+    const tableIdx = tables.map(e=>e.id).indexOf(tableId);
+
+    if (tables[tableIdx] !== undefined) {
+        const table = tables[tableIdx];
+
+        while (true) {
+            table.turnIdx++;
+            table.turnIdx %= table.players.length;
+            
+            if (table.players[table.turnIdx] !== undefined && table.players[table.turnIdx].isSatDown && !table.players[table.turnIdx].isFolded) {
+                return ;
+            }
+        }
+    }
+}
+
+function getCardsOnTable(tableId) {
+    const tableIdx = tables.map(e=>e.id).indexOf(tableId);
+
+    if (tables[tableIdx] !== undefined) {
+        const table = tables[tableIdx];
+
+        if (table.round === 2) {
+            for (let i = 0; i < 3; i++) {
+                const card = drawASingleCard(table.id);
+                            
+                if (card !== undefined) {
+                    table.cards.push(card);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * ********************* BEGIN OF FUNCTIONS *********************
+ */
+
+function createTable(playerId, playerName, tableName) {
+    const tableId = uuidv4();
+
+    const table = {
+        id: tableId,
+        name: tableName,
+        status: '_1_just_created',
+        creator: playerName,
+        started: false,
+        round: 0,
+        turnIdx: 0,
+        lastBet: 20,
+        turnsSinceLastBet: 0,
+        deck: [...deck],
+        players: [{
+            id: playerId,
+            table: tableId,
+            status: '_1_just_entered',
+            displayName: playerName,
+            cards: [],
+            betAmount: 0,
+            isSatDown: false,
+            isCoordinator: true,
+            isFolded: false,
+        }],
+        cards: [],
+    }
+
+    tables.push(table)
+
+    return table;
+}
+
+function getRestrictedTablesArray() {
+    let result = [];
+
+    tables.forEach(table => {
+        let tmpPlayers = [];
+        table.players.forEach(player => {
+            tmpPlayers.push({
+                ...player,
+                id: '',
+                table: '',
+                cards: '',
+            })
+        });
+
+        let tmp = {
+            ...table,
+            deck: [],
+            players: tmpPlayers,
+        }
+
+        result.push({...tmp});
+    })
+
+    return result;
+}
+
+function getRestrictedTableArray(tableId, session_id) {
+    let result = {...sampleTable};
+
+    let tableIdx = tables.map(e=>e.id).indexOf(tableId);
+
+    if (tableIdx !== -1) {
+        let table = tables[tableIdx];
+
+        let tmpPlayers = [];
+        table.players.forEach(player => {
+            if (player.id === session_id) {
+                tmpPlayers.push({
+                    ...player,
+                    id: '',
+                    table: '',
+                })
+            }
+            else {
+                tmpPlayers.push({
+                    ...player,
+                    id: '',
+                    table: '',
+                    cards: player.cards.length > 0 ? ['back', 'back'] : '',
+                })
+            }
+        });
+
+        result = {
+            ...table,
+            players: tmpPlayers,
+        }
+    }
+
+    return result;
+}
+
+function getTable(tableId) {
+    const tableIdx = tables.map(e=>e.id).indexOf(tableId);
+
+    if (tableIdx !== -1) {
+        return tables[tableIdx];
+    }
+
+    return undefined;
+}
+
+function getTableAndPlayer(session_id) {
+    for (let tableIdx = 0; tableIdx < tables.length; tableIdx++) {
+        const playerIdx = tables[tableIdx].players.map(e=>e.id).indexOf(session_id);
+
+        if (playerIdx !== -1) {
+            return {
+                success: true,
+                table: tables[tableIdx],
+                player: tables[tableIdx].players[playerIdx],
+            }
+        }
+    }
+
+    return {
+        success: false,
+        table: sampleTable,
+        player: samplePlayer,
+    };
+}
+
+/**
+ * ********************* END OF FUNCTIONS *********************
+ */
+
+/**
+ * ********************* BEGIN OF REQUEST HANDLER *********************
+ */
+export default async function handler(req, res) {
+    /**
+     * GET method
+     */
+    if (req.method === 'GET') {
+        
+        /**
+         * /---------------------- GET ----------------------/
+         * Creates the table and enters the user inside
+         * @action game_action
+         * @param session_id
+         * @param specificAction
+         * @param betAmount
+         */
+        if (req.query.action === 'game_action' && req.query?.session_id && req.query?.specificAction && req.query?.betAmount) {
+            const { success, table, player } = getTableAndPlayer(req.query.session_id)
+
+            if (success && table.started) {
+                if (table.players.map(e=>e.id).indexOf(req.query.session_id) !== table.turnIdx) {
+                    res.end();
+                    return ;
+                }
+
+                let okayToGo = false;
+
+                const satDownPlayers = table.players.filter(e=>e.isSatDown === true);
+                const remainingPlayers = satDownPlayers.filter(e=>e.folded === false);
+
+                if (req.query.specificAction === 'check') {
+
+                }
+                else if (req.query.specificAction === 'call') {
+                    player.betAmount += table.lastBet;
+                    table.turnsSinceLastBet++;
+                    okayToGo = true;
+
+                    if (table.turnsSinceLastBet === remainingPlayers.length) {
+                        table.round++;
+                        table.lastBet = 0;
+
+                        getCardsOnTable(table.id);
+                    }
+                }
+                else if (req.query.specificAction === 'raise') {
+                    
+                }
+                else if (req.query.specificAction === 'fold') {
+                    player.folded = true;
+                }
+
+                if (okayToGo) {
+                    setNextPlayerIdx(table.id);
+                }
+            }
+            
+            res.end();
+        }
+
+        /**
+         * /---------------------- GET ----------------------/
+         * Creates the table and enters the user inside
+         * @action start_game
+         * @param session_id
+         */
+        if (req.query.action === 'start_game' && req.query?.session_id) {
+            const { success, table } = getTableAndPlayer(req.query.session_id)
+
+            if (success && !table.started) {
+                table.started = true;
+                table.round = 1;
+
+                const satDownPlayers = table.players.filter(e=>e.isSatDown === true);
+
+                table.turnIdx = Math.floor(Math.random(0, satDownPlayers.length))
+
+                table.players.forEach(player => {
+                    if (player.isSatDown) {
+                        for (let i = 0; i < 2; i++) {
+                            const card = drawASingleCard(table.id);
+                            
+                            if (card !== undefined) {
+                                player.cards.push(card);
+                            }
+                        }
+                    }
+                })
+            }
+            
+            res.end();
+        }
+
+        /**
+         * /---------------------- GET ----------------------/
+         * Creates the table and enters the user inside
+         * @action sit_down
+         * @param session_id
+         * @param tableId
+         */
+         if (req.query.action === 'sit_down' && req.query?.session_id && req.query?.tableId) {
+            const { success, table, player } = getTableAndPlayer(req.query.session_id)
+
+            if (success && !table.started) {
+                player.isSatDown = true;
+            }
+
+            res.end();
+        }
+
+        /**
+         * /---------------------- GET ----------------------/
+         * Creates the table and enters the user inside
+         * @action join_a_table
+         * @param session_id
+         * @param tableId
+         * @param displayName
+         */
+         if (req.query.action === 'join_a_table' && req.query?.session_id && req.query?.tableId && req.query?.displayName) {
+            if (req.query.tableId.length > 0) {
+                const { success } = getTableAndPlayer(req.query.session_id);
+
+                if (!success) {
+                    const table = getTable(req.query.tableId)
+
+                    if (!table.started) {
+                        table.players.push({
+                            ...samplePlayer,
+                            id: req.query.session_id,
+                            table: req.query.tableId,
+                            displayName: req.query.displayName
+                        })
+                    }
+                }
+            }
+
+            res.end();
+        }
+
+        /**
+         * /---------------------- GET ----------------------/
+         * Creates the table and enters the user inside
+         * @action create_a_table
+         * @param session_id
+         * @param displayName
+         * @param tableName
+         */
+        if (req.query.action === 'create_a_table' && req.query?.session_id && req.query?.displayName && req.query?.tableName) {
+            const { success } = getTableAndPlayer(req.query.session_id);
+
+            if (!success) {
+                createTable(req.query.session_id, req.query.displayName, req.query.tableName);
+            }
+
+            res.end();
+        }
+
+        /**
+         * /---------------------- GET ----------------------/
+         * Creates the table and enters the user inside
+         * @action update_state
+         * @param session_id
+         */
+        if (req.query.action === 'update_state' && req.query?.session_id) {
+            const session_id = req.query.session_id;
+
+            const { table, player } = getTableAndPlayer(session_id);
+
+            res.json({
+                success: true,
+                pokerGame: {
+                    tables: getRestrictedTablesArray(),
+                    table: getRestrictedTableArray(table.id, req.query.session_id),
+                    player: player,
+                }
+            })
+        }
+
+        /**
+         * /---------------------- GET ----------------------/
+         * If the player is not in an existing room, create a room for them.
+         * If they are reconnecting, get the room they were in.
+         * @action get_player_info_on_enter
+         * @param session_id
+         */
+        if (req.query.action === 'get_player_info_on_enter' && req.query?.session_id) {
+            const session_id = req.query.session_id;
+
+            axios.get(`${process.env.HOME_URL}/api/postgre?action=check_if_logged_in&session_id=${session_id}`).then(postgreRes => {
+                if (postgreRes.data?.success) {
+                    res.json({
+                        success: true,
+                        displayName: postgreRes.data?.displayName,
+                        session_id: postgreRes.data?.session_id,
+                        credits: postgreRes.data?.credits,
+                    })
+                }
+                else {
+                    res.json({
+                        success: false,
+                    })
+                }
+            });
+        }
+    }
+}
+/**
+ * ********************* END OF REQUEST HANDLER *********************
+ */

pages/api/roulette/index.js

@@ -138 +138 @@
      */
     if (req.method === 'GET') {
-        
         /**
          * /---------------------- GET ----------------------/