前言

2025-2026年，AI辅助编程工具已从”代码补全”全面迈入”智能Agent”时代。本文从大型项目支撑、需求规划、代码修复、团队协作、团队成本五个维度，深度对比四款主流AI编程工具——Cursor、Claude Code、Codex（OpenAI）和Antigravity（Google），帮助5-20人规模的开发团队做出选择。

工具概览

一、大型项目支撑能力

大型项目（代码量10万行以上、多模块、多仓库）对AI工具的上下文管理和架构理解能力是极大考验。

Cursor ⭐⭐⭐

Cursor通过深度代码索引（@codebase）构建项目的语义地图，中小型项目体验极好。但当代码量超过50万行时，索引性能下降明显，上下文窗口难以承载复杂的跨文件特性。Composer模式支持多文件编辑，但在超大型单体仓库中容易出现”上下文遗忘”。

1
2

适合场景：中小型项目（<50万行）的日常开发
局限：超大型项目索引瓶颈，长会话上下文衰减

Claude Code ⭐⭐⭐⭐

Claude Code采用”动态读取”策略——不依赖预构建索引，而是实时遍历文件系统、追踪引用关系。这种方式避免了索引过期的问题，在复杂架构的代码重构和跨模块调试中表现出色。但高强度使用会快速消耗配额。

1
2

适合场景：复杂架构重构、深度调试、跨模块修改
局限：高配额消耗，长会话需要手动分段

Codex ⭐⭐⭐

Codex擅长处理”可隔离的明确任务”——如批量迁移中间件、修复TypeScript类型错误等。每次任务从全新上下文启动，避免了上下文污染，但也意味着它可能遗漏项目特定的约定和规范。

1
2

适合场景：批量重构、标准化修复、可隔离的后台任务
局限：缺乏持续项目记忆，需要显式提供项目规范

Antigravity ⭐⭐⭐⭐⭐

Antigravity的Agent-first架构是处理大型项目的杀手级特性。通过Agent Manager可以同时派发多个自主Agent——一个处理后端逻辑，一个构建前端，一个编写测试——并行推进。每个Agent能跨IDE、终端和内置浏览器操作，并生成Artifacts（实现计划、截图、浏览器录屏）供人工审核。

1
2

适合场景：大型复杂项目、多模块并行开发
优势：多Agent并行、跨工具链操作、可验证的Artifacts输出

二、需求规划能力

从模糊需求到可执行的技术方案，需求规划能力决定了工具在”从0到1”阶段的价值。

Cursor ⭐⭐

Cursor的核心优势在代码级别——Tab补全和Cmd+K内联编辑极其流畅，但它本质是一个”编辑器增强”工具。对于复杂需求的分解和规划，需要开发者自己完成或依赖外部工具。

Claude Code ⭐⭐⭐⭐

Claude Code支持结构化的任务分解流程。通过CLAUDE.md文件定义项目规范后，它能分析需求、生成任务计划、逐步执行：

1
2
3
4
5

## 典型工作流
1. 用户描述需求
2. Claude Code分析并生成任务计划
3. 用户审核确认
4. 按计划逐步执行，每步可中断调整

Claude的推理能力在需求分析阶段表现突出，能识别潜在的技术风险和边界情况。

Codex ⭐⭐⭐

Codex支持任务委托——你可以在ChatGPT中描述需求并委派给Codex去执行，然后回来检查完成的PR。但需求分解的深度不如Claude Code，更适合已经明确的技术任务。

Antigravity ⭐⭐⭐⭐⭐

Antigravity在需求规划方面有完整的内置工作流：

1
2
3
4
5

需求 → 实现计划（implementation_plan.md）
     → 用户审核 & 反馈
     → 任务分解（task.md）
     → 逐步执行 & 进度跟踪
     → 变更总结（walkthrough.md）

这套Plan → Review → Execute → Verify的流程是工具原生支持的，不是提示词技巧，而是平台能力。特别是实现计划会按组件分组、标注文件变更类型（NEW/MODIFY/DELETE），并包含验证方案。

三、代码修复能力

Cursor ⭐⭐⭐⭐

Cursor的代码修复体验最为流畅：选中有问题的代码，Cmd+K描述问题，AI直接内联修改。对于IDE中的lint错误和类型错误，Cursor能快速定位并修复。适合”看到错误→立即修”的快速迭代节奏。

Claude Code ⭐⭐⭐⭐⭐

Claude Code在复杂Bug修复方面表现最强。它能自主运行测试、分析错误堆栈、遍历相关代码、提出修复方案并验证。特别是涉及多文件关联的深层Bug，Claude Code的推理深度是明显优势。

1
2
3

# 典型调试流程
claude "这个API返回500错误，帮我找到根因并修复"
# Claude Code会：读取日志 → 追踪调用链 → 定位问题 → 修复 → 运行测试验证

Codex ⭐⭐⭐

Codex适合批量标准化修复——如”修复所有TypeScript严格模式报错”或”将所有回调改为async/await”。可以委派任务后离开，回来检查结果。但对复杂逻辑Bug的自主诊断能力不及Claude Code。

Antigravity ⭐⭐⭐⭐

Antigravity的代码修复结合了IDE集成和Agent能力。它能感知IDE的lint反馈，在修复时自动关联lint错误ID。同时支持启动浏览器子Agent录屏验证UI问题，生成修复前后的可视化对比。不过在纯逻辑推理深度上，使用Claude Opus模型时与Claude Code相当。

四、团队协作

对于5-20人的开发团队，协作能力直接影响工具的实际价值。

Cursor ⭐⭐⭐

Cursor Teams提供基本的团队协作基础设施，但工具本质上是个人IDE，协作更多体现在管理层面而非工作流层面。

