Protobuf在游戏开发中的应用：TypeScript + Golang 实践

Protobuf在游戏开发中的应用：TypeScript + Golang 实践指南

前言

在游戏开发中，客户端与服务器之间的通信是核心功能之一。随着游戏复杂度的增加，传统的JSON通信方式在性能、数据大小和类型安全方面逐渐显现出不足。Protocol Buffers（简称Protobuf）作为Google开发的数据序列化格式，以其高效的二进制编码、强类型定义和跨语言支持等优势，成为游戏开发中理想的通信协议选择。

本文将详细介绍如何在游戏开发中使用Protobuf，结合TypeScript前端和Golang后端，提供完整的实践指南。

目录

1. Protobuf简介
2. 环境搭建
3. 定义.proto文件
4. Golang后端实现
5. TypeScript前端实现
6. 在Cocos Creator中的集成
7. 性能对比
8. 最佳实践
9. 总结

Protobuf简介

什么是Protobuf？

Protocol Buffers是Google开发的一种语言无关、平台无关、可扩展的结构化数据序列化机制。它比XML更小、更快、更简单，支持多种编程语言。

主要优势

1. 高效的二进制编码：比JSON和XML更紧凑，传输更快
2. 强类型定义：编译时类型检查，减少运行时错误
3. 向后兼容：支持字段的添加和删除，不影响现有代码
4. 跨语言支持：支持多种编程语言
5. 自动代码生成：根据.proto文件自动生成对应语言的代码

适用场景

• 游戏客户端与服务器通信
• 微服务间通信
• 数据存储和传输
• API接口定义

环境搭建

1. 安装Protobuf编译器

# macOS
brew install protobuf

# Ubuntu/Debian
sudo apt-get install protobuf-compiler

# Windows
# 下载预编译版本：https://github.com/protocolbuffers/protobuf/releases

2. 安装Golang相关工具

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

3. 安装TypeScript相关工具

npm install -g protobuf-ts
npm install protobufjs

定义.proto文件

让我们以一个简单的游戏通信协议为例，定义用户登录、获取房间列表等消息格式。

创建 game.proto 文件

syntax = "proto3";

package game;

option go_package = "github.com/yourgame/proto/game";
option java_package = "com.yourgame.proto";
option csharp_namespace = "YourGame.Proto";

// 用户信息
message UserInfo {
  int64 user_id = 1;
  string username = 2;
  int64 gold = 3;
  int64 diamond = 4;
  int32 level = 5;
  string avatar = 6;
  int64 exp = 7;
}

// 房间信息
message RoomInfo {
  int32 room_id = 1;
  string room_name = 2;
  int32 min_buy = 3;
  int32 max_buy = 4;
  int32 player_count = 5;
  int32 max_players = 6;
  bool is_locked = 7;
  repeated int32 blinds = 8;
}

// 登录请求
message LoginReq {
  string username = 1;
  string password = 2;
  string device_id = 3;
}

// 登录响应
message LoginResp {
  int32 code = 1;
  string message = 2;
  UserInfo user_info = 3;
  string token = 4;
}

// 获取房间列表请求
message GetRoomListReq {
  int32 page_num = 1;
  int32 page_size = 2;
  int32 room_type = 3;
}

// 获取房间列表响应
message GetRoomListResp {
  int32 code = 1;
  string message = 2;
  repeated RoomInfo rooms = 3;
  int32 total_count = 4;
}

// 加入房间请求
message JoinRoomReq {
  int32 room_id = 1;
  int32 buy_in_amount = 2;
}

// 加入房间响应
message JoinRoomResp {
  int32 code = 1;
  string message = 2;
  int32 table_id = 3;
  int32 seat_id = 4;
}

// 游戏操作请求
message GameActionReq {
  int32 table_id = 1;
  int32 action_type = 2; // 1: fold, 2: call, 3: raise, 4: check
  int32 amount = 3;
}

// 游戏操作响应
message GameActionResp {
  int32 code = 1;
  string message = 2;
  int32 action_id = 3;
}

