koishi-plugin-satori-ai 2.2.0 → 2.3.0

package/lib/abstractGame.d.ts

@@ -4,10 +4,18 @@ declare module 'koishi' {
         'game-result'(session: Session, result: gameResult): void;
     }
 }
+export interface gamePlayerResult {
+    playerID: string;
+    name?: string;
+    win: number;
+    bonus: number;
+}
 export interface gameResult {
     playerID: string;
     message: string;
     gameName: string;
+    playerResults?: gamePlayerResult[];
+    cancelled?: boolean;
 }
 /**
  * 单局游戏的抽象基类，提供通用生命周期方法
@@ -16,16 +24,19 @@ export declare abstract class abstractGameSingleGame {
     protected session: Session;
     protected disposeListener: () => boolean;
     protected lastActionTime: number;
+    protected playerIDs: string[];
     constructor(disposeListener: () => boolean, session: Session);
     startGame(): Promise<string>;
-    endGame(): Promise<{
+    endGame(session?: Session): Promise<{
         message: string;
         gameName: string;
         playerID: string;
     }>;
     getPlayerID(): string;
+    getPlayerIDs(): string[];
+    acceptsInput(userId: string): boolean;
     getLastActionTime(): number;
-    processInput(str: string): Promise<string>;
+    processInput(str: string, session?: Session): Promise<string>;
 }
 type Constructor<T> = new (...args: any[]) => T;
 /**

package/lib/api.d.ts

@@ -30,13 +30,10 @@ export declare class APIClient {
     private pruneTicketFailures;
     private ticketAuxiliaryRoute;
     private defaultAuxiliaryRoute;
-    generateUserPortrait(user: User, messages: Sat.Msg[]): Promise<{
-        content: string;
-        error: boolean;
-    }>;
     private createPayload;
     private createAuxiliaryPayload;
     private tryRequest;
+    private sendChat;
     private createHeaders;
     private handleAPIError;
     private rotateKey;

package/lib/favorability.d.ts

@@ -3,6 +3,7 @@ import { User, FavorabilityLevel, FavorabilityConfig } from './types';
 import { MoodManager } from './mood';
 import { Sat } from './types';
 export declare function handleFavorabilitySystem(ctx: Context, session: Session, config: FavorabilityConfig): Promise<string | void>;
+export declare function isFamilyLevel(level: FavorabilityLevel): boolean;
 export declare function getFavorabilityLevel(user: User, config: FavorabilityConfig): FavorabilityLevel;
 export declare function generateLevelPrompt(level: FavorabilityLevel, config: FavorabilityConfig, user: User): string;
 export declare function generateAuxiliaryPrompt(prompt: string, responseContent: string, user: User, config: FavorabilityConfig): Sat.Msg[];

package/lib/game.d.ts

@@ -14,6 +14,7 @@ export declare class Game {
     private GAMES;
     private channelGames;
     private availableGames;
+    private oneTouchPvp;
     private userUsage;
     private context;
     private config;
@@ -21,9 +22,13 @@ export declare class Game {
     constructor(ctx: Context, cfg: Sat.Config, sat: SAT);
     private registerCommands;
     startGame(session: Session, gameName: string, args: string[]): Promise<string>;
+    private startOneTouchPvp;
     endGame(session: Session): Promise<string>;
+    hasActiveGame(channelId: string): boolean;
+    private getGameController;
     private chat;
     private getGameCd;
     private getGameList;
     private resultJudge;
+    private judgePvp;
 }

package/lib/gameOneTouch.d.ts

@@ -1,10 +1,53 @@
 import { Session, Context } from 'koishi';
 import { abstractGame, abstractGameSingleGame, gameResult } from './abstractGame';
 import { winFlag } from './game';
+export declare enum playerStatus {
+    Normal = 0,// 正常状态
+    Stunned = 1,// 眩晕状态
+    lastStunned = 2
+}
+export interface PlayerState {
+    left: number;
+    right: number;
+    hp: number;
+    shield?: number;
+    strength?: number;
+    bleed?: number;
+    counterAttack?: number;
+    vulnerablility?: number;
+    status: playerStatus;
+}
+export interface SkillEffect {
+    name?: string;
+    damage?: number;
+    damageTimes?: number;
+    pierceDamage?: number;
+    heal?: number;
+    shield?: number;
+    bleed?: number;
+    selfbleed?: number;
+    stun?: boolean;
+    destroyShield?: number;
+    weakStun?: boolean;
+    selfStun?: boolean;
+    strengthChange?: number;
+    selfstrengthChange?: number;
+    addSelfLeft?: number;
+    addSelfRight?: number;
+    addLeft?: number;
+    addRight?: number;
+    counterAttack?: number;
+    vulnerablility?: number;
+    magnificentEnd?: boolean;
+    revwersalOfStrength?: boolean;
+}
 export interface OneTouchResult extends gameResult {
     win: winFlag;
     bonus: number;
 }
+export declare const SKILL_MAP: {
+    [key: string]: SkillEffect;
+};
 declare class OneTouchSingleGame extends abstractGameSingleGame {
     private player;
     private ai;
@@ -38,13 +81,17 @@ declare class OneTouchSingleGame extends abstractGameSingleGame {
     private generatePossibleMoves;
     private cloneState;
     private simulateMove;
-    private evaluateState;
     private generateChat;
     private instuction;
     private skillList;
 }
+export declare const ONE_TOUCH_SKILL_LIST: string;
+export declare function resolveCombo(a: number, b: number): SkillEffect | null;
+export declare function applySkillEffect(self: PlayerState, enemy: PlayerState, effect: SkillEffect, isCombo: boolean): void;
+export declare function buildEffectMessage(effect: SkillEffect, isCombo: boolean, self: PlayerState, enemy: PlayerState): string;
 export declare class OneTouchGame extends abstractGame<OneTouchSingleGame> {
     constructor();
     startGame(session: Session, ctx: Context, args: string[]): Promise<OneTouchSingleGame>;
 }
+export declare function wrapInHTML(str: string): Promise<string>;
 export {};

package/lib/gameOneTouchPvp.d.ts

@@ -0,0 +1,46 @@
+import { Session, Context } from 'koishi';
+import { abstractGame, abstractGameSingleGame, gameResult } from './abstractGame';
+/**
+ * 一碰一 1v1 对战单局。双方都是真人，bot 只负责结算规则。
+ */
+export declare class OneTouchPvpSingleGame extends abstractGameSingleGame {
+    private ctx;
+    private players;
+    private maxHp;
+    private turn;
+    private phase;
+    private inviteTimer;
+    private turnTimer;
+    private onFinish;
+    constructor(disposeListener: () => boolean, session: Session, ctx: Context, opponent: {
+        id: string;
+        name?: string;
+    }, maxHp: number, onFinish: () => void);
+    private createPlayer;
+    private initState;
+    startGame(): Promise<string>;
+    processInput(input: string, session?: Session): Promise<string>;
+    private startBattle;
+    private render;
+    private executeTurn;
+    private buildTurnText;
+    private formatStatus;
+    private buildAttackerBonus;
+    private buildDefenderBonus;
+    private settleTurnBonus;
+    private clearTurnTimer;
+    private clearTimers;
+    private resetTurnTimer;
+    private settle;
+    private abort;
+    private finish;
+    endGame(session?: Session): Promise<gameResult>;
+    private rules;
+}
+/**
+ * 一碰一 对战控制器：负责邀请、双方消息转发与单局生命周期。
+ */
+export declare class OneTouchPvpGame extends abstractGame<OneTouchPvpSingleGame> {
+    constructor();
+    startGame(session: Session, ctx: Context, args: string[]): Promise<abstractGameSingleGame | null>;
+}