Claude Code ⭐⭐⭐

Claude Code的Team计划提供Standard和Premium两种席位。通过CLAUDE.md文件可以统一团队的编码规范和项目上下文，但缺乏原生的多人协同机制——本质上是每个人各自使用各自的终端Agent。

Codex ⭐⭐⭐

Codex的Business/Enterprise计划提供工作区级别的信用额度池，适合团队共享资源。但它更像是”每个人的后台助手”，缺乏团队成员之间的协作编排能力。

Antigravity ⭐⭐⭐⭐⭐

Antigravity在团队协作方面有本质性的差异化：

• 多Agent并行：团队成员可以同时作为”架构师”角色管理各自的Agent编队，不同成员的Agent可以处理不同的模块和任务
• Artifacts共享：实现计划、任务进度、变更总结等Artifacts天然可以作为团队沟通的载体
• Agent-to-Agent协议（A2A）：支持Agent之间安全的任务交接和协作
• Human-in-the-Loop：Agent输出需经人工审核门禁，确保代码质量
• Google Cloud集成：企业版通过Gemini Enterprise Agent Platform接入，与Google Workspace深度整合

对于5-20人团队，Antigravity的多Agent架构意味着团队的AI生产力是乘法效应而非加法——每个成员都能同时调度多个Agent并行工作。

五、团队成本分析（5-20人团队）

以下按月度计算，考虑中高强度的AI编程使用量。

定价方案一览

5人团队月度成本估算

20人团队月度成本估算

💡 Antigravity Ultra的成本优势

Antigravity的Ultra计划（$100/月或$200/月）提供的是共享额度池，而非按席位计费。这意味着：

• $200/月的Ultra顶配计划提供20倍于Pro的使用量，一个订阅即可支撑小型团队的高强度使用
• 结合Google Cloud的Gemini Enterprise方案，企业可以获得组织级别的额度池和管理控制
• 对于5-20人团队，Antigravity的人均成本可以做到最低，同时提供最高的AI生产力

官方模型智能度对比

AI编程工具的表现很大程度上取决于底层模型的能力。

关键洞察：Antigravity的独特优势在于多模型自由切换——你可以在同一个项目中混用Gemini 3.1 Pro（超长上下文）、Claude Opus 4.6（深度推理）和GPT系列，根据任务特点选择最合适的模型。

综合评分

使用建议

选择Cursor当：

• 团队习惯VS Code，希望最低学习成本的AI增强
• 以日常编码和快速迭代为主
• 预算有限，需要按席位控制成本

选择Claude Code当：

• 团队有终端重度用户
• 经常需要深度Bug调试和复杂代码推理
• 项目对代码质量要求极高

选择Codex当：

• 有大量可标准化的批量重构任务
• 希望将任务委派后台异步执行
• 已深度使用OpenAI生态

选择Antigravity当：

• 5-20人团队需要最高性价比的AI编程方案
• 大型复杂项目需要多Agent并行推进
• 需要完整的需求→计划→执行→验证工作流
• 希望灵活切换多家模型，取各家之长
• 重视团队协作和AI生产力的乘法效应

组合使用策略

1
2
3
4
5
6

2026年高效开发流程：

1. Antigravity: 需求分析 → 生成实现计划 → 多Agent并行开发
2. Claude Code: 深度调试复杂Bug，终端级自主修复
3. Cursor: 日常编码，快速补全和小型重构
4. Codex: 委派批量重构、标准化修复等后台任务

总结

四款工具各有所长：

• Cursor——最佳日常编码IDE体验，上手零门槛
• Claude Code——最强推理和调试能力，终端极客之选
• Codex——最佳后台委托Agent，批量任务专家
• Antigravity——最佳团队AI编程平台，多Agent并行 + 高性价比

对于5-20人的开发团队，如果只能选一个工具，Antigravity的Ultra方案提供了最高的性价比和最强的协作能力；如果预算允许组合使用，建议以Antigravity为主力平台，辅以Claude Code处理深度调试任务。

注意：AI工具领域变化极快，定价和功能可能随时调整。建议在做采购决策前，访问各工具官网确认最新信息。

参考资料

• Cursor官网
• Claude Code文档
• OpenAI Codex
• Google Antigravity
• Google AI订阅方案

评论和共享

前言

RuoYi-Cloud是基于Spring Cloud的微服务权限管理系统，采用前后端分离架构。本文介绍如何使用Nacos进行微服务管理，以及单机调试与微服务模式部署的方法。

技术栈

项目结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

ruoyi-cloud/
├── ruoyi-api/                    # API模块
│   ├── ruoyi-api-system/        # 系统API
│   └── ruoyi-api-file/          # 文件API
├── ruoyi-auth/                   # 认证中心
├── ruoyi-common/                 # 通用模块
│   ├── ruoyi-common-core/       # 核心模块
│   ├── ruoyi-common-redis/      # Redis模块
│   ├── ruoyi-common-security/   # 安全模块
│   └── ruoyi-common-swagger/    # Swagger模块
├── ruoyi-gateway/                # 网关服务
├── ruoyi-modules/                # 业务模块
│   ├── ruoyi-system/            # 系统模块
│   ├── ruoyi-gen/               # 代码生成
│   ├── ruoyi-job/               # 定时任务
│   └── ruoyi-file/              # 文件服务
├── ruoyi-visual/                 # 可视化模块
│   └── ruoyi-monitor/           # 监控中心
└── ruoyi-ui/                     # 前端项目

自定义模块结构

按照你提供的结构，创建自定义业务模块：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

