rpgCore
The Problem
My Approach
Key Highlights
How It Works
[!IMPORTANT] rpgCore has been succeeded by OperatorGame. While the technical foundation of rpgCore remains a valid architectural study, the development has shifted to the Rust-based Operator engine for production-grade performance and cross-platform mobile stability.
The Problem
Build a flexible game engine capable of powering multiple game genres (space shooters, RPGs, tycoon games) with integrated AI learning systems. The challenge was bridging Python’s scripting capabilities with Godot’s visual rendering while maintaining clean separation of concerns.
My Approach
→ ECS Architecture: Entity-Component-System for decoupled game logic.
→ Godot 4.x C# Frontend: Rendering and visual debugging layer.
→ Python Core Engine: NEAT genetic algorithm for AI training.
→ IPC Communication: Socket-based messaging between C# and Python.
Key Highlights
- 1,400+ lines of well-tested core engine code.
- 31/31 tests passing (100% pass rate).
- Complete architecture documentation (
DELIVERABLES.md,BUILD_PIPELINE.md). - Multi-genre support: Space, RPG, Tycoon compatible.
- NEAT AI integration showing neural network evolution visualization.
How It Works
rpgCore represented my most ambitious technical project—a production-grade game engine built as a proof of concept for cross-language architecture at scale.
The Challenge
Most game engines are monolithic, written in a single language. I wanted to explore what happens when you intentionally separate concerns: high-level game scripting in Python, real-time rendering in C#/Godot, and AI training in a separate Python process.
Architecture Highlights
The system consists of three tightly coupled components:
- Python Core Engine: Houses all game state, physics, AI logic, and ECS framework. Uses Pydantic for configuration.
- Godot Frontend: C# layer handles rendering and visual debugging. Communicates with Python core via socket IPC.
- NEAT Integration: Neural networks evolve through genetic algorithm, learning to play games through environmental feedback.
Lessons Learned
This project taught me that architectural clarity often matters more than raw performance for game prototyping. The benefits of clear separation of concerns outweighed the overhead of socket communication. This 100% test pass rate gave me the confidence to refactor aggressively, a principle that carried over to its successor, OperatorGame.