// 游戏状态更新
message GameStateUpdate {
  int32 table_id = 1;
  int32 game_phase = 2; // 1: preflop, 2: flop, 3: turn, 4: river, 5: showdown
  repeated int32 community_cards = 3;
  repeated PlayerState players = 4;
  int32 pot_amount = 5;
  int32 current_player = 6;
}

// 玩家状态
message PlayerState {
  int32 seat_id = 1;
  int32 chips = 2;
  int32 bet_amount = 3;
  bool is_folded = 4;
  bool is_all_in = 5;
  repeated int32 hole_cards = 6;
}

// 服务定义
service GameService {
  rpc Login(LoginReq) returns (LoginResp);
  rpc GetRoomList(GetRoomListReq) returns (GetRoomListResp);
  rpc JoinRoom(JoinRoomReq) returns (JoinRoomResp);
  rpc GameAction(GameActionReq) returns (GameActionResp);
}

Golang后端实现

1. 生成Go代码

protoc --go_out=. --go_opt=paths=source_relative \
       --go-grpc_out=. --go-grpc_opt=paths=source_relative \
       game.proto

2. 创建服务器实现

package main

import (
    "context"
    "log"
    "net"
    "sync"

    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
    pb "github.com/yourgame/proto/game"
)

type gameServer struct {
    pb.UnimplementedGameServiceServer
    users    map[int64]*pb.UserInfo
    rooms    map[int32]*pb.RoomInfo
    userMux  sync.RWMutex
    roomMux  sync.RWMutex
}

func (s *gameServer) Login(ctx context.Context, req *pb.LoginReq) (*pb.LoginResp, error) {
    log.Printf("Login request from user: %s", req.Username)
    
    // 这里应该实现真实的用户验证逻辑
    // 为了演示，我们创建一个模拟用户
    userInfo := &pb.UserInfo{
        UserId:   12345,
        Username: req.Username,
        Gold:     10000,
        Diamond:  100,
        Level:    1,
        Avatar:   "avatar_1",
        Exp:      0,
    }
    
    // 保存用户信息
    s.userMux.Lock()
    s.users[userInfo.UserId] = userInfo
    s.userMux.Unlock()
    
    return &pb.LoginResp{
        Code:     200,
        Message:  "Login successful",
        UserInfo: userInfo,
        Token:    "mock_token_" + req.Username,
    }, nil
}

func (s *gameServer) GetRoomList(ctx context.Context, req *pb.GetRoomListReq) (*pb.GetRoomListResp, error) {
    log.Printf("Get room list request: page=%d, size=%d, type=%d", 
               req.PageNum, req.PageSize, req.RoomType)
    
    // 创建模拟房间数据
    rooms := []*pb.RoomInfo{
        {
            RoomId:      1,
            RoomName:    "新手场",
            MinBuy:      100,
            MaxBuy:      1000,
            PlayerCount: 5,
            MaxPlayers:  9,
            IsLocked:    false,
            Blinds:      []int32{10, 20},
        },
        {
            RoomId:      2,
            RoomName:    "进阶场",
            MinBuy:      1000,
            MaxBuy:      10000,
            PlayerCount: 3,
            MaxPlayers:  9,
            IsLocked:    false,
            Blinds:      []int32{50, 100},
        },
    }
    
    return &pb.GetRoomListResp{
        Code:       200,
        Message:    "Success",
        Rooms:      rooms,
        TotalCount: int32(len(rooms)),
    }, nil
}

func (s *gameServer) JoinRoom(ctx context.Context, req *pb.JoinRoomReq) (*pb.JoinRoomResp, error) {
    log.Printf("Join room request: room_id=%d, buy_in=%d", req.RoomId, req.BuyInAmount)
    
    // 检查房间是否存在
    s.roomMux.RLock()
    room, exists := s.rooms[req.RoomId]
    s.roomMux.RUnlock()
    
    if !exists {
        return nil, status.Errorf(codes.NotFound, "Room not found")
    }
    
    // 检查房间是否已满
    if room.PlayerCount >= room.MaxPlayers {
        return nil, status.Errorf(codes.ResourceExhausted, "Room is full")
    }
    
    // 分配座位
    seatId := int32(room.PlayerCount + 1)
    
    return &pb.JoinRoomResp{
        Code:    200,
        Message: "Joined room successfully",
        TableId: req.RoomId,
        SeatId:  seatId,
    }, nil
}