${artifactId}/
├─ pom.xml                           # 根pom（带profiles）
├─ ${artifactId}-api/                # API聚合模块
│   ├─ ${artifactId}-local-api/      # 单机启动模块
│   │   ├─ pom.xml
│   │   └─ src/main/java/...
│   ├─ ${artifactId}-cloud-api/      # 微服务启动模块
│   │   ├─ pom.xml
│   │   └─ src/main/java/...
│   └─ pom.xml
├─ ${artifactId}-biz/                # 业务逻辑模块
│   ├─ pom.xml
│   └─ src/main/java/...
└─ ${artifactId}-start/              # 启动模块
    ├─ pom.xml
    └─ src/main/java/...

Nacos配置

1. 安装Nacos

1
2
3
4
5
6
7
8
9
10

# 下载Nacos
wget https://github.com/alibaba/nacos/releases/download/2.2.0/nacos-server-2.2.0.tar.gz
tar -xvf nacos-server-2.2.0.tar.gz
cd nacos/bin

# 单机模式启动
./startup.sh -m standalone

# Windows
startup.cmd -m standalone

访问 http://localhost:8848/nacos，默认账号密码：nacos/nacos

2. 服务注册配置

1
2
3
4
5
6
7
8
9
10
11
12
13

# application.yml
spring:
  application:
    name: ruoyi-system
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: dev
      config:
        server-addr: 127.0.0.1:8848
        namespace: dev
        file-extension: yml

3. 配置中心使用

在Nacos控制台创建配置：

• Data ID: ruoyi-system-dev.yml
• Group: DEFAULT_GROUP

1
2
3
4
5
6
7
8
9
10

# Nacos配置内容
server:
  port: 9201

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ry-cloud?useUnicode=true
    username: root
    password: password

单机调试模式

Profile配置

根pom.xml配置profiles：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<profiles>
    <!-- 单机模式 -->
    <profile>
        <id>local</id>
        <properties>
            <profile.active>local</profile.active>
        </properties>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
    <!-- 微服务模式 -->
    <profile>
        <id>cloud</id>
        <properties>
            <profile.active>cloud</profile.active>
        </properties>
    </profile>
</profiles>

单机启动配置

application-local.yml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

spring:
  profiles:
    active: local
  cloud:
    nacos:
      discovery:
        enabled: false  # 禁用服务注册
      config:
        enabled: false  # 禁用配置中心

# 直接配置数据源
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/ry-cloud
    username: root
    password: password

单机启动命令

1
2
3
4

# 使用local profile启动
mvn spring-boot:run -Plocal

# 或者IDEA中设置Active Profiles为local

微服务模式部署

1. 启动顺序

1
2
3
4
5
6

1. Nacos (服务注册与配置中心)
2. MySQL + Redis
3. ruoyi-gateway (网关)
4. ruoyi-auth (认证中心)
5. ruoyi-system (系统服务)
6. 其他业务服务

2. Docker Compose部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

version: '3'
services:
  nacos:
    image: nacos/nacos-server:v2.2.0
    environment:
      - MODE=standalone
    ports:
      - "8848:8848"
    
  mysql:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=root
    ports:
      - "3306:3306"
    
  redis:
    image: redis:6.0
    ports:
      - "6379:6379"
    
  ruoyi-gateway:
    build: ./ruoyi-gateway
    ports:
      - "8080:8080"
    depends_on:
      - nacos
      
  ruoyi-auth:
    build: ./ruoyi-auth
    depends_on:
      - nacos
      - redis
      
  ruoyi-system:
    build: ./ruoyi-modules/ruoyi-system
    depends_on:
      - nacos
      - mysql

3. 微服务启动命令

1
2
3
4
5
6
7
8

# 使用cloud profile启动
mvn spring-boot:run -Pcloud

# 打包
mvn clean package -Pcloud

# 运行jar
java -jar ruoyi-gateway.jar --spring.profiles.active=cloud

服务调用

Feign客户端定义

1
2
3
4
5
6
7
8
9

// ruoyi-api-system模块
@FeignClient(contextId = "remoteUserService", 
             value = "ruoyi-system",
             fallbackFactory = RemoteUserFallbackFactory.class)
public interface RemoteUserService {
    
    @GetMapping("/user/info/{username}")
    R<LoginUser> getUserInfo(@PathVariable("username") String username);
}

服务调用

1
2
3
4
5
6
7
8
9
10
11

@Service
public class SysLoginService {
    
    @Autowired
    private RemoteUserService remoteUserService;
    
    public LoginUser login(String username) {
        R<LoginUser> result = remoteUserService.getUserInfo(username);
        return result.getData();
    }
}

常见问题

1. Nacos连接失败

检查Nacos是否启动，namespace是否正确配置

2. 服务注册不上

检查spring.application.name是否配置，网络是否通畅

3. 配置不生效

确认Data ID格式：${spring.application.name}-${profile}.${file-extension}

总结

RuoYi-Cloud通过Nacos实现了服务注册与配置管理，支持单机和微服务两种部署模式。开发时使用单机模式方便调试，生产环境使用微服务模式实现高可用。

参考资料

• RuoYi-Cloud官方文档
• Nacos官方文档
• Spring Cloud Alibaba

评论和共享

什么是OKR

OKR（Objectives and Key Results）即目标与关键结果法，是一套明确和跟踪目标及其完成情况的管理工具和方法。由Intel发明，后被Google、Facebook等公司广泛采用。

OKR的组成

• **O (Objective)**：目标，你想要达成什么
• **KR (Key Results)**：关键结果，如何衡量目标的达成

OKR vs KPI

OKR制定原则

1. Objective 目标原则

• 鼓舞人心：目标应该能激励团队
• 可达成但有挑战：不是轻易能完成的
• 定性描述：用文字描述，不是数字
• 时间限定：通常为一个季度

2. Key Results 关键结果原则

