koishi-plugin-satori-ai 1.2.11 → 1.3.0

package/lib/abstractGame.d.ts

@@ -15,11 +15,11 @@ export declare abstract class abstractGameSingleGame {
     protected session: Session;
     protected disposeListener: () => boolean;
     constructor(disposeListener: () => boolean, session: Session);
-    startGame(): string;
-    endGame(): {
+    startGame(): Promise<string>;
+    endGame(): Promise<{
         message: string;
         gameName: string;
-    };
+    }>;
     processInput(str: string): Promise<string>;
 }
 type Constructor<T> = new (...args: any[]) => T;
@@ -43,10 +43,10 @@ export declare abstract class abstractGame<T extends abstractGameSingleGame> {
      * @param ctx Koishi 上下文
      * @param args 启动参数（如难度等级）
      */
-    startGame(session: Session, ctx: Context, args: string[]): abstractGameSingleGame | null;
+    startGame(session: Session, ctx: Context, args: string[]): Promise<abstractGameSingleGame | null>;
     /**
      * 结束游戏实例，触发结果事件
      */
-    endGame(session: Session, ctx: Context): string;
+    endGame(session: Session, ctx: Context): Promise<string>;
 }
 export {};

package/lib/game.d.ts

@@ -13,7 +13,7 @@ export declare class Game {
     private sat;
     constructor(ctx: Context, cfg: Sat.Config, sat: SAT);
     private registerCommands;
-    startGame(session: Session, gameName: string, args: string[]): Promise<"当前频道已经有游戏在进行中" | "没有这个游戏哦">;
+    startGame(session: Session, gameName: string, args: string[]): Promise<string>;
     endGame(session: Session): Promise<string>;
     private selectGame;
     private chat;

package/lib/gamefencing.d.ts

@@ -1 +1,36 @@
+import { Session } from 'koishi';
+import { abstractGame, abstractGameSingleGame, gameResult } from './abstractGame';
+export declare enum winFlag {
+    win = 1,
+    lose = 2,
+    draw = 3,
+    pending = 4
+}
+export interface fencingGameResult extends gameResult {
+    win: winFlag;
+}
+declare enum fencingAction {
+    attack = 1,
+    defence = 2
+}
+declare class fencingSingleGame extends abstractGameSingleGame {
+    private winningFlag;
+    private playerPosition;
+    private enemyPosition;
+    private availablePlayerActions;
+    static fencingActionHint: Map<fencingAction, string>;
+    constructor(disposeListener: () => boolean, session: Session);
+    private render;
+    startGame: () => Promise<string>;
+    endGame: () => Promise<{
+        message: string;
+        win: winFlag;
+        gameName: string;
+    }>;
+    private enemyDecision;
+    processInput(str: string): Promise<string>;
+}
+export declare class fencing extends abstractGame<fencingSingleGame> {
+    constructor();
+}
 export {};

package/lib/gamegobang.d.ts

@@ -8,7 +8,7 @@ export declare enum winFlag {
 }
 export interface goBangGameResult extends gameResult {
     win: winFlag;
-    level: number;
+    message: string;
 }
 /**
  * 五子棋单局实现类，继承自 abstractGameSingleGame
@@ -18,27 +18,32 @@ declare class goBangSingleGame extends abstractGameSingleGame {
     private winningFlag;
     level: number;
     private board;
+    private lastScore;
+    private turnsCount;
     constructor(disposeListener: () => boolean, session: Session);
-    startGame: () => string;
-    endGame: () => {
+    startGame: () => Promise<string>;
+    endGame: () => Promise<{
         message: string;
         win: winFlag;
         gameName: string;
-    };
+    }>;
     /**
      * 处理玩家输入（落子坐标）
      * @param str 输入内容，格式为 "x y"
      */
     processInput(str: string): Promise<string>;
+    private getAIMove;
     private checkWin;
     private checkDirection;
+    private place;
     private printBoard;
+    private generateChat;
 }
 /**
  * 五子棋管理类，继承自 abstractGame
  */
 export declare class goBang extends abstractGame<goBangSingleGame> {
     constructor();
-    startGame(session: Session, ctx: Context, args: string[]): goBangSingleGame;
+    startGame(session: Session, ctx: Context, args: string[]): Promise<goBangSingleGame>;
 }
 export {};