func (s *gameServer) GameAction(ctx context.Context, req *pb.GameActionReq) (*pb.GameActionResp, error) {
    log.Printf("Game action request: table_id=%d, action_type=%d, amount=%d", 
               req.TableId, req.ActionType, req.Amount)
    
    // 这里应该实现真实的游戏逻辑
    // 为了演示，我们返回成功
    return &pb.GameActionResp{
        Code:     200,
        Message:  "Action processed",
        ActionId: 12345,
    }, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    
    s := grpc.NewServer()
    pb.RegisterGameServiceServer(s, &gameServer{
        users: make(map[int64]*pb.UserInfo),
        rooms: make(map[int32]*pb.RoomInfo),
    })
    
    log.Printf("Server listening at %v", lis.Addr())
    if err := s.Serve(lis); err != nil {
        log.Fatalf("Failed to serve: %v", err)
    }
}

3. 创建客户端测试

package main

import (
    "context"
    "log"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    pb "github.com/yourgame/proto/game"
)

func main() {
    conn, err := grpc.Dial("localhost:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        log.Fatalf("Did not connect: %v", err)
    }
    defer conn.Close()
    
    c := pb.NewGameServiceClient(conn)
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    
    // 测试登录
    loginResp, err := c.Login(ctx, &pb.LoginReq{
        Username: "testuser",
        Password: "password",
        DeviceId: "device123",
    })
    if err != nil {
        log.Fatalf("Could not login: %v", err)
    }
    log.Printf("Login response: %v", loginResp)
    
    // 测试获取房间列表
    roomResp, err := c.GetRoomList(ctx, &pb.GetRoomListReq{
        PageNum:  1,
        PageSize: 10,
        RoomType: 0,
    })
    if err != nil {
        log.Fatalf("Could not get room list: %v", err)
    }
    log.Printf("Room list response: %v", roomResp)
}

TypeScript前端实现

1. 生成TypeScript代码

protoc --plugin=protoc-gen-ts_proto=./node_modules/.bin/protoc-gen-ts_proto \
       --ts_proto_out=./src/proto \
       --ts_proto_opt=esModuleInterop=true \
       game.proto

2. 创建网络管理器

// src/network/NetworkManager.ts
import { GameServiceClient } from '../proto/game_grpc_pb';
import { 
    LoginReq, LoginResp, 
    GetRoomListReq, GetRoomListResp,
    JoinRoomReq, JoinRoomResp,
    GameActionReq, GameActionResp 
} from '../proto/game_pb';

export class NetworkManager {
    private static instance: NetworkManager;
    private client: GameServiceClient;
    private token: string = '';
    
    private constructor() {
        // 创建gRPC客户端
        this.client = new GameServiceClient('http://localhost:50051');
    }
    
    public static getInstance(): NetworkManager {
        if (!NetworkManager.instance) {
            NetworkManager.instance = new NetworkManager();
        }
        return NetworkManager.instance;
    }
    
    public setToken(token: string): void {
        this.token = token;
    }
    
    public async login(username: string, password: string, deviceId: string): Promise<LoginResp> {
        return new Promise((resolve, reject) => {
            const request = new LoginReq();
            request.setUsername(username);
            request.setPassword(password);
            request.setDeviceId(deviceId);
            
            this.client.login(request, (error, response) => {
                if (error) {
                    reject(error);
                } else {
                    if (response && response.getCode() === 200) {
                        this.setToken(response.getToken());
                    }
                    resolve(response);
                }
            });
        });
    }
    
    public async getRoomList(pageNum: number, pageSize: number, roomType: number): Promise<GetRoomListResp> {
        return new Promise((resolve, reject) => {
            const request = new GetRoomListReq();
            request.setPageNum(pageNum);
            request.setPageSize(pageSize);
            request.setRoomType(roomType);
            
            this.client.getRoomList(request, (error, response) => {
                if (error) {
                    reject(error);
                } else {
                    resolve(response);
                }
            });
        });
    }
    