• 可量化：必须是可衡量的数字
• 有挑战性：完成60-70%算成功
• 3-5个为宜：每个O对应3-5个KR
• 结果导向：关注结果而非过程

OKR实践案例

案例一：技术团队OKR

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

【Q3 技术团队OKR】

O1: 提升系统稳定性，打造高可用服务
├── KR1: 系统可用性从99.5%提升到99.9%
├── KR2: P0故障数量从每月3次降低到0次
├── KR3: 平均故障恢复时间从30分钟降低到10分钟
└── KR4: 完成核心服务的容灾演练，覆盖率100%

O2: 提升研发效率，加速产品迭代
├── KR1: 需求平均交付周期从14天缩短到7天
├── KR2: 代码review覆盖率从60%提升到100%
├── KR3: 自动化测试覆盖率从40%提升到80%
└── KR4: 部署频率从每周1次提升到每天1次

O3: 建设技术影响力，打造学习型团队
├── KR1: 团队成员人均输出技术文章2篇
├── KR2: 组织内部技术分享会8次
└── KR3: 完成新人培训体系搭建，新人上手时间缩短50%

案例二：产品经理OKR

1
2
3
4
5
6
7
8
9
10
11
12

【Q3 产品经理OKR】

O1: 提升用户体验，打造极致产品
├── KR1: 用户满意度NPS从30提升到50
├── KR2: 核心功能用户留存率从40%提升到60%
├── KR3: 用户反馈处理率达到100%，平均响应时间<24小时
└── KR4: 完成3次用户调研，产出调研报告

O2: 驱动业务增长，实现商业价值
├── KR1: 付费转化率从2%提升到5%
├── KR2: 用户ARPU值从50元提升到80元
└── KR3: 新功能上线后DAU增长20%

案例三：个人OKR

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

【Q3 个人OKR - 后端开发工程师】

O1: 成为团队核心骨干，独当一面
├── KR1: 独立负责完成2个核心模块的设计与开发
├── KR2: 代码质量评分从B提升到A（bug率<1%）
└── KR3: 主导完成1次技术方案评审

O2: 提升技术深度，建立技术壁垒
├── KR1: 深入学习分布式系统，完成《DDIA》读书笔记
├── KR2: 输出2篇高质量技术博客
└── KR3: 获得1项云计算相关认证

O3: 提升软技能，增强团队协作
├── KR1: 主动帮助2名新同事完成onboarding
├── KR2: 参与跨团队项目协作，获得合作方好评
└── KR3: 完成1次团队内部技术分享

OKR实施流程

1. 制定阶段（季度初）

1
2
3
4
5
6
7
8
9

第1周：
├── 公司层面确定年度/季度战略目标
├── 各部门负责人制定部门OKR
└── 团队成员制定个人OKR

第2周：
├── OKR对齐会议，确保上下一致
├── 横向对齐，确保跨部门协作
└── 最终确认并公示所有OKR

2. 执行阶段（季度中）

1
2
3
4
5
6
7
8
9

每周：
├── 周会回顾OKR进展
├── 更新KR完成进度
└── 识别风险和阻碍

每月：
├── 月度OKR复盘会议
├── 调整策略和行动计划
└── 必要时调整KR（O一般不变）

3. 复盘阶段（季度末）

1
2
3
4
5

季度末：
├── 自评OKR完成情况（打分0-1）
├── 团队OKR复盘会议
├── 总结经验教训
└── 为下季度OKR制定做准备

OKR评分标准

注意：OKR评分不应直接与绩效考核挂钩，否则会导致目标设定保守。

常见问题与解决方案

问题1：OKR变成了任务清单

解决：KR应该是结果而非任务，问自己”完成这个能证明目标达成吗？”

问题2：目标设定过于保守

解决：鼓励挑战性目标，强调60-70%完成率是正常的

问题3：OKR与日常工作脱节

解决：每周回顾OKR，将日常工作与OKR关联

问题4：跨部门OKR不对齐

解决：建立OKR对齐机制，定期进行横向沟通

推荐工具

• 飞书OKR：字节跳动出品，功能完善
• Worktile：国产项目管理工具，支持OKR
• Notion：灵活的文档工具，可自定义OKR模板
• Weekdone：专业OKR管理工具

总结

OKR的核心价值：

1. 聚焦：让团队专注于最重要的事
2. 对齐：确保上下左右目标一致
3. 透明：全员可见，促进协作
4. 挑战：鼓励设定有野心的目标

成功实施OKR的关键：

• 领导层的支持和参与
• 持续的沟通和反馈
• 与绩效考核适度分离
• 建立学习和迭代的文化

参考资料

• 《这就是OKR》- 约翰·杜尔
• 《OKR工作法》- 克里斯蒂娜·沃特克
• Google re:Work OKR指南

评论和共享

前言

ET框架是一个基于C#的双端（客户端+服务端）游戏开发框架，由熊猫大佬开发维护。它的最大特点是客户端和服务端共用一套代码，大大提高了开发效率。本文将介绍ET框架的核心概念和简单入门。

ET框架特点

1. 双端共用代码

• 客户端使用Unity引擎
• 服务端使用.NET Core
• 网络协议、实体组件等代码可以共用

2. ECS架构

ET采用Entity-Component-System架构：

• Entity（实体）：游戏中的对象，如玩家、怪物
• Component（组件）：实体的数据和行为
• System（系统）：处理组件的逻辑

3. Actor模型

服务端采用Actor模型进行消息处理，每个Actor独立处理自己的消息队列，避免多线程竞争。