package/{wasm → lib}/gobang.cpp

@@ -1,23 +1,17 @@
-// emcc gobang.cpp -O3 -s EXPORTED_FUNCTIONS="['_decideMove', '_malloc', '_free']" -s MODULARIZE=1 -s ENVIRONMENT='node' -o gobang.js
-
+// 使用DEV-C++编译器编译
 #define _CRT_SECURE_NO_WARNINGS
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <string>
+#include <iostream>
+#include <sstream>
 #define BOARD_SIZE 12    // 棋盘大小
 #define EMPTY 0          // 空位
 #define BLACK 1          // 黑棋
 #define WHITE 2          // 白棋
 #define INF 2147483647   // 正无穷
 #define _INF -2147483647 // 负无穷
-#define DEPTH 5          // 搜索深度
-#define START "START"    // 开始游戏
-#define PLACE "PLACE"    // 放置棋子
-#define TURN "TURN"      // 轮到我方下棋
-#define END "END"        // 游戏结束
-const int BOARD_MIDDLE_1 = (BOARD_SIZE + 1) / 2 - 1;
-const int BOARD_MIDDLE_2 = BOARD_SIZE / 2;
 struct chessType {
     int win5;   // 连五
     int alive4; // 活4
@@ -29,7 +23,6 @@ struct chessType {
     int conti2; // 眠2
     int jump2;  // 跳2
     int alive1; // 活1
-    int conti1; // 眠1
 };
 // 坐标结构体
 struct coordinate {
@@ -43,31 +36,19 @@ struct coordinate {
 struct Nude {
     int board[BOARD_SIZE][BOARD_SIZE] = {{0}}; // 棋盘状态
     int state = 0;                             // 棋盘状态标识
-    Nude() {
-        // 初始化棋盘，放置初始棋子
-        board[BOARD_MIDDLE_1][BOARD_MIDDLE_1] = WHITE;
-        board[BOARD_MIDDLE_2][BOARD_MIDDLE_2] = WHITE;
-        board[BOARD_MIDDLE_2][BOARD_MIDDLE_1] = BLACK;
-        board[BOARD_MIDDLE_1][BOARD_MIDDLE_2] = BLACK;
-    }
-    void arr_input(int x, int y, int playerround) {
-        board[x][y] = playerround; // 在指定位置放置棋子
-    }
+    Nude() {}
 };
 class Game {
 public:
     int myFlag;
     int enemyFlag;
+    int inspireSearchLength;
     bool draw;
     Nude MAP;
     Game() :
-            myFlag(0), enemyFlag(0), draw(0) {}
+      myFlag(0), enemyFlag(0), draw(0) {}
 };
-// Game game;
-void debug(const char *str) {
-    printf("DEBUG %s\n", str);
-    fflush(stdout);
-}
+
 // 判断坐标是否在棋盘范围内
 bool judgeInRange(coordinate temp) {
     if (temp.x < 0)
@@ -87,9 +68,10 @@ int getColor(coordinate target, const Game &game) {
     else
         return game.enemyFlag;
 }
+
 // 在指定位置放置棋子
 void place(coordinate target, int player, Game &game) {
-    game.MAP.board[target.x][target.y] = player;
+  game.MAP.board[target.x][target.y] = player;
 }
 // 快速排序函数
 int partition(coordinate *s, int high, int low) {
@@ -109,6 +91,7 @@ int partition(coordinate *s, int high, int low) {
     return i;
 }
 void quickSort(coordinate *s, int high, int low = 0) {
+    if (high < 0) return;
     if (low < high) {
         int pi = partition(s, high, low);
         quickSort(s, pi - 1, low);
@@ -388,8 +371,7 @@ chessType typeAnalysis(coordinate p, int dire, int player, const Game &game) {
                         else if (b[3] == 0)
                             temp.conti2++; // 001012xxx
                     }
-                } else
-                    temp.conti1++; // xxx012xxx
+                }
             }
         } else {
             if (b[4] == 0) {
@@ -414,8 +396,6 @@ chessType typeAnalysis(coordinate p, int dire, int player, const Game &game) {
                     } else if (b[6] == 0) {
                         if (b[7] == player)
                             temp.conti2++; // xxx210001
-                        else if (b[7] == 0)
-                            temp.conti1++; // xxx210000
                     }
                 }
             }
@@ -426,9 +406,9 @@ chessType typeAnalysis(coordinate p, int dire, int player, const Game &game) {
 // 单点得分
 int singleScore(coordinate p, int player, const Game &game) {
     chessType chesstype = typeAnalysis(p, 0, player, game);
+    int score = 0;
     for (int i = 1; i < 4; i++) {
-        chessType temp;
-        temp = typeAnalysis(p, i, player, game);
+        chessType temp = typeAnalysis(p, i, player, game);
         chesstype.win5 += temp.win5;
         chesstype.alive4 += temp.alive4;
         chesstype.conti4 += temp.conti4;
@@ -439,16 +419,12 @@ int singleScore(coordinate p, int player, const Game &game) {
         chesstype.conti2 += temp.conti2;
         chesstype.jump2 += temp.jump2;
         chesstype.alive1 += temp.alive1;
-        chesstype.conti1 += temp.conti1;
     }
-    if (chesstype.win5) // 胜
-        return 1048576;
-    int score = ((chesstype.conti4 << 12) +
-                 (chesstype.alive3 << 12) + (chesstype.conti3 << 8) + (chesstype.jump3 << 10) +
-                 (chesstype.alive2 << 8) + (chesstype.conti2 << 3) + (chesstype.jump2 << 6) +
-                 (chesstype.alive1 << 3) + chesstype.conti1);
-    if (chesstype.alive3 >= 2 || (chesstype.conti4 && chesstype.alive3) || chesstype.alive4 || chesstype.conti4 >= 2) // 必胜?
-        score += 65536;
+    score += chesstype.win5 << 20;
+    score += ((chesstype.conti4 << 9) + (chesstype.alive3 << 8) + (chesstype.conti3 << 7) +
+              (chesstype.jump3 << 6) + (chesstype.alive2 << 5) + (chesstype.jump2 << 3) + chesstype.conti2 + chesstype.alive1);
+    if (chesstype.alive3 > 1 || (chesstype.conti4 && chesstype.alive3) || chesstype.alive4 || chesstype.conti4 > 1) // 必胜?
+        score += (1 << 12);
     return score;
 }
 // 棋盘整体局面分
@@ -474,10 +450,9 @@ int inspireSearch(coordinate *scoreBoard, int player, Game &game) {
         for (int j = 0; j < BOARD_SIZE; j++) {
             if (game.MAP.board[i][j] == 0) {
                 coordinate temp = {i, j, 0};
-                if (hasNeighbor(temp, 3, game)) {
+                if (hasNeighbor(temp, 2, game)) {
                     scoreBoard[length] = temp;
-                    scoreBoard[length].score = singleScore(temp, 3 - player, game);
-                    scoreBoard[length].score += singleScore(temp, player, game);
+                    scoreBoard[length].score = singleScore(temp, 3 - player, game) + singleScore(temp, player, game);
                     length++;
                 }
             }
@@ -487,7 +462,7 @@ int inspireSearch(coordinate *scoreBoard, int player, Game &game) {
     quickSort(scoreBoard, length - 1);
     // 找到最高分数
     int maxScore = scoreBoard[0].score;
-    if (maxScore < 5)
+    if (maxScore < 5 || length == 0)
         game.draw = 1;
     const int threshold = maxScore / 3;
     // 找到分界线
@@ -501,8 +476,9 @@ int inspireSearch(coordinate *scoreBoard, int player, Game &game) {
     // 更新 length 为分界线的位置
     length = boundary;
     // 返回 length，最多不超过
-    return length > 10 ? 10 : length;
+    return length > game.inspireSearchLength ? game.inspireSearchLength : length;
 }
+
 // 负极大极小值搜索
 coordinate alphaBeta(int depth, int alpha, int beta, int player, coordinate command, coordinate current, Game &game) {
     coordinate temp = command;
@@ -512,9 +488,7 @@ coordinate alphaBeta(int depth, int alpha, int beta, int player, coordinate comm
     }
     coordinate steps[BOARD_SIZE * BOARD_SIZE];
     int length = inspireSearch(steps, player, game); // 搜索可落子点
-    if (length > 7 && depth > 1)
-        depth--;
-    else if (length > 2)
+    if (length > 2)
         depth--;
     for (int i = 0; i < length; i++) {
         place(steps[i], player, game);                                               // 模拟落子
@@ -554,39 +528,29 @@ coordinate entrance(int depth, int alpha, int beta, int player, coordinate comma
     return best;
 }
 
-/*
-  * @param board: 棋盘状态
-  * @param myFlag: 我方棋子颜色
-  * @param depth: 搜索深度
-  * @return: 返回落子位置
-  * @outX: 落子横坐标指针
-  * @outY: 落子纵坐标指针
-  * @outScore: 落子分数指针
-  * outX: 落子横坐标
-  * outY: 落子纵坐标
-  * outScore: 落子分数
-  * -1: 游戏平局
-  */
-extern "C" void decideMove(const int board[BOARD_SIZE * BOARD_SIZE], int myFlag, int depth, int* outX, int* outY, int* outScore) {
-    Game localGame;
-    for (int i = 0; i < BOARD_SIZE; i++) {
-        for (int j = 0; j < BOARD_SIZE; j++) {
-            localGame.MAP.board[i][j] = board[i * BOARD_SIZE + j];
-        }
-    }
-    localGame.myFlag = myFlag;
-    localGame.enemyFlag = 3 - myFlag;
-    localGame.draw = 0;
+coordinate calculateNextMove(const std::string& boardStr, int playerFlag, int difficulty, int inspireSearchLength) {
+  Game game;
+  game.myFlag = playerFlag;
+  game.enemyFlag = 3 - playerFlag;
+  game.inspireSearchLength = inspireSearchLength;
+  // 解析棋盘字符串
+  std::istringstream iss(boardStr);
+  for(int i=0; i<BOARD_SIZE; ++i)
+      for(int j=0; j<BOARD_SIZE; ++j)
+          iss >> game.MAP.board[i][j];
 
-    coordinate cmd, current;
-    coordinate result = entrance(depth, _INF, INF, localGame.myFlag, cmd, current, localGame);
-    if (localGame.draw) {
-        *outX = -1;
-        *outY = -1;
-        *outScore = -1;
-        return;
-    }
-    *outX = result.x;
-    *outY = result.y;
-    *outScore = result.score;
+  int depth = difficulty + 1;
+  coordinate best = entrance(depth, _INF, INF, game.myFlag, coordinate(), coordinate(), game);
+  if (game.draw) {
+      best.x = -1;
+      best.y = -1;
+      best.score = -1;
+  }
+  return best;
+}
+
+int main(int argc, char* argv[]) {
+  coordinate result = calculateNextMove(argv[1], atoi(argv[2]), atoi(argv[3]), atoi(argv[4]));
+  std::cout << result.x << " " << result.y << " " << result.score;
+  return 0;
 }

package/lib/index.d.ts

@@ -1,5 +1,7 @@
 import { Context, Session } from 'koishi';
 import { Sat, User } from './types';
+import Puppeteer from 'koishi-plugin-puppeteer';
+export declare let puppeteer: Puppeteer | null;
 export declare class SAT extends Sat {
     config: Sat.Config;
     private apiClient;