Unity实时控制Python算法？ZeroMQ+Protobuf实现双向高速通信（附源码）

第一章：Python 与 Unity 的跨进程通信（ZeroMQ+Protobuf）

环境准备与依赖安装

pip install pyzmq protobuf

• NetMQ
• protobuf-net

Protobuf 消息定义

syntax = "proto3";
message Command {
  string action = 1;
  repeated float data = 2;
}

ZeroMQ 通信模式选择

import zmq
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://*:5555")

while True:
    message = socket.recv()  # 接收二进制消息
    command = Command().parse(message)
    print(f"Received: {command.action}")
    socket.send(b"ACK")  # 返回确认

性能对比参考

第二章：通信架构设计与核心技术选型

2.1 ZeroMQ 消息队列原理与通信模式解析

核心通信模式

• REQ/REP：请求-应答模式，客户端发送请求，服务端返回响应，形成同步交互。
• PUB/SUB：发布-订阅模式，发布者广播消息，订阅者按主题过滤接收。
• PUSH/PULL：用于流水线架构，实现任务分发与结果收集。
• DEALER/ROUTER：支持异步全双工通信，常用于构建复杂拓扑结构。

代码示例：PUB/SUB 模式

import zmq

# 创建上下文和发布者
context = zmq.Context()
publisher = context.socket(zmq.PUB)
publisher.bind("tcp://*:5556")

# 发送带主题的消息
publisher.send_multipart([b"news", b"Breaking: ZeroMQ in action"])

2.2 Protobuf 序列化机制及其在高性能通信中的优势

序列化效率对比

定义消息结构

message User {
  string name = 1;
  int32 age = 2;
  repeated string emails = 3;
}

2.3 Python 与 Unity 进程间通信的典型场景分析

典型应用场景

• 机器学习模型推理：Python 执行 AI 推理，结果传回 Unity 控制角色行为
• 自动化测试：Python 脚本驱动 Unity 游戏逻辑并采集运行数据
• 实时数据可视化：Python 处理传感器数据，Unity 动态更新 3D 场景

基于 Socket 的通信示例

import socket

def send_to_unity(message):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect(('localhost', 8080))
        s.sendall(message.encode())

2.4 基于请求-响应模式的双向通信原型设计

核心通信流程

type Request struct {
    Method string            `json:"method"`
    Params map[string]string `json:"params"`
}

type Response struct {
    Code int         `json:"code"`
    Data interface{} `json:"data"`
}

消息往返机制

2.5 开发环境搭建与依赖库配置（ZeroMQ + Protobuf for Python/Unity）

Python端依赖安装

pip install pyzmq protobuf

Unity端配置

跨平台通信准备

第三章：Protobuf 接口定义与跨语言数据契约实现

3.1 定义通用消息结构：.proto 文件编写规范

基础语法结构

syntax = "proto3";
package user.v1;
option go_package = "example.com/user/v1";

message UserInfo {
  string name = 1;
  int32 age = 2;
  repeated string hobbies = 3;
}

字段命名与类型规范

• 字段名使用小写加下划线（snake_case）
• 必选字段应在文档中标注，默认均为可选（proto3）
• 重复字段使用 repeated 关键字表示列表结构

3.2 使用 protoc 编译生成 Python 与 C# 通信类

编译命令示例

protoc --python_out=. --csharp_out=. message.proto

生成内容对比

3.3 数据序列化/反序列化性能测试与验证

测试方案设计

type User struct {
    ID   int64  `json:"id" protobuf:"varint,1,opt,name=id"`
    Name string `json:"name" protobuf:"bytes,2,opt,name=name"`
}

性能对比结果

第四章：Unity 与 Python 端通信模块编码实践

4.1 Python 服务端实现：基于 ZeroMQ 的异步消息处理

核心通信模式选择

import zmq
import threading

def worker_routine():
    context = zmq.Context()
    socket = context.socket(zmq.REP)
    socket.connect("inproc://workers")
    while True:
        msg = socket.recv()
        # 处理业务逻辑
        socket.send(b"ACK")

# 启动多个工作线程
for i in range(5):
    thread = threading.Thread(target=worker_routine)
    thread.start()

性能对比

4.2 Unity 客户端实现：C# 中 ZeroMQ 插件集成与协程封装

协程驱动的消息接收

IEnumerator ReceiveMessages()
{
    using (var subscriber = new Socket(SocketType.SUB))
    {
        subscriber.Connect("tcp://localhost:5555");
        subscriber.Subscribe("");

        while (true)
        {
            string message = subscriber.ReceiveFrameString();
            // 处理接收到的消息
            ProcessMessage(message);
            yield return null; // 每帧处理一条消息
        }
    }
}

线程安全与消息队列

4.3 实时控制指令传输：从 Unity 发送参数到 Python 算法引擎

通信协议选择

using (var ws = new WebSocket("ws://localhost:8765")) {
    ws.OnOpen += (sender, e) => {
        var cmd = new { action = "start", param = 0.8 };
        ws.Send(JsonUtility.ToJson(cmd));
    };
    ws.Connect();
}

import websockets
import asyncio

async def handler(websocket):
    async for message in websocket:
        data = json.loads(message)
        print(f"Received: {data['action']} with {data['param']}")

import asyncio
import websockets
import json

async def send_results(websocket, path):
    # 模拟算法输出
    result_data = {
        "position": [1.5, 2.0, -3.0],
        "status": "completed",
        "score": 0.96
    }
    await websocket.send(json.dumps(result_data))
    print("数据已推送至Unity")

start_server = websockets.serve(send_results, "localhost", 8765)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

package main

import (
    "context"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
)

func listPods(clientset *kubernetes.Clientset, namespace string) error {
    pods, err := clientset.CoreV1().Pods(namespace).List(
        context.TODO(), 
        metav1.ListOptions{})
    if err != nil {
        return err
    }
    for _, pod := range pods.Items {
        // 处理 Pod 状态监控逻辑
        println("Pod:", pod.Name, "Phase:", pod.Status.Phase)
    }
    return nil
}