Skip to content
J.R.
日本語 EN 中文

04 / 05 · 2023.07 — 2024.07

Guangzhou Chenchuang Technology Development Co., Ltd.

Backend and agent work on a simulation product line: the main business service, engine lifecycle management and multi-user co-editing of a battlefield-simulation platform in Go (Gin), plus Python integration with a C++ wargaming platform, red/blue agents and a live monitor.

Role
Python Developer
Industry
Simulation & wargaming (research software)
Location
Beijing
Tenure
1 yr 1 mo

Key results

  • ~100

    Endpoints in the main business service, across 17 modules — models, entities, equipment, dictionaries, templates, scenario versions

  • 38

    Wargaming-platform integration interfaces wrapped over ZeroMQ + Protobuf

  • 16

    Entered agents deployed and evaluated (rule-based, ML, deep networks)

Projects here

PROJECTS · 2

2023.07 – 2024.07（1 yr） · Backend developer (Go / Python)

Battlefield Parallel Simulation System

The company's core product: a browser-based battlefield-simulation platform for research institutes. Users compose scenarios on a 3D digital globe, push them to a simulation engine with one click, and get live situation display, multi-user co-editing, recording/replay and effectiveness evaluation.

  • Designed and built the main business service (Gin + MongoDB) in router/controller/service/model layers — 17 modules and about 100 endpoints covering models, entities, equipment, data dictionaries, templates and scenario versions
  • Designed simulation-engine lifecycle management: dynamic port allocation, scenario export as engine input, process launch and registration via os/exec, goroutines that detect exit and reclaim resources — supporting several simulations in parallel
  • Implemented multi-user scenario co-editing with a WebSocket hub and per-task rooms: separate read/write goroutines with heartbeat, a flattened scenario-tree index cache, and incremental command broadcast
  • Built the operator service: scenario JSON → external simulation-engine XML conversion (3,000+ lines) and GeoJSON area/intersection/union computation; per-frame situation recording with pause, speed control and timeline replay
  • Wrote the engine console in Go: connects to the scheduler over TCP, relays engine commands, and exposes HTTP endpoints to start, pause and resume a simulation
  • Built a radar-signal generation service with Tornado + SciPy (chirp pulses, clutter, echoes), generated asynchronously on background threads and deployed with Docker
  • Go
  • Gin
  • MongoDB
  • MySQL
  • Redis
  • NSQ
  • WebSocket
  • Python
  • Tornado
  • SciPy
  • Docker

System architecture

Overall system architecture
L1 Browser Scenario editor Vue 2 + Cesium 3D globe multi-user co-editing Simulation control start / pause / resume speed · timeline Situation display 3D view · record & replay effectiveness evaluation L2 Services (Go) Main service (Gin) 17 modules · ~100 endpoints router / controller / service / model WebSocket hub per-task rooms read/write goroutines + heartbeat Operator service scenario JSON → engine XML (3000+ lines) GeoJSON spatial ops · recording L3 Engine control Engine lifecycle dynamic ports · os/exec spawn goroutine reclaims on exit Engine console (Go) TCP to scheduler · relays commands start / pause / resume over HTTP Radar-signal service Tornado + SciPy · Docker chirp pulses · clutter · echoes L4 Engine & storage Simulation engine (external) runs the scenario · streams situation back Storage & messaging MongoDB · MySQL · Redis · NSQ
Live monitor (PyQt5): red/blue units and damage on separate tabs — rendered here by replaying saved offline match data

2023.07 – 2024.07（8 mos） · Python developer — agents and platform integration

Intelligent adversarial wargaming

A command-and-decision agent project for an unmanned air-sea scenario (island defence vs carrier strike group). A C++ wargaming platform adjudicates; on the Python side I built the platform integration, the red and blue agents and a live monitor of the engagement.

  • Built the platform-integration layer over ZeroMQ (REQ + DEALER) and Protobuf, wrapping 38 interfaces — simulation control, unit/task/damage queries, routes, take-off, grouping; a runner drives the observe → decide → command loop at a fixed step and scores the outcome
  • Red defence agent: staged decision-making — perception, information fusion, missile/gun/laser fire allocation, strike verification. Blue attack agent: multiple courses of action, drone-squadron launch and saturation strikes
  • Deployed and evaluated 16 entered agents (rule-based, ML, deep networks), resolved dependency and runtime problems, dissected representative strategies and gave a tech talk
  • Agent state is published over MQTT; built a PyQt5 live monitor with tabs for red/blue units and damage, plus per-round offline dumps for review
  • Python
  • ZeroMQ
  • Protobuf
  • MQTT
  • PyQt5
  • NumPy

System architecture

Integration layer and agent architecture
L1 Platform (C++) Wargaming platform adjudicates the simulation and damage L2 Integration (Python) ZeroMQ (REQ + DEALER) request / reply channels Protobuf messages serialises simulation data 38 wrapped interfaces control · unit / task / damage queries routes · take-off · grouping L3 Main loop Runner fixed step: observe → decide → command Scoring per-round results L4 Agents Red defence agent perception → fusion fire allocation → strike check Blue attack agent multiple courses of action drone squadrons · saturation strike Entrant evaluation 16 deployed · dependency fixes dissect representative strategies L5 Monitoring MQTT publish agent state PyQt5 live monitor tabs: red/blue units and damage Offline dumps for review saved per round

System data flow

Abstract sketch · no internal details

  1. Scenario editor

    Vue + Cesium · WebSocket co-editing

  2. Gin main service

    17 modules · ~100 endpoints

    ▲ My part

  3. Operator service

    Scenario JSON → engine XML

    ▲ My part

  4. Engine console

    Go · relays commands over TCP

    ▲ My part

  5. Simulation engine

    Run · situation feedback

  6. 3D display

    Situation · replay

Team & daily life

Photos are shared with colleagues' consent, or other people's faces are blurred

What I learned here

On the simulation product line I wrote server-side Go for the first time: goroutines and a WebSocket hub for multi-user co-editing, os/exec to manage the simulation engine’s process lifecycle, and how to organise a service of about 100 endpoints into router / controller / service / model layers.

The other thread was Python integration with a C++ wargaming platform — agents and a live monitor on top of ZeroMQ + Protobuf. Deploying and evaluating 16 entered agents let me dissect representative rule-based, ML and deep-network strategies, and I gave a tech talk on them.

TECH STACK

  • Go
  • Gin
  • Python
  • Tornado
  • MongoDB
  • MySQL
  • Redis
  • NSQ
  • WebSocket
  • ZeroMQ
  • Protobuf
  • MQTT
  • PyQt5
  • Vue 2
  • Cesium
  • Docker