    public async joinRoom(roomId: number, buyInAmount: number): Promise<JoinRoomResp> {
        return new Promise((resolve, reject) => {
            const request = new JoinRoomReq();
            request.setRoomId(roomId);
            request.setBuyInAmount(buyInAmount);
            
            this.client.joinRoom(request, (error, response) => {
                if (error) {
                    reject(error);
                } else {
                    resolve(response);
                }
            });
        });
    }
    
    public async gameAction(tableId: number, actionType: number, amount: number): Promise<GameActionResp> {
        return new Promise((resolve, reject) => {
            const request = new GameActionReq();
            request.setTableId(tableId);
            request.setActionType(actionType);
            request.setAmount(amount);
            
            this.client.gameAction(request, (error, response) => {
                if (error) {
                    reject(error);
                } else {
                    resolve(response);
                }
            });
        });
    }
}

3. 创建游戏管理器

// src/managers/GameManager.ts
import { NetworkManager } from '../network/NetworkManager';
import { UserInfo, RoomInfo } from '../proto/game_pb';

export class GameManager {
    private static instance: GameManager;
    private networkManager: NetworkManager;
    private currentUser: UserInfo | null = null;
    private roomList: RoomInfo[] = [];
    
    private constructor() {
        this.networkManager = NetworkManager.getInstance();
    }
    
    public static getInstance(): GameManager {
        if (!GameManager.instance) {
            GameManager.instance = new GameManager();
        }
        return GameManager.instance;
    }
    
    public async login(username: string, password: string): Promise<boolean> {
        try {
            const deviceId = this.getDeviceId();
            const response = await this.networkManager.login(username, password, deviceId);
            
            if (response.getCode() === 200) {
                this.currentUser = response.getUserInfo();
                console.log('Login successful:', this.currentUser);
                return true;
            } else {
                console.error('Login failed:', response.getMessage());
                return false;
            }
        } catch (error) {
            console.error('Login error:', error);
            return false;
        }
    }
    
    public async loadRoomList(): Promise<RoomInfo[]> {
        try {
            const response = await this.networkManager.getRoomList(1, 100, 0);
            
            if (response.getCode() === 200) {
                this.roomList = response.getRoomsList();
                console.log('Room list loaded:', this.roomList);
                return this.roomList;
            } else {
                console.error('Failed to load room list:', response.getMessage());
                return [];
            }
        } catch (error) {
            console.error('Load room list error:', error);
            return [];
        }
    }
    
    public async joinRoom(roomId: number, buyInAmount: number): Promise<boolean> {
        try {
            const response = await this.networkManager.joinRoom(roomId, buyInAmount);
            
            if (response.getCode() === 200) {
                console.log('Joined room:', response.getTableId(), 'Seat:', response.getSeatId());
                return true;
            } else {
                console.error('Failed to join room:', response.getMessage());
                return false;
            }
        } catch (error) {
            console.error('Join room error:', error);
            return false;
        }
    }
    
    public async performGameAction(tableId: number, actionType: number, amount: number): Promise<boolean> {
        try {
            const response = await this.networkManager.gameAction(tableId, actionType, amount);
            
            if (response.getCode() === 200) {
                console.log('Game action performed:', response.getActionId());
                return true;
            } else {
                console.error('Failed to perform game action:', response.getMessage());
                return false;
            }
        } catch (error) {
            console.error('Game action error:', error);
            return false;
        }
    }
    
    public getCurrentUser(): UserInfo | null {
        return this.currentUser;
    }
    
    public getRoomList(): RoomInfo[] {
        return this.roomList;
    }
    
    private getDeviceId(): string {
        // 生成或获取设备ID的逻辑
        return 'device_' + Date.now();
    }
}

在Cocos Creator中的集成

1. 创建UI组件

// assets/scripts/views/LoginView.ts
import { _decorator, Component, Node, EditBox, Button, Label } from 'cc';
import { GameManager } from '../managers/GameManager';

const { ccclass, property } = _decorator;

@ccclass('LoginView')
export class LoginView extends Component {
    @property(EditBox)
    usernameInput: EditBox = null!;
    
    @property(EditBox)
    passwordInput: EditBox = null!;
    
    @property(Button)
    loginButton: Button = null!;
    
    @property(Label)
    statusLabel: Label = null!;
    