package/lib/index.d.ts

@@ -3,6 +3,7 @@ import { Sat, User } from './types';
 import Puppeteer from 'koishi-plugin-puppeteer';
 import { BroadcastManager } from './broadcast';
 import { WeatherManager } from './weather';
+import { ProactiveManager } from './proactive';
 export declare let puppeteer: Puppeteer | null;
 export declare function refreshPuppeteer(ctx: Context): void;
 export declare class SAT extends Sat {
@@ -14,6 +15,7 @@ export declare class SAT extends Sat {
     private moodManager;
     broadcastManager: BroadcastManager;
     weatherManager: WeatherManager;
+    proactive: ProactiveManager;
     private usersToWarn;
     private puppeteer;
     private game;
@@ -44,11 +46,18 @@ export declare class SAT extends Sat {
         error: boolean;
         reasoning_content?: string;
     }>;
-    getChatResponse(user: User, messages: Sat.Msg[], prompt: string): Promise<{
+    getChatResponse(user: User, messages: Sat.Msg[], prompt: string, session?: Session): Promise<{
         content: string;
         error: boolean;
         reasoning_content?: string;
     }>;
+    /**
+     * 生成一条主动消息（不写入长期记忆，不扣使用次数）。
+     * idleMinutes 用于告诉模型沉默时长；queryHint 用用户最后一句做记忆检索。
+     */
+    generateProactive(session: Session, idleMinutes: number, queryHint?: string): Promise<string>;
+    /** 主动消息成功后由发送方调用，只写短期记忆 */
+    recordProactive(session: Session, content: string): void;
     private buildMessages;
     private buildSystemPrompt;
     private getThinkingPrompt;
@@ -60,9 +69,14 @@ export declare class SAT extends Sat {
     addGroupCommonSense(session: Session, content: string, groupId: string): Promise<string>;
     private handleUserLevel;
     private handleUserUsage;
+    isGameActive(session: Session): boolean;
     handleRandomMiddleware(session: Session): Promise<string>;
+    /** 群聊环境里代表 bot 自己的名字：昵称列表第一个加「（你）」，让模型能分辨这是自己的发言 */
+    private getSelfDialogueName;
     handleNickNameMiddleware(session: Session, prompt: string): Promise<string>;
     handleChannelMemoryManager(session: Session): Promise<void>;
+    private handleDigest;
+    private renderDigestCard;
     dispose(): Promise<void>;
 }
 export default SAT;