项目结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ET/
├── Unity/                    # Unity客户端项目
│   ├── Assets/
│   │   ├── Scripts/
│   │   │   ├── Core/        # 核心框架代码
│   │   │   ├── Model/       # 数据模型
│   │   │   ├── Hotfix/      # 热更新代码
│   │   │   └── ThirdParty/  # 第三方库
│   │   └── Bundles/         # 资源包
├── Server/                   # 服务端项目
│   ├── Model/               # 服务端数据模型
│   ├── Hotfix/              # 服务端热更新
│   └── App/                 # 启动入口
└── Share/                    # 共享代码
    ├── Proto/               # 协议定义
    └── Config/              # 配置文件

核心概念

Entity 实体

1
2
3
4
5
6
7
8
9
10
11

// 定义一个玩家实体
public class Player : Entity
{
    public string Name { get; set; }
    public int Level { get; set; }
}

// 创建实体
Player player = ComponentFactory.Create<Player>();
player.Name = "TestPlayer";
player.Level = 1;

Component 组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 定义移动组件
public class MoveComponent : Component
{
    public Vector3 Position { get; set; }
    public float Speed { get; set; }
    
    public void MoveTo(Vector3 target)
    {
        // 移动逻辑
    }
}

// 给实体添加组件
player.AddComponent<MoveComponent>();

消息处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 定义消息
[Message(OuterOpcode.C2G_Login)]
public partial class C2G_LoginRequest : IRequest
{
    public string Account { get; set; }
    public string Password { get; set; }
}

// 消息处理器
[MessageHandler]
public class C2G_LoginHandler : AMRpcHandler<C2G_LoginRequest, G2C_LoginResponse>
{
    protected override async ETTask Run(Session session, C2G_LoginRequest request, 
        G2C_LoginResponse response, Action reply)
    {
        // 处理登录逻辑
        response.PlayerId = 10001;
        reply();
    }
}

快速入门

1. 环境准备

1
2
3
4
5

# 安装 .NET Core SDK 3.1+
# 安装 Unity 2019.4 LTS

# 克隆项目
git clone https://github.com/egametang/ET.git

2. 启动服务端

1
2

cd ET/Server/App
dotnet run

3. 启动客户端

1. 用Unity打开 ET/Unity 项目
2. 打开场景 Assets/Scenes/Init.unity
3. 点击Play运行

4. 创建第一个功能

以创建一个简单的聊天功能为例：

定义协议 (Share/Proto/OuterMessage.proto)

1
2
3
4
5
6
7
8
9
10
11

message C2G_Chat // IRequest
{
    string Content = 1;
}

message G2C_Chat // IResponse
{
    int32 RpcId = 90;
    int32 Error = 91;
    string Message = 92;
}

服务端处理器

1
2
3
4
5
6
7
8
9
10
11

[MessageHandler]
public class C2G_ChatHandler : AMRpcHandler<C2G_Chat, G2C_Chat>
{
    protected override async ETTask Run(Session session, C2G_Chat request, 
        G2C_Chat response, Action reply)
    {
        Log.Info($"收到聊天消息: {request.Content}");
        response.Message = $"服务器收到: {request.Content}";
        reply();
    }
}

客户端调用

1
2
3
4
5
6

public static async ETTask SendChat(string content)
{
    G2C_Chat response = await SessionComponent.Instance.Session
        .Call(new C2G_Chat { Content = content }) as G2C_Chat;
    Log.Info(response.Message);
}

服务端架构

ET服务端采用分布式架构，主要包含以下进程：

热更新机制

ET支持代码热更新：

• Model层：不可热更新的基础代码
• Hotfix层：可热更新的业务逻辑

1
2

// Hotfix层代码可以在运行时重新加载
// 修改Hotfix代码后，服务端可以不停服更新

总结

ET框架的优势：

1. 开发效率高：双端共用代码
2. 架构清晰：ECS + Actor模型
3. 支持热更新：业务逻辑可热更
4. 社区活跃：持续更新维护

适用场景：

• 中小型网络游戏
• 需要快速迭代的项目
• 熟悉C#的团队

参考资料

• ET框架GitHub
• ET框架文档
• ET框架QQ群

评论和共享

容器简介

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，相互之间不会有任何接口。

CentOS 7 安装docker

安装必要的一些系统工具

1

$ yum update

1

$ yum install -y yum-utils device-mapper-persistent-data lvm2

添加软件源信息

1

$ yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 

更新并安装 Docker

1
2
3
4
5
6
7

$ yum makecache fast
$ yum -y install docker-ce


$ echo 开启容器服务
$ systemctl enable docker
$ systemctl start docker

注意：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ 官方软件源默认启用了最新的软件，您可以通过编辑软件源的方式获取各个版本的软件包。例如官方并没有将测试版本的软件源置为可用，你可以通过以下方式开启。同理可以开启各种测试版本等。
$ vim /etc/yum.repos.d/docker-ce.repo
$   将 [docker-ce-test] 下方的 enabled=0 修改为 enabled=1
$ 
$ 安装指定版本的Docker-CE:
$ Step 1: 查找Docker-CE的版本:
$ yum list docker-ce.x86_64 --showduplicates | sort -r
$   Loading mirror speeds from cached hostfile
$   Loaded plugins: branch, fastestmirror, langpacks
$   docker-ce.x86_64            17.03.1.ce-1.el7.centos            docker-ce-stable
$   docker-ce.x86_64            17.03.1.ce-1.el7.centos            @docker-ce-stable
$   docker-ce.x86_64            17.03.0.ce-1.el7.centos            docker-ce-stable
$   Available Packages
$ Step2 : 安装指定版本的Docker-CE: (VERSION 例如上面的 17.03.0.ce.1-1.el7.centos)
$ yum -y install docker-ce-[VERSION]

注册一个阿里的账号,
进入加速器页面https://cr.console.aliyun.com/#/accelerator

1

$ vim /etc/docker/daemon.json

内容如下

1
2
3