    private gameManager: GameManager;
    
    onLoad() {
        this.gameManager = GameManager.getInstance();
        this.setupEventListeners();
    }
    
    private setupEventListeners() {
        this.loginButton.node.on(Button.EventType.CLICK, this.onLoginClick, this);
    }
    
    private async onLoginClick() {
        const username = this.usernameInput.string;
        const password = this.passwordInput.string;
        
        if (!username || !password) {
            this.showStatus('请输入用户名和密码');
            return;
        }
        
        this.loginButton.interactable = false;
        this.showStatus('登录中...');
        
        try {
            const success = await this.gameManager.login(username, password);
            
            if (success) {
                this.showStatus('登录成功');
                // 跳转到大厅
                this.loadHallView();
            } else {
                this.showStatus('登录失败');
            }
        } catch (error) {
            this.showStatus('网络错误');
            console.error('Login error:', error);
        } finally {
            this.loginButton.interactable = true;
        }
    }
    
    private showStatus(message: string) {
        if (this.statusLabel) {
            this.statusLabel.string = message;
        }
    }
    
    private loadHallView() {
        // 加载大厅场景的逻辑
        console.log('Loading hall view...');
    }
}

2. 创建房间列表组件

// assets/scripts/views/RoomListView.ts
import { _decorator, Component, Node, Prefab, instantiate, Label, Button } from 'cc';
import { GameManager } from '../managers/GameManager';
import { RoomInfo } from '../proto/game_pb';

const { ccclass, property } = _decorator;

@ccclass('RoomListView')
export class RoomListView extends Component {
    @property(Prefab)
    roomItemPrefab: Prefab = null!;
    
    @property(Node)
    roomListContainer: Node = null!;
    
    @property(Button)
    refreshButton: Button = null!;
    
    private gameManager: GameManager;
    
    onLoad() {
        this.gameManager = GameManager.getInstance();
        this.setupEventListeners();
        this.loadRoomList();
    }
    
    private setupEventListeners() {
        this.refreshButton.node.on(Button.EventType.CLICK, this.loadRoomList, this);
    }
    
    private async loadRoomList() {
        try {
            const rooms = await this.gameManager.loadRoomList();
            this.displayRooms(rooms);
        } catch (error) {
            console.error('Failed to load room list:', error);
        }
    }
    
    private displayRooms(rooms: RoomInfo[]) {
        // 清空现有房间列表
        this.roomListContainer.removeAllChildren();
        
        // 创建房间项
        rooms.forEach(room => {
            const roomItem = instantiate(this.roomItemPrefab);
            this.setupRoomItem(roomItem, room);
            this.roomListContainer.addChild(roomItem);
        });
    }
    
    private setupRoomItem(roomItem: Node, room: RoomInfo) {
        // 设置房间信息
        const nameLabel = roomItem.getChildByName('NameLabel')?.getComponent(Label);
        if (nameLabel) {
            nameLabel.string = room.getRoomName();
        }
        
        const playerLabel = roomItem.getChildByName('PlayerLabel')?.getComponent(Label);
        if (playerLabel) {
            playerLabel.string = `${room.getPlayerCount()}/${room.getMaxPlayers()}`;
        }
        
        const buyInLabel = roomItem.getChildByName('BuyInLabel')?.getComponent(Label);
        if (buyInLabel) {
            buyInLabel.string = `${room.getMinBuy()}-${room.getMaxBuy()}`;
        }
        
        // 设置加入房间按钮
        const joinButton = roomItem.getChildByName('JoinButton')?.getComponent(Button);
        if (joinButton) {
            joinButton.node.on(Button.EventType.CLICK, () => {
                this.joinRoom(room.getRoomId(), room.getMinBuy());
            });
        }
    }
    
    private async joinRoom(roomId: number, buyInAmount: number) {
        try {
            const success = await this.gameManager.joinRoom(roomId, buyInAmount);
            
            if (success) {
                console.log('Successfully joined room:', roomId);
                // 跳转到游戏场景
                this.loadGameView();
            } else {
                console.error('Failed to join room');
            }
        } catch (error) {
            console.error('Join room error:', error);
        }
    }
    
