Basic Codey Connect4 AI created

Author: davidgan1218

src/components/games/connectFour.ts

@@ -11,10 +11,15 @@ import { openDB } from '../db';
 import { CodeyUserError } from '../../codeyUserError';
 import { getEmojiByName } from '../emojis';
 import { getRandomIntFrom1 } from '../../utils/num';
+import { isNull } from 'lodash';
 
 const CONNECT_FOUR_COLUMN_COUNT = 7;
 const CONNECT_FOUR_ROW_COUNT = 6;
 
+const TWO_IN_A_ROW_WEIGHT = 1;
+const THREE_IN_A_ROW_WEIGHT = 3;
+
+
 class ConnectFourGameTracker {
   // Key = id, Value = game
   games: Map<number, ConnectFourGame>;
@@ -247,6 +252,7 @@ export class ConnectFourGame {
     state: ConnectFourGameState,
     columnIndex: number,
   ): Promise<ConnectFourGameStatus> {
+
     // Instead of exhaustively checking every combination of tokens we can simply use the fact that
     //  as of this point the user hasn't won yet, so we just need to check if the token that was just placed
     //  is part of a winning combination
@@ -395,6 +401,152 @@ ${this.state.player2Username}: ${getEmojiFromSign(this.state.player2Sign)}
       components: this.state.status === ConnectFourGameStatus.Pending ? [row1, row2] : [],
     };
   }
