RMJ 发表于 2026-5-10 19:57:02

Python搭建智能体测试

本帖最后由 RMJ 于 2026-5-10 20:47 编辑

本方案是AI给的,格式正确,没有编译测试,也知道智能体怎么回事了,这是我好奇问了AI搞出来的,希望厉害的大佬们发发力,做个火山的案例名字是PLC,实际是火山技能


pip install chromadb langchain langchain-community sentence-transformers openai









RMJ 发表于 2026-5-10 20:37:57

<火山程序 类型 = "通常" 版本 = 1 />

包 打地鼠游戏

类 打地鼠游戏类 <公开 基础类 = 窗口类>
{
    变量 游戏状态 <类型 = 整数>
    变量 得分 <类型 = 整数>
    变量 最高分 <类型 = 整数>
    变量 剩余时间 <类型 = 整数>
    变量 命中次数 <类型 = 整数>
    变量 错过次数 <类型 = 整数>
    变量 游戏计时器 <类型 = 整数>
    变量 地鼠计时器 <类型 = 整数>
    变量 地洞数组 <类型 = 地洞信息类 [] 值 = { 9 }>
    变量 游戏进行中 <类型 = 逻辑型>
    变量 游戏结束 <类型 = 逻辑型>

    方法 初始化组件 <公开>
    {
      本对象.标题 = "打地鼠游戏"
      本对象.宽度 = 800
      本对象.高度 = 600
      本对象.背景颜色 = 颜色类.浅绿色

      初始化地洞 ()
      重置游戏 ()
    }

    方法 初始化地洞 <公开>
    {
      变量 行 <类型 = 整数>
      变量 列 <类型 = 整数>
      变量 索引 <类型 = 整数>
      变量 起始X <类型 = 整数>
      变量 起始Y <类型 = 整数>

      起始X = (800 - (4 * 120)) / 2 + 60
      起始Y = (600 - (3 * 120)) / 2 + 60

      计次循环 (行 = 0 到 2)
      {
            计次循环 (列 = 0 到 3)
            {
                索引 = 行 * 4 + 列
                地洞数组 [索引].X坐标 = 起始X + 列 * 120
                地洞数组 [索引].Y坐标 = 起始Y + 行 * 120
                地洞数组 [索引].有地鼠 = 假
                地洞数组 [索引].出现时间 = 0
            }
      }
    }

    方法 重置游戏 <公开>
    {
      得分 = 0
      命中次数 = 0
      错过次数 = 0
      剩余时间 = 30
      游戏进行中 = 假
      游戏结束 = 假
      游戏状态 = 0

      变量 计次 <类型 = 整数>
      计次循环 (计次 = 0 到 8)
      {
            地洞数组 [计次].有地鼠 = 假
            地洞数组 [计次].出现时间 = 0
      }

      如果 (游戏计时器 > 0)
      {
            停止时钟 (游戏计时器)
            游戏计时器 = 0
      }

      如果 (地鼠计时器 > 0)
      {
            停止时钟 (地鼠计时器)
            地鼠计时器 = 0
      }

      刷新显示 ()
    }

    方法 开始游戏 <公开>
    {
      重置游戏 ()
      游戏进行中 = 真
      游戏状态 = 1
      游戏计时器 = 启动时钟 (1000, 本对象, 更新计时器)
      地鼠计时器 = 启动时钟 (1500, 本对象, 生成地鼠)
      刷新显示 ()
    }

    方法 更新计时器 <公开>
    {
      如果 (游戏进行中 = 假)
      {
            返回
      }

      剩余时间 = 剩余时间 - 1

      如果 (剩余时间 <= 0)
      {
            剩余时间 = 0
            游戏结束 ()
      }

      刷新显示 ()
    }

    方法 生成地鼠 <公开>
    {
      如果 (游戏进行中 = 假)
      {
            返回
      }

      变量 空位数组 <类型 = 整数 []>
      变量 计次 <类型 = 整数>
      变量 随机索引 <类型 = 整数>

      计次循环 (计次 = 0 到 8)
      {
            如果 (地洞数组 [计次].有地鼠 = 假)
            {
                空位数组.添加成员 (计次)
            }
      }

      如果 (空位数组.取成员数 () > 0)
      {
            随机索引 = 取随机数 (0, 空位数组.取成员数 () - 1)
            地洞数组 [空位数组 [随机索引]].有地鼠 = 真
            地洞数组 [空位数组 [随机索引]].出现时间 = 取启动时间 ()
      }

      刷新显示 ()
    }

    方法 游戏结束 <公开>
    {
      游戏进行中 = 假
      游戏结束 = 真
      游戏状态 = 2

      如果 (游戏计时器 > 0)
      {
            停止时钟 (游戏计时器)
            游戏计时器 = 0
      }

      如果 (地鼠计时器 > 0)
      {
            停止时钟 (地鼠计时器)
            地鼠计时器 = 0
      }

      如果 (得分 > 最高分)
      {
            最高分 = 得分
      }

      刷新显示 ()
    }

    方法 处理鼠标点击 <公开 参数类型 = 鼠标事件类>
    {
      如果 (游戏进行中 = 假)
      {
            返回
      }

      变量 计次 <类型 = 整数>
      变量 点击X <类型 = 整数>
      变量 点击Y <类型 = 整数>
      变量 距离 <类型 = 整数>

      点击X = 参数.横坐标
      点击Y = 参数.纵坐标

      计次循环 (计次 = 0 到 8)
      {
            如果 (地洞数组 [计次].有地鼠 = 真)
            {
                距离 = (点击X - 地洞数组 [计次].X坐标) * (点击X - 地洞数组 [计次].X坐标) +
                        (点击Y - 地洞数组 [计次].Y坐标) * (点击Y - 地洞数组 [计次].Y坐标)

                如果 (距离 <= 1600) // 40 * 40
                {
                  地洞数组 [计次].有地鼠 = 假
                  得分 = 得分 + 10
                  命中次数 = 命中次数 + 1
                  刷新显示 ()
                  返回
                }
            }
      }
    }

    方法 处理键盘按下 <公开 参数类型 = 键事件类>
    {
      如果 (参数.键代码 = 键代码.空格键)
      {
            如果 (游戏状态 = 0 或 游戏状态 = 2)
            {
                开始游戏 ()
            }
      }
    }

    方法 刷新显示 <公开>
    {
      本对象.清除绘图 ()

      绘制背景 ()
      绘制地洞 ()
      绘制地鼠 ()
      绘制信息 ()

      本对象.刷新 ()
    }

    方法 绘制背景 <公开>
    {
      本对象.画填充矩形 (0, 0, 800, 600, 颜色类.浅绿色)
    }

    方法 绘制地洞 <公开>
    {
      变量 计次 <类型 = 整数>

      计次循环 (计次 = 0 到 8)
      {
            本对象.画填充椭圆 (
                地洞数组 [计次].X坐标 - 40,
                地洞数组 [计次].Y坐标 - 40,
                地洞数组 [计次].X坐标 + 40,
                地洞数组 [计次].Y坐标 + 40,
                颜色类.黑色
            )

            本对象.画椭圆 (
                地洞数组 [计次].X坐标 - 40,
                地洞数组 [计次].Y坐标 - 40,
                地洞数组 [计次].X坐标 + 40,
                地洞数组 [计次].Y坐标 + 40,
                颜色类.深**,
                3
            )
      }
    }

    方法 绘制地鼠 <公开>
    {
      变量 计次 <类型 = 整数>

      计次循环 (计次 = 0 到 8)
      {
            如果 (地洞数组 [计次].有地鼠 = 真)
            {
                变量 地鼠X <类型 = 整数>
                变量 地鼠Y <类型 = 整数>

                地鼠X = 地洞数组 [计次].X坐标
                地鼠Y = 地洞数组 [计次].Y坐标 - 5

                // 身体
                本对象.画填充椭圆 (
                  地鼠X - 35,
                  地鼠Y - 35,
                  地鼠X + 35,
                  地鼠Y + 35,
                  颜色类.棕色
                )

                // 眼睛
                本对象.画填充椭圆 (
                  地鼠X - 20,
                  地鼠Y - 20,
                  地鼠X - 4,
                  地鼠Y - 10,
                  颜色类.白色
                )
                本对象.画填充椭圆 (
                  地鼠X + 4,
                  地鼠Y - 20,
                  地鼠X + 20,
                  地鼠Y - 10,
                  颜色类.白色
                )
                本对象.画填充椭圆 (
                  地鼠X - 16,
                  地鼠Y - 16,
                  地鼠X - 8,
                  地鼠Y - 14,
                  颜色类.黑色
                )
                本对象.画填充椭圆 (
                  地鼠X + 8,
                  地鼠Y - 16,
                  地鼠X + 16,
                  地鼠Y - 14,
                  颜色类.黑色
                )

                // 鼻子
                本对象.画填充椭圆 (
                  地鼠X - 5,
                  地鼠Y - 10,
                  地鼠X + 5,
                  地鼠Y - 2,
                  颜色类.粉红色
                )

                // 耳朵
                本对象.画填充椭圆 (
                  地鼠X - 25,
                  地鼠Y - 30,
                  地鼠X - 11,
                  地鼠Y - 20,
                  颜色类.深棕色
                )
                本对象.画填充椭圆 (
                  地鼠X + 11,
                  地鼠Y - 30,
                  地鼠X + 25,
                  地鼠Y - 20,
                  颜色类.深棕色
                )
            }
      }
    }

    方法 绘制信息 <公开>
    {
      变量 文本 <类型 = 文本型>

      // 标题
      本对象.画文本 (300, 20, "打地鼠游戏", 颜色类.黑色, 36)

      // 得分
      文本 = "得分: " + 到文本 (得分)
      本对象.画文本 (20, 20, 文本, 颜色类.黑色, 24)

      // 剩余时间
      文本 = "剩余时间: " + 到文本 (剩余时间) + "秒"
      本对象.画文本 (600, 20, 文本, 颜色类.黑色, 24)

      // 命中率
      如果 (命中次数 + 错过次数 > 0)
      {
            变量 命中率 <类型 = 小数>
            命中率 = (小数)命中次数 / (命中次数 + 错过次数) * 100
            文本 = "命中率: " + 到文本 (命中率, 1) + "%"
            本对象.画文本 (20, 60, 文本, 颜色类.黑色, 18)
      }

      // 游戏结束信息
      如果 (游戏结束 = 真)
      {
            本对象.画文本 (300, 250, "游戏结束", 颜色类.红色, 48)
            文本 = "最终得分: " + 到文本 (得分)
            本对象.画文本 (320, 310, 文本, 颜色类.黑色, 36)

            如果 (得分 >= 最高分 且 得分 > 0)
            {
                本对象.画文本 (320, 360, "新纪录!", 颜色类.金色, 36)
            }

            本对象.画文本 (280, 420, "按空格键重新开始", 颜色类.黑色, 24)
      }

      // 菜单信息
      如果 (游戏状态 = 0)
      {
            本对象.画文本 (280, 250, "打地鼠游戏", 颜色类.黑色, 48)
            本对象.画文本 (300, 320, "按空格键开始游戏", 颜色类.黑色, 24)

            如果 (最高分 > 0)
            {
                文本 = "最高分: " + 到文本 (最高分)
                本对象.画文本 (340, 370, 文本, 颜色类.黑色, 24)
            }
      }
    }

    方法 更新地鼠状态 <公开>
    {
      变量 当前时间 <类型 = 整数>
      变量 计次 <类型 = 整数>

      当前时间 = 取启动时间 ()

      计次循环 (计次 = 0 到 8)
      {
            如果 (地洞数组 [计次].有地鼠 = 真)
            {
                如果 (当前时间 - 地洞数组 [计次].出现时间 > 1500)
                {
                  地洞数组 [计次].有地鼠 = 假
                  错过次数 = 错过次数 + 1
                  刷新显示 ()
                }
            }
      }
    }
}

类 地洞信息类 <公开>
{
    变量 X坐标 <类型 = 整数>
    变量 Y坐标 <类型 = 整数>
    变量 有地鼠 <类型 = 逻辑型>
    变量 出现时间 <类型 = 整数>
}

唐兀 发表于 2026-5-12 17:28:27

知道在火山GO上怎么搞吗,

RMJ 发表于 2026-5-12 20:35:58

唐兀 发表于 2026-5-12 17:28
知道在火山GO上怎么搞吗,

搭建智能体好像就PYthon模块比较全面,其他的不好搞,还有就是用Dify,go去调API

RMJ 发表于 2026-5-12 20:43:02

唐兀 发表于 2026-5-12 17:28
知道在火山GO上怎么搞吗,

二、最佳升级方案:用 FastAPI + Qdrant(或 Chroma 服务模式)
1. 把脚本包成一个 Web API(使用 FastAPI)
之前你在命令行 input() 提问,现在要让它监听 HTTP 请求。

安装

bash
pip install fastapi uvicorn

有空可以去往这方向研究

唐兀 发表于 2026-5-31 09:03:37

安卓的怎么搞
页: [1]
查看完整版本: Python搭建智能体测试