import subprocess
 
def start_engine(engine_path):
    """
    该函数启动指定路径的引擎（如 pikafish-bmi2.exe）。
    subprocess.Popen 创建一个新的子进程来运行引擎，并通过 stdin 和 stdout 与进程进行交互。
    stdin=subprocess.PIPE 允许我们向引擎发送命令，stdout=subprocess.PIPE 允许我们读取引擎的输出，text=True 表示输入和输出是文本模式（而不是字节）。
    """
    return subprocess.Popen(engine_path, stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
 
 
def send_command(engine, command):
    """
    该函数向引擎发送命令。
    engine.stdin.write(command + '\n') 将命令写入引擎的标准输入，并加上换行符。
    engine.stdin.flush() 确保命令被及时发送到引擎。
    """
    engine.stdin.write(command + '\n')
    engine.stdin.flush()
 
 
def read_response(engine):
    """
    该函数读取引擎的标准输出并返回引擎的响应。
    engine.stdout.readline().strip() 读取一行输出并去除前后的空白字符。
    如果引擎返回了 'uciok'（表示已成功初始化 UCI 协议），'readyok'（表示引擎准备好），或者以 'bestmove' 开头（表示最佳走法），就退出循环。
    否则，打印引擎的其他输出。
    """
    while True:
        response = engine.stdout.readline().strip()
        if response == 'uciok' or response == 'readyok' or response.startswith('bestmove'):
            break
        print(response)
    return response
 
 
def main():
    # 启动引擎
    engine = start_engine(r'D:\User\Downloads\Pikafish_20240917\pikafish-bmi2.exe')
 
    # 初始化引擎
    send_command(engine, 'uci')
    read_response(engine)
 
    # 设置选项
    send_command(engine, 'setoption name Threads value 4')
    send_command(engine, 'setoption name Hash value 256')
 
    # 确认引擎准备好
    send_command(engine, 'isready')
    read_response(engine)
 
    # 开始新游戏
    send_command(engine, 'ucinewgame')
 
    # 设定初始位置
    send_command(engine, 'position startpos')
 
    # 让引擎思考并走一步
    send_command(engine, 'go movetime 5000')
    best_move = read_response(engine)
    print(f'Best move: {best_move}')
 
    # 关闭引擎
    send_command(engine, 'quit')
    engine.terminate()
 
if __name__ == '__main__':
    main()

using System;
using System.Diagnostics;
using System.Text;
using System.Threading;
using UnityEngine;
using Debug = UnityEngine.Debug;
 
public class PikaFishController : MonoBehaviour
{
    private Process pikaFishProcess;
    public string enginePath { get; set; } = "";  // 替换为你的皮卡鱼路径
    private StringBuilder outputBuffer = new StringBuilder();
 
    public void Init()
    {
        StartEngine();
        InitializeEngine();
    }
 
    private void StartEngine()
    {
        pikaFishProcess = new Process();
        pikaFishProcess.StartInfo.FileName = enginePath;
        pikaFishProcess.StartInfo.UseShellExecute = false;
        pikaFishProcess.StartInfo.RedirectStandardInput = true;
        pikaFishProcess.StartInfo.RedirectStandardOutput = true;
        pikaFishProcess.StartInfo.CreateNoWindow = true;
 
        pikaFishProcess.OutputDataReceived += new DataReceivedEventHandler(OutputHandler);
        pikaFishProcess.Start();
        pikaFishProcess.BeginOutputReadLine();
    }
 
    private void InitializeEngine()
    {
        SendCommand("uci");
        WaitForResponse("uciok");
 
        // 设置线程数和哈希表大小（根据需要调整）
        SendCommand("setoption name Threads value 4");
        SendCommand("setoption name Hash value 256");
 
        SendCommand("isready");
        WaitForResponse("readyok");
 
        SendCommand("ucinewgame");
    }
 
    public void SendCommand(string command)
    {
        if (pikaFishProcess != null && !pikaFishProcess.HasExited)
        {
            pikaFishProcess.StandardInput.WriteLine(command);
        }
    }
 
    private void OutputHandler(object sendingProcess, DataReceivedEventArgs outLine)
    {
        if (!string.IsNullOrEmpty(outLine.Data))
        {
            outputBuffer.AppendLine(outLine.Data);
            Debug.Log(outLine.Data);  // 打印引擎输出到 Unity 控制台
        }
    }
 
    private string WaitForResponse(string keyword, int timeout = 5000)
    {
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
 
        while (stopwatch.ElapsedMilliseconds < timeout)
        {
            if (outputBuffer.ToString().Contains(keyword))
            {
                string response = outputBuffer.ToString();
                outputBuffer.Clear();
                return response;
            }
            Thread.Sleep(100);
        }
 
        Debug.LogError($"Timeout waiting for response containing '{keyword}'");
        return null;
    }
 
    void OnDestroy()
    {
        if (pikaFishProcess != null && !pikaFishProcess.HasExited)
        {
            SendCommand("quit");
            pikaFishProcess.WaitForExit(1000);
            if (!pikaFishProcess.HasExited)
            {
                pikaFishProcess.Kill();
            }
        }
    }
}

using SFB;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
public class FileOpener : MonoBehaviour
{
    public PikaFishController pikaFishController;
    public Text pathText;
    public InputField input;
    public Button SetPathButton;
    public Button SendButton;
 
    private void Start()
    {
        SetPathButton.onClick.AddListener(OnSetPathButton);
        SendButton.onClick.AddListener(OnSendButton);
    }
 
    public void OnSetPathButton()
    {
        Debug.Log("OnSetPathButton()");
        string enginePath = OpenFileAndGetPath();
        pikaFishController.enginePath = enginePath;
        pikaFishController.Init();
        pathText.text = enginePath;
    }
 
    public void OnSendButton()
    {
        pikaFishController.SendCommand(input.text);
    }
 
    private string OpenFileAndGetPath()
    {
        string path = StandaloneFileBrowser.OpenFilePanel("选择文件", "", "exe", false)[0];
 
        // 判断文件是否被选中
        if (!string.IsNullOrEmpty(path))
        {
            return path;  // 返回文件路径
        }
        else
        {
            return "";
        }
    }
}