+
+  // ConnectFourGameState
+  // Waiting = 0,
+  // Pending = 1,
+  // Draw = 2,
+  // Player1Win = 3,
+  // Player2Win = 4,
+  // Player1TimeOut = 5,
+  // Player2TimeOut = 6,
+  // Unknown = 7,
+  private updateState = (state : ConnectFourGameState, columnNumber : number, turn : number): ConnectFourGameState => {
+    const fill : number = state.columns[columnNumber].fill;
+    if (turn === 1){ //means its Codeybot's turn
+      state.columns[columnNumber].tokens[fill] = 3;
+    } else{
+      state.columns[columnNumber].tokens[fill] = 2;
+    }
+    state.columns[columnNumber].fill = state.columns[columnNumber].fill + 1;
+    return state;
+  }
+
+  // returns number of possible wins remaining
+  private possibleWins = (state : ConnectFourGameState, opponentSign : number): number => {
+    let possibleWins : number = 0;
+    // check vertical
+    for (let i  = 0; i < CONNECT_FOUR_COLUMN_COUNT; i++){
+      for (let j = 3; j < CONNECT_FOUR_ROW_COUNT; j++){
+        if (state.columns[i].tokens[j] !== opponentSign && state.columns[i].tokens[j-1] !== opponentSign && state.columns[i].tokens[j-2] !== opponentSign && state.columns[i].tokens[j-3] !== opponentSign){
+          possibleWins = possibleWins + 1;
+        }
+      }
+    }
+    // check horizonal
+    for (let j = 0; j < CONNECT_FOUR_ROW_COUNT; j++){
+      for (let i = 3; i < CONNECT_FOUR_COLUMN_COUNT; i++){
+        if (state.columns[i].tokens[j] !== opponentSign && state.columns[i-1].tokens[j] !== opponentSign && state.columns[i-2].tokens[j] !== opponentSign && state.columns[i-3].tokens[j] !== opponentSign){
+          possibleWins = possibleWins + 1;
+        }
+      }
+    }
+    // check diagonal up
+    for (let i = 0; i <= 3; i++){
+      for (let j = 0; j <= 2; j++){
+        if (state.columns[i].tokens[j] !== opponentSign && state.columns[i+1].tokens[j+1] !== opponentSign && state.columns[i+2].tokens[j+2] !== opponentSign && state.columns[i+3].tokens[j+3] !== opponentSign){
+          possibleWins = possibleWins + 1;
+        }
+      }
+    }
+
+    //check diagonal down
+    for (let i = 3; i < CONNECT_FOUR_COLUMN_COUNT; i++){
+      for (let j = 0; j <= 2; j++){
+        if (state.columns[i].tokens[j] !== opponentSign && state.columns[i-1].tokens[j+1] !== opponentSign && state.columns[i-2].tokens[j+2] !== opponentSign && state.columns[i-3].tokens[j+3] !== opponentSign){
+          possibleWins = possibleWins + 1;
+        }
+      }
+    }
+    return possibleWins;
+  }
+
+  // takes a ConnectFourGameState and evaluates it according to heuristic function
+  private evaluate = (state : ConnectFourGameState): number => {
+    let codeyPoints : number = this.possibleWins(state, 2); // 3 represents Codeybot sign
+    let opponentPoints : number = this.possibleWins(state, 3); // 2 represents player1 sign
+    return codeyPoints - opponentPoints;
+  }
+
+// from perspective of Codeybot, +infinity means Codeybot win, -infinity means Player1 wins
+// turn = 1, means it's Codeybot's turn, turn = -1 means it's opponent's turn
+// returns the best possible score that can be achieved, given that Player1 plays optimally
+  private miniMax = (state : ConnectFourGameState, depth : number, turn : number): number =>{
+    if (state.status === 2){ // means draw
+      return 0;
+    }
+    if (state.status === 3){ // means Player1 wins
+      return -Infinity;
+    }
+    if (state.status === 4){ // means Player 2 wins
+      return Infinity;
+    }
+    if (depth === 0){
+      return this.evaluate(state); //heuristic function to evaluate state of game
+    }
+
+    // if it is Codeybot's turn, we want to find move that maximizes score
+    if (turn === 1){
+      let value : number = -Infinity;
+      const column_choices : number[] = [0, 1, 2, 3, 4, 5, 6];
+      for (const column_choice of column_choices){
+        if (state.columns[column_choice].fill < CONNECT_FOUR_ROW_COUNT){
+          let newState : ConnectFourGameState = JSON.parse(JSON.stringify(state));
+          this.updateState(newState, column_choice, turn);
+          this.setStatus(newState, column_choice);
+          value = Math.max(value, this.miniMax(newState, depth - 1, turn * -1));
+        }
+      }
+      return value;
+    } else { // (turn = -1) it is Player 1's turn, so we want to find minimum score (this assumes Player 1 plays optimally)
+      let value : number = Infinity;
+      const column_choices : number[] = [0, 1, 2, 3, 4, 5, 6];
+      for (const column_choice of column_choices){
+        // if selected column is not already full, recurse down the branch
+        if (state.columns[column_choice].fill < CONNECT_FOUR_ROW_COUNT){
+          let newState : ConnectFourGameState = JSON.parse(JSON.stringify(state));
+          this.updateState(newState, column_choice, turn);
+          this.setStatus(newState, column_choice);
+          value = Math.min(value, this.miniMax(newState, depth - 1, turn * -1));
+        }
+      }
+      return value;
+    }
+  }
+
+  private findBestColumn = (state : ConnectFourGameState): number =>{
+    let column_scores : number[] = [-Infinity, -Infinity, -Infinity, -Infinity, -Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < 7; i++){
+      if (state.columns[i].fill < CONNECT_FOUR_ROW_COUNT){
+        let newState : ConnectFourGameState = JSON.parse(JSON.stringify(state)); // make a deep copy of game state
+        this.updateState(newState, i, 1);
+        this.setStatus(newState, i);
+        column_scores[i] = this.miniMax(newState, 4, -1);
+      } 
+    }
+    let value = -Infinity;
+    let best_column = -1;
+    for (let i = 0; i < 7; i++){
+      if (column_scores[i] > value){
+        value = column_scores[i];
+        best_column = i;
+      } 
+    }
+    // if best_column = -1, then that means all posible moves lead to certain loss
+    if (best_column === -1){
+      for (let i = 0; i < 7; i++){
+        if (state.columns[i].fill < CONNECT_FOUR_ROW_COUNT){
+          return i;
+        }
+      }
+    } 
+    return best_column;
+  } 
+
+// takes in ConnectFourGameState, returns best column for Codeybot to play in
+  public getBestMove = (state : ConnectFourGameState): number => {
+    return this.findBestColumn(state);
+  };
 }
 
 export enum ConnectFourGameStatus {
@@ -467,9 +619,9 @@ export const getStateAsString = (state: ConnectFourGameState): string => {
   return result;
 };
 
-export const getCodeyConnectFourSign = (): ConnectFourGameSign => {
-  return getRandomIntFrom1(7);
-};
+// export const getCodeyConnectFourSign = (): ConnectFourGameSign => {
+//   return getRandomIntFrom1(7);
+// };
 
 export const updateColumn = (column: ConnectFourColumn, sign: ConnectFourGameSign): boolean => {
   const fill: number = column.fill;

src/interaction-handlers/games/connectFour.ts

@@ -3,7 +3,6 @@ import { Option } from '@sapphire/result';
 import { ButtonInteraction } from 'discord.js';
 import { getEmojiByName } from '../../components/emojis';
 import {
-  getCodeyConnectFourSign,
   ConnectFourGameStatus,
   ConnectFourGameSign,
   connectFourGameTracker,
@@ -62,16 +61,19 @@ export class ConnectFourHandler extends InteractionHandler {
         const status = await game.setStatus(game.state, result.sign - 1);
         if (status == ConnectFourGameStatus.Pending) {
           if (!game.state.player2Id) {
-            let codeySign = getCodeyConnectFourSign();
-            while (!updateColumn(game.state.columns[codeySign - 1], game.state.player2Sign)) {
-              codeySign = getCodeyConnectFourSign();
-            }
-            game.setStatus(game.state, codeySign - 1);
+            let bestMove = game.getBestMove(game.state);
+            // while (!updateColumn(game.state.columns[codeySign - 1], game.state.player2Sign)) {
+            //   codeySign = getCodeyConnectFourSign(game.state);
+            // }
+            updateColumn(game.state.columns[bestMove], game.state.player2Sign);
+            game.setStatus(game.state, bestMove);
+            
           }
         }
       }
       updateMessageEmbed(game.gameMessage, game.getGameResponse());
     });
+
     connectFourGameTracker.endGame(result.gameId);
   }
 }