    private loadGameView() {
        // 加载游戏场景的逻辑
        console.log('Loading game view...');
    }
}

性能对比

数据大小对比

序列化性能对比

// 性能测试代码
const testData = {
    userId: 12345,
    username: "testuser",
    gold: 10000,
    diamond: 100,
    level: 1,
    avatar: "avatar_1",
    exp: 0
};

// JSON序列化
const jsonStart = performance.now();
const jsonString = JSON.stringify(testData);
const jsonEnd = performance.now();
console.log('JSON serialization time:', jsonEnd - jsonStart);

// Protobuf序列化
const protoStart = performance.now();
const protoMessage = new UserInfo();
protoMessage.setUserId(testData.userId);
protoMessage.setUsername(testData.username);
protoMessage.setGold(testData.gold);
protoMessage.setDiamond(testData.diamond);
protoMessage.setLevel(testData.level);
protoMessage.setAvatar(testData.avatar);
protoMessage.setExp(testData.exp);
const protoBuffer = protoMessage.serializeBinary();
const protoEnd = performance.now();
console.log('Protobuf serialization time:', protoEnd - protoStart);

最佳实践

1. 版本管理

// 使用版本号管理协议变更
message GameMessage {
  int32 version = 1;
  oneof payload {
    LoginReq login_req = 2;
    LoginResp login_resp = 3;
    GetRoomListReq get_room_list_req = 4;
    GetRoomListResp get_room_list_resp = 5;
    // ... 其他消息类型
  }
}

2. 错误处理

// 统一的错误处理
export class NetworkError extends Error {
    constructor(
        public code: number,
        public message: string,
        public originalError?: any
    ) {
        super(message);
        this.name = 'NetworkError';
    }
}

export class NetworkManager {
    private handleError(error: any): never {
        if (error.code) {
            throw new NetworkError(error.code, error.message, error);
        } else {
            throw new NetworkError(500, 'Network error', error);
        }
    }
}

3. 连接管理

export class ConnectionManager {
    private reconnectAttempts = 0;
    private maxReconnectAttempts = 5;
    private reconnectDelay = 1000;
    
    public async reconnect(): Promise<void> {
        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
            throw new Error('Max reconnection attempts reached');
        }
        
        this.reconnectAttempts++;
        await this.delay(this.reconnectDelay * this.reconnectAttempts);
        
        try {
            await this.connect();
            this.reconnectAttempts = 0;
        } catch (error) {
            await this.reconnect();
        }
    }
    
    private delay(ms: number): Promise<void> {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
}

4. 消息队列

export class MessageQueue {
    private queue: Array<() => Promise<void>> = [];
    private processing = false;
    
    public async enqueue(messageHandler: () => Promise<void>): Promise<void> {
        this.queue.push(messageHandler);
        
        if (!this.processing) {
            await this.processQueue();
        }
    }
    
    private async processQueue(): Promise<void> {
        this.processing = true;
        
        while (this.queue.length > 0) {
            const handler = this.queue.shift();
            if (handler) {
                try {
                    await handler();
                } catch (error) {
                    console.error('Message processing error:', error);
                }
            }
        }
        
        this.processing = false;
    }
}

总结

Protobuf在游戏开发中提供了显著的优势：

1. 性能提升：更小的数据大小和更快的序列化速度
2. 类型安全：编译时类型检查，减少运行时错误
3. 跨语言支持：支持多种编程语言，便于前后端协作
4. 向后兼容：支持协议演进，不影响现有功能
5. 自动代码生成：减少手动编写代码的工作量

通过本文的实践指南，你可以：

• 在Golang后端实现高效的gRPC服务
• 在TypeScript前端集成Protobuf通信
• 在Cocos Creator中构建完整的游戏网络架构
• 掌握Protobuf的最佳实践和性能优化技巧

随着游戏复杂度的增加，Protobuf将成为构建高性能、可扩展游戏网络架构的重要工具。希望本文能够帮助你在游戏开发中更好地使用Protobuf技术。

如有游戏方面的需求，可关注我，我们可以合作开发游戏。

参考资料：

• Protocol Buffers官方文档
• gRPC官方文档
• Cocos Creator官方文档

版权声明： 本文为原创文章，转载请注明出处。