{
"registry-mirrors": ["https://你的阿里云加速地址.mirror.aliyuncs.com"]
}

重启docker

1
2

$ systemctl daemon-reload
$ systemctl restart docker

常用docker命令

查看运行容器

1

$ docker ps

查看所有容器

1

$ docker ps -a

进入容器
其中字符串为容器ID:

1

$ docker exec -it d27bd3008ad9 /bin/bash

1.停用全部运行中的容器:

1

$ docker stop $(docker ps -q)

2.删除全部容器：

1

$ docker rm $(docker ps -aq)

3.一条命令实现停用并删除容器：

1

$ docker stop $(docker ps -q) && docker rm $(docker ps -aq)

安装mariadb

centOS上比yum安装mysql要方便.

###安装mysql-client，用于访问mysql容器数据库

1

$ yum -y install mariadb

单独MySQL模式

1
2
3
4
5
6
7

docker run -d \
-e TIMEZONE=Asia/Shanghai \
-v /data/mariadb-master:/data/mariadb \
-e MYSQL_ROOT_PASSWORD=admin \
-e REPLICATION_PASSWORD=admin \
-p 3306:3306 \
mariadb

MariaDB MASTER

进入容器需要修改镜像
将下面内容添加进/etc/mysql/conf.d/*.cnf
从机server-id=2

1
2
3
4
5

[mysqld]
server-id=1
log-bin=mysql-bin
binlog_format=MIXED
default-time_zone = '+8:00'

提交

1
2

docker commit -m "set log bin on" -a "lional" d27bd3008ad9 mariadb-master:1.0
docker commit -m "set log bin on" -a "lional" d27bd3008ad9 mariadb-slave:1.0

运行master, 这里LOG_BIN参数没有用,所以在上面修改了镜像

1
2
3
4
5
6
7
8
9
10
11

docker run -d \
--restart=always \
--name mysql-master \
-e TIMEZONE=Asia/Shanghai \
-v /data/mariadb-master:/data/mariadb \
-e MYSQL_ROOT_PASSWORD=admin \
-e LOG_BIN=mysql-bin \
-e BINLOG_FORMAT=MIXED \
-e REPLICATION_PASSWORD=admin \
-p 3306:3306 \
mariadb-master:1.0

查询容器的ip地址

1

$ docker inspect --format='{{.NetworkSettings.IPAddress}}' $(docker ps -a -q)  

1

172.17.0.2

链接容器mysql

1

mysql -uroot -padmin -h 172.17.0.2

查看master是否启用了log_bin

1
2
3
4
5
6
7
8
9
10
11
12

MariaDB [(none)]> show variables like '%log_bin%';
+---------------------------------+--------------------------------+
| Variable_name                   | Value                          |
+---------------------------------+--------------------------------+
| log_bin                         | ON                             |
| log_bin_basename                | /var/lib/mysql/mysql-bin       |
| log_bin_compress                | OFF                            |
| log_bin_compress_min_len        | 256                            |
| log_bin_index                   | /var/lib/mysql/mysql-bin.index |
| log_bin_trust_function_creators | OFF                            |
| sql_log_bin                     | ON                             |
+---------------------------------+--------------------------------+

查看主机状态,注意启动从机的时候bin和pos的参数

1
2
3
4
5
6

MariaDB [(none)]> show master status;
+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000003 |      342 |              |                  |
+------------------+----------+--------------+------------------+

添加slave账户

1
2

GRANT REPLICATION SLAVE ON *.* to 'slave'@'%' identified by 'reader';
FLUSH PRIVILEGES;

MariaDB SLAVE

没有sql导入的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

docker run -d \
--restart=always \
--name mysql-slave2 \
-e TIMEZONE=Asia/Shanghai \
-v /data/mariadb-slave:/data/mariadb \
-e MYSQL_ROOT_PASSWORD=admin \
-e LOG_BIN=mysql-bin \
-e BINLOG_FORMAT=MIXED \
-e REPLICATION_PASSWORD=admin \
-e MASTER_LOG_FILE=mysql-bin.000003 \
-e MASTER_LOG_POS=342 \
-e MASTER_PORT=3306 \
-e MASTER_HOST=172.17.0.2 \
-p 3310:3306 \
mariadb-slave2:1.0

先用sql文件导入再同步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

docker run -d \
--restart=always \
--name mysql-master \
-e TIMEZONE=Asia/Shanghai \
-v /data/mariadb-slave:/data/mariadb \
-e MYSQL_ROOT_PASSWORD=admin \
-e BINLOG_FORMAT=MIXED \
-e REPLICATION_PASSWORD=admin \
-e DATABASE_FILE=database.sql \
-e MASTER_LOG_FILE=mysql-bin.000003 \
-e MASTER_LOG_POS=342 \
-e MASTER_PORT=3306 \
-e MASTER_HOST=172.17.0.2 \
-p 3308:3306 \
mariadb-slave:1.0

需要把database.sql文件存提前存放在/data/mariadb-slave目录

进入slaver的mariadb

1

mysql -uroot -padmin -h 172.17.0.3

设置主库链接

1

change master to master_host='172.17.0.2',master_user='slave',master_password='reader',master_log_file='mysql-bin.000003',master_log_pos=342,master_port=3306;

启动从库同步

1

start slave;

查看状态

1

show slave status\G;

当看到

1
2

Slave_IO_Running: Yes
Slave_SQL_Running: Yes

则启动成功

##docker redis 集群（cluster）搭建

顺带完成redis集群,安装依赖

1

$ docker pull redis

1

$ docker pull ruby

创建redis容器

1、创建redis配置文件（redis-cluster.tmpl）

我在路径/root下创建一个文件夹redis-cluster,在路径/root/redis-cluster下创建一个文件redis-cluster.tmpl，并把以下内容复制过去。

10.0.2.15 //自己的服务器ip

1
2
3
4
5
6
7
8

port ${PORT}
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 10.0.2.15
cluster-announce-port ${PORT}
cluster-announce-bus-port 1${PORT}
appendonly yes

创建自定义network

1

$ docker network create redis-net

在/root/redis-cluster下生成conf和data目标，并生成配置信息

1
2
3
4
5

for port in `seq 6379 6384`; do \
  mkdir -p ./${port}/conf \
  && PORT=${port} envsubst < ./redis-cluster.tmpl > ./${port}/conf/redis.conf \
  && mkdir -p ./${port}/data; \
done

创建6个redis容器

1
2
3
4
5
6
7

for port in `seq 6379 6384`; do \
  docker run -d -ti -p ${port}:${port} -p 1${port}:1${port} \
  -v /root/redis-cluster/${port}/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  -v /root/redis-cluster/${port}/data:/data \
  --restart always --name redis-${port} --net redis-net \
  --sysctl net.core.somaxconn=1024 redis redis-server /usr/local/etc/redis/redis.conf; \
done

通过启动ruby来实现集群

1
2
3
4
5
6
7

echo yes | docker run -i --rm --net redis-net ruby sh -c ' \
gem install redis \
&& wget http://download.redis.io/redis-stable/src/redis-trib.rb \
&& ruby redis-trib.rb create --replicas 1 \
'"$(for port in `seq 6379 6384`; do \
echo -n "$(docker inspect --format '{{ (index .NetworkSettings.Networks "redis-net").IPAddress }}' "redis-${port}")":${port} ' ' ; \
done)"

评论和共享

前言

写这篇文章之前,我在想这是属于策划案还是开发框架,最终定位到策划案,希望有更多的游戏设计者能先策划出新的玩法,再来定开发框架.
本文所述并未实现过任何代码,也并未用于任何上线产品,纯属概念模型.之所以有这种想法,可能是基于昨晚的一次灵感,以及即将设计的游戏有关.

第一章 去中心化概念

其实最简单的去中心化游戏就是单机游戏和局域网游戏,但是本文要讲诉的是mmo网络游戏的去中心化,为什么既然网络化了又要去中心化,这不是矛盾吗.
网络游戏有个通病,就是网速影响游戏体验过,这是客户端所直接反映的问题,服务端反应的你不能直接感受到的问题,很难做到全球同服,什么意思呢,就是所有玩家不全是在一台服务器上
因为服务器是有瓶颈的,本身计算量很大的情况下,socket能承载同时单服1W人在线就很不错了,像coc这种全球一个服的游戏很少,这种服务器的架构就很复杂,绝大部分网游就是分区,另一个好处就是分区重新开始游戏,可以解决通货膨胀问题.coc玩到满级满王满墙也就没有玩下去的动力了.另一方面,单机游戏比起网游,不具备强交互能力,可玩性,游戏性大打折扣.如果做到既能联网交互,又可以不靠网络来获得体验,由客户端去演算游戏逻辑,极大降低服务端成本,这就是本文想探讨的去中心化的游戏.像王者荣耀这样的moba游戏已经很接近本文所说的功能了,但是还是有所区别.至于什么区别读完本文可能有个大致了解.本文要探讨的不是moba,也不是rpg,亦或是slg这些类型,而是总的游戏设计方法.去中心化,没有中心服务器,可以是弱联网,亦或是强联网,核心是有各自客户端或是区域链来演算游戏的逻辑,然而还是有一处中心化得服务器为大家来解决统一数据问题,例如物品交易,这点类似于比特币

第二章 比特币模型

我大概简单的描述一下比特币,这也是去中心化的基石.比特币是一种符合某种算法结果的数字货币,什么意思呢,比如在某一个坐标区域,坐标值代入md5公式,能得到一个符合”x01”字符串的值,那么就认为你找到一枚数字货币,而且这个货币还能定义下一个坐标区域,也就是说,当前区域总的货币数量是一定的,没有挖掘完之前,也无法开采下一个坐标区域.比特币的函数要比我所述的复杂,但基本上是这个意思,算法是公开的,能得到的货币是有限的,一旦挖掘到货币就与中心服确认,并且获得所有权.那如果把这个模型改造一下.游戏币是从boss掉落的,或者生产制作的.或者任务获得的,假设boss,制作工具,任务都有一个gid,全局唯一ID,而且产生的作者也有个唯一uid,再加上创造出来的时间戳time,那我们可以拿着这些数据,到服务器去鉴别真伪,中心服务器会保存一个私钥,给gid+uid+time+key签名,这个货币就有一个串值,如果同一个uid复制多个货币,因为签名一样,也会被认为是一个货币而删掉其他,如果发生交易,那么这个货币还要一个交易序列,给gid+uid+time+trade+key签名会成为新的串值,而中心服会保存所有货币的最新值,也就是说两个玩家拥有了同样的货币,看他们串值是否是最新的,那么鉴别为旧版货币的就是假币.如果都修改成同一串值,那么看交易序列的最后拥有者是谁,谁就是真币.这是我想到的数字货币模型,但是如果作为游戏币,每一个货币都要保存很多值,所以我更倾向于付费可交易货币做这种去中心化的真伪模型,比如银票.而不能交易的游戏币还是只是简单的数字.

第三章 装备模型

上述所说比特币模型,数字货币模型,如果直接引用到装备模型,完全可以像数字货币一样,做到去中心化的真伪模型,玩家获得一件装备,属于未鉴定状态,需要向中心服鉴别真伪,如果为伪,那装备没有加成的属性.我们还需要处理的一件事情是防止玩家直接对真实装备改值,这需要第一,配置表的时候就生产一个验证,是否是改过配置表,第二,生成装备的时候要要把属性加入到串码算法中.玩家战斗时检测装备正确性,因为是客户端自己验算,所以也不会对服务端产生压力,目前客户端性能越来越强大,对于简单的演算还是可以接受的.

第四章 函数逻辑模型

所有的演算,逻辑都在客户端,或者说区域链服,可以把区域链服理解为几个人组局域网后其中一个人为主机的概念,那么客户端也可能对函数进行作弊,这种无法从任何算法上解决,但去中心化还有种思路是,可以认同50%以上的逻辑为正确的逻辑,也就是说假如我5个人联网,有3个人结果一致,就按这3个人的逻辑,如果5个人结果都不一致,那么此次验证失败,那么只要大部分的人保持正确心态,可以容忍少部分人作弊,也只能是自己单机演算作弊,假如多数人作弊的情况下,大环境下也可以认可是公平的.只是作为运营的我们收入大大折扣了,所以要防止这种事情发生.另外,如果防止单机作弊,我的想法是每次函数堆栈(重要的战斗算法)要保存起来参数,返回值,这些,传给服务器做一个校正,是否真伪,如果作弊可以纳入非诚信玩家,并给与一定惩罚

第五章 其他中心化包含的内容

有些内容是无法去中心化的,比如全局装备鉴别,货币鉴别,装备交易,玩家排行榜,世界聊天,世界地图等这些本身就是要做中心化的交互,所以这里不予讨论,这里只是把战斗,组队,装备掉落这些耗时的主要逻辑在客户端来演算,来增加体验和性能.

后记

说了这么多,其实还并没有实现一个基于这个想法的游戏.如果把RPG设计成去中心化,要解决大地图的问题,如果大地图还是中心服那就没有意义,还是需要处理很多逻辑,所以这个适合跑大地图,进副本战斗和回合制战斗的RPG游戏.如果把MOBA设计成去中心化,那其实就是当年的魔兽,星际,只是主机不是一台,而是多台,以大多数人的演算为准,个人感觉,意义也不大,直接做局域网的游戏就可以了,只是加个中心交互,如果用来做SLG,感觉还是不错的,试想一下三国志并不是你一个人在攻城略地,有没有很刺激.如果做其他的小地图副本游戏也是可以的.当然这个设计也是有弊端的,你需要容忍数据不能像ARGP那样及时同步,因为你无法保证组队的5个人每个人的网络都很好,万一有个别人卡住,要么踢掉他,要么等他回来的验算结果.其他的弊端暂未想到,欢迎一起来讨论

评论和共享

Foreword

I have been looking for such a blog, strong self-confidence like WordPress.
And Spending dollars to buy the domain name and server space is prerequisite.
I never thought that a free and almost unlimited freedom blog exist.
Hexo just like this. A fast, simple & powerful blog. I did not hesitate to try it.
So far so amazing.

Quick Start

First

Let’s introduce how to set up hexo.
Please Download nodejs from http://nodejs.org.
I get node-v4.2.2-x64.msi.
then double click to install nodejs.
Keep the default configuration to direct the installation.

1

$ npm install -g hexo-cli

Setup your blog.

make a name in the computer called “YOU NAME” folder (for example, I make dir in D:\workspace\OSGDreamWorks\ibunnyteam.github.io).
then open this folder, run the following command.

1
2
3
4

$ hexo init
[info] Copying data
[info] You are almost done! Don't forget to run `npm install` before you start b
logging with Hexo!

Hexo will automatically create a file in the target folder that website require.
Then follow the prompts to run npm install (in “YOU NAME” folder).

1

$ npm install

then you can get the node_modules.
All work will be done automatically by nodejs.

Start the server

Run the following command (in “YOU NAME” folder).

1
2

$ hexo server
[info] Hexo is running at http://localhost:4000/. Press Ctrl+C to stop.

Then you can open the local blog. easy, all right!

Create a new post

Open a new command-line window, execute the following command

1
2

$ hexo new "My New Post"
[info] File created at d:\Hexo\source\_posts\My-New-Post.md

Refresh http://localhost:4000/，you can see the “My New Post”。

Generate static files

执行下面的命令，将markdown文件生成静态网页。

1

$ hexo generate

After this command is executed, it will be generating a series of html, css and other documents in public directory.

Upload the blog

Now you only have established a local blog.
How others see your blog.
You need github. Also amazing project.
your can know every thing in github.comhttps://github.com/

continue

Deployed to the former Github need to configure _config.yml file, first locate the following content.

1
2
3
4

# Deployment
## Docs: http://hexo.io/docs/deployment.html
deploy:
  type:

Changed to:

1
2
3
4
5
6

# Deployment
## Docs: http://hexo.io/docs/deployment.html
deploy:
  type: git
  repository: git@github.com:ibunnyteam/ibunnyteam.github.io.git
  branch: master

NOTE1:

Repository: SSH form must be url (git@github.com: ibunnyteam / ibunnyteam.github.io.git), but can not be HTTPS form url (https://github.com/ibunnyteam/ibunnyteam.github.io. git), otherwise an error:
You need named the repository YOU_GITHUB_ACCOUNT.github.io then you can open the github static web.

1
2

$ hexo deploy
[info] Start deploying: github

Use SSH url, if the computer is not an open SSH port will cause the deployment to fail.

1
2
3
4
5

[error] https://github.com/ibunnyteam/ibunnyteam.github.io is not a valid repositor URL!
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

NOTE2：

If you are making a project website, then you need to branch to gh-pages.

Last

you can make a domain name with the github static web.

The short command for hexo:

new blog

1

$ hexo n

generate

1

$ hexo g

upload

1

$ hexo d

Have fun

评论和共享