Engineering
How the games are built
Game development spans client, gameplay and server. These are the areas I work in and the principles I apply — without exposing any proprietary code.
Cocos Creator
Scene and component architecture for HTML5 games built in Cocos Creator.
- Component-based scene structure with clear ownership of state and presentation.
- Prefab and asset organisation that keeps projects maintainable as they grow.
- Build configuration for web targets and embedded viewports.
TypeScript
Typed game and tooling code that catches mistakes before they reach a build.
- Strict typing for game state, configuration and server payloads.
- Shared types between client code, tools and tests.
- Small, composable modules rather than monolithic game scripts.
HTML5 game UI
Game interfaces that adapt to portrait, landscape and embedded layouts.
- Responsive HUD and control layouts driven by viewport and safe-area constraints.
- Readable typography and touch targets at small sizes.
- UI state kept in sync with game state through a single source of truth.
Gameplay & animation
Presentation layered on top of game logic, never mixed into it.
- Separating simulation/outcome logic from animation and effects.
- Sequencing systems for wins, transitions and feature rounds that can be skipped or sped up safely.
- Respecting reduced-motion and performance budgets on lower-end devices.
Java & Spring Boot
Backend services that support games and their tooling.
- REST services with validation and clear error contracts.
- Layered service design that keeps business rules testable.
- Configuration and environment handling for multiple deployment stages.
REST & WebSockets
Request/response and real-time channels between clients and services.
- Choosing between request/response and push based on the interaction.
- Message schemas, versioning and defensive parsing on both ends.
- Reconnection and state-recovery strategies for unreliable networks.
Unity3D, C# & mobile
Game clients beyond the browser, including native Android apps.
- Unity3D game clients written in C#, alongside Cocos Creator and Egret Wing projects.
- Native Android development and mobile distribution.
- In-app purchases, advertising and game center integrations for mobile games.
Testing & QA
Verification that covers the paths players actually take.
- Unit tests for game logic and data transformations.
- Scenario and replay-based checks for feature paths and edge cases.
- Browser-based end-to-end checks across device sizes before release.
Deployment
Repeatable builds and releases.
- Automated build pipelines with checks that block broken releases.
- Static hosting and CDN delivery for web game assets.
- Environment-specific configuration without leaking secrets into client bundles.
Architecture
Selected case studies
Architecture write-ups from real projects, focused on the problem, the approach and how it was verified.
Detailed architecture case studies will be published alongside the game case studies.