Gameplay Programmer | Unity / C# | Unreal Engine / C++ | Backend & Game Services
Brazil • Porto Alegre, RS • +55 (62) 98114-7008 • andersonfilho09@gmail.com

GitHub • LinkedIn • Itch.io

Gameplay Programmer with a strong software engineering background, focused on building scalable gameplay systems, AI behaviors, modular architectures and player-facing mechanics.

I have hands-on experience with Unity/C# and Unreal Engine/C++, including gameplay systems, multiplayer concepts, Gameplay Ability System, plugin development and published playable projects. My background also includes professional experience in backend engineering, APIs, clean architecture, distributed systems, asynchronous workers, integrations and production-oriented software development.

Currently pursuing an MSc in Computer Science at UFRGS, researching Game AI, Multi-Agent Systems, Planning and Reinforcement Learning, with a focus on practical applications for NPC behavior, adaptive AI and systemic gameplay.

My long-term focus is the intersection between gameplay programming, AI systems, tools engineering and backend/game services.

• Gameplay Systems Architecture
• Unity / C# Gameplay Programming
• Unreal Engine / C++ Gameplay Programming
• AI Programming: HTN, GOAP, Behavior Trees and Reinforcement Learning
• Multiplayer and Networked Gameplay Concepts
• Data-driven Gameplay Design
• Tools and Plugin Development
• Modular and Scalable Game Architecture
• Backend / Game Services
• Distributed Systems for Gameplay, LiveOps and Tooling

• C++
• C#
• Python
• Java
• TypeScript
• C

• Unity
• Unreal Engine 5
• Gameplay Ability System
• Blueprints
• State Machines
• Behavior Trees
• 2D Gameplay
• FPS Mechanics
• Gameplay Systems
• Multiplayer / Networking Concepts
• Game Architecture
• Game AI

• SOLID
• Design Patterns
• DDD
• TDD
• Clean Architecture
• Hexagonal Architecture
• REST APIs
• Git
• Docker
• CI/CD

• Python / FastAPI
• Java / Spring Boot
• PostgreSQL
• SQLAlchemy
• Alembic
• Redis
• RabbitMQ
• JWT / RBAC
• Webhooks
• HMAC Authentication
• Async Workers
• API Integrations

• Docker
• Terraform
• GCP
• Azure DevOps
• GitHub Actions
• CI/CD Pipelines

• Angular
• React
• TypeScript

• Portuguese — Native
• English — C1 Advanced

Solo Developer · C/C++ · Allegro · Windows/Linux
Playable build: The Invasion on Itch.io

A retro-inspired arcade space shooter developed entirely in C++ with Allegro, without using a commercial game engine. The project was built as a foundational exercise in low-level game development, covering the full gameplay loop, rendering, input, collision, audio and score systems.

This project is especially important to me because it was developed during my first semester of college and represents the beginning of my journey into software development and game programming.

Main contributions:

• Built the full game loop from scratch.
• Implemented player movement, shooting, enemy waves and collision detection.
• Created a persistent high score system.
• Implemented dynamic difficulty progression.
• Developed a scrolling starfield background and retro arcade-style presentation.
• Handled rendering, input processing, basic physics and audio integration without an engine.

Tech stack:
C++ C Allegro Game Loop 2D Rendering Collision Detection Input Handling Audio Arcade Shooter

Solo Developer · Unity · C# · 2D Remake · In Development

A 2D remake of my original C/C++ arcade shooter The Invasion, rebuilt from the ground up in Unity with a stronger focus on gameplay architecture, game feel, progression and scalable systems.

The project keeps the spirit of the original arcade shooter while rebuilding its technical foundation with modern Unity/C# practices.

Planned focus:

• Rebuild the original game as a 2D Unity project.
• Improve the original arcade shooter gameplay loop.
• Implement cleaner player movement, shooting, enemies and wave systems.
• Build modular gameplay systems using C#.
• Create data-driven enemy, weapon, upgrade and wave definitions.
• Improve game feel, feedback, UI, audio and progression.
• Apply SOLID, design patterns and testable code organization where useful.
• Use the project as a long-term case study in Unity gameplay architecture.

Planned systems:

• Player movement and shooting
• Enemy wave spawning
• Weapon and projectile systems
• Temporary run-based upgrades
• Permanent progression
• Boss encounters
• Score and resource economy
• Data-driven content through ScriptableObjects

Tech stack:
Unity C# 2D Gameplay Arcade Shooter Roguelite ScriptableObjects Gameplay Architecture SOLID

Gameplay Programmer · Unity · C# · FPS Prototype
Playable build: Enhanced Shots on Itch.io

A first-person shooting range game focused on precision, reflexes and strategy. The project includes a special mode called R U Lucky, where players use strategic cards and special targets to change the flow of the match.

The game combines FPS mechanics with score-based progression, temporary buffs, special target effects and tactical grenade usage.

Main contributions:

• Implemented core FPS shooting mechanics.
• Developed card-based gameplay modifiers such as reload speed, precision, score multiplier and extra time.
• Implemented special targets with unique gameplay effects.
• Added explosive and freezing grenade mechanics.
• Structured gameplay systems around score progression, timed challenges and player feedback.
• Worked on gameplay flow, balancing and interaction logic.

Gameplay features:

• Strategic cards affecting reload speed, recoil, score and time.
• Special targets such as bomb targets, turtle targets, multiplier targets and infinite ammo targets.
• Explosive and freezing grenades.
• Mouse-based aiming, shooting, reload and tactical inputs.
• Score-chasing gameplay loop.

Tech stack:
Unity C# FPS Gameplay Systems Card Mechanics Scoring System Power-ups

Programmer & Game Designer · Unity · C# · 2D Side-Scroller Survival/Stealth Prototype
Status: Jam prototype / Post-jam remake planned

A game concept started during Global Game Jam 2026 under the theme Mask. The jam version was not fully completed within the 48-hour timeframe, but it established the core concept, visual direction and gameplay foundation for a future remake.

The project is being rebuilt as a more complete Unity/C# 2D side-scroller survival/stealth game, inspired by the side-view structure of games like This War of Mine, focused on mask-based disguise, inventory management, enemy reactions and mansion exploration.

Concept:

The player must survive the night inside a mansion filled with hostile creatures. The game uses a side-view perspective where the player explores rooms, manages limited resources, avoids enemies and uses masks as temporary disguises or survival tools.

Masks allow the player to hide their identity, deceive enemies, access specific areas or survive dangerous encounters. Each mask has limited durability, forcing the player to decide when using one is worth the risk.

Main focus:

• Side-scroller survival gameplay
• Mask-based disguise mechanics
• Room-by-room mansion exploration
• Inventory and item interaction
• Enemy patrol, detection and chase behavior
• Stealth and social disguise mechanics
• Resource management under pressure
• Survival loop during a hostile night
• Remake from jam prototype into a polished playable build

Tech stack:
Unity C# 2D Gameplay Game Jam Side-Scroller Survival Stealth Inventory Prototype

Unity Developer · Unity · C# · 3D Simulation
Playable build: Solar System Simulation on Itch.io

A 3D Solar System simulation developed as part of the Game Design and Development Specialization by Michigan State University on Coursera. The project demonstrates core Unity skills such as 3D scene organization, object positioning, materials, lighting and camera behavior.

Main contributions:

• Built a 3D solar system scene with planets orbiting the Sun.
• Implemented camera behavior to follow selected planets.
• Added a top-down mini-map view to track celestial bodies.
• Configured dynamic materials and textures for planets.
• Implemented central lighting using a Sun-like point light.
• Organized the Unity hierarchy and project folders following clean project structure practices.
• Added randomly spawning comets to improve scene dynamism.

Tech stack:
Unity C# 3D Simulation Camera Systems Materials Lighting Scene Organization

Full-Stack / Backend Developer · Python · FastAPI · Angular · Distributed Systems
Status: Production-oriented system / Freelance project

A waste management and ESG platform focused on MTR emission, service orders, company management, authentication, multi-tenancy, asynchronous processing and integration with external government systems.

The project uses a modular backend architecture with DDD, Hexagonal Architecture, async-first FastAPI services, workers, queues, tenant-aware authorization and production-oriented infrastructure.

Main backend contributions:

• Designed and implemented async REST APIs using Python 3.12 and FastAPI.
• Structured the backend as a modular monolith with bounded contexts.
• Worked with modules such as Identity, MTR, ESG, Operations and Notifications.
• Implemented JWT authentication, Argon2 password hashing and RBAC.
• Implemented multi-tenancy using request-scoped company context.
• Integrated tenant-aware access control using X-Company-ID.
• Built asynchronous MTR emission flows using RabbitMQ workers.
• Used retry queues, DLQ patterns and idempotent processing.
• Integrated with SIGOR-SP external APIs for MTR-related operations.
• Implemented webhook security using HMAC authentication.
• Worked with rate limiting, idempotency keys and correlation IDs.
• Used PostgreSQL, SQLAlchemy 2.0 async, Alembic, Redis and RabbitMQ.
• Applied SOLID, typed Python, Pydantic v2 and production-oriented validation.
• Worked on testing, mypy compliance and API documentation.

Main frontend contributions:

• Developed Angular features for ESG and MTR flows.
• Built screens for MTR emission, status polling and PDF download.
• Worked with API integration, forms, state handling and UI feedback.
• Helped structure frontend modules for better maintainability.

Technical highlights:

• Modular monolith architecture
• Domain-driven design
• Hexagonal architecture
• Async-first backend
• Tenant-aware authorization
• HMAC-secured webhooks
• RabbitMQ workers with retry/DLQ
• PostgreSQL persistence
• Redis caching and locking
• External API integration
• Production deployment with Docker Compose

Tech stack:
Python 3.12 FastAPI PostgreSQL SQLAlchemy Alembic RabbitMQ Redis Pydantic JWT RBAC Docker Angular TypeScript DDD Hexagonal Architecture

Full-Stack Developer · Java Spring Boot · Angular

A full-stack platform for managing tabletop RPG sessions, focused on character sheets, NPCs, enemies, dice history and combat control.

Main contributions:

• Built backend services using Java and Spring Boot.
• Created frontend features with Angular.
• Designed systems for customizable character sheets and RPG rules.
• Implemented structured data models for campaigns, NPCs and combat.
• Applied scalable architecture for complex rule-based systems.

Tech stack:
Java Spring Boot Angular PostgreSQL REST API RPG Systems

Backend Developer · Java Spring Boot · Machine Learning

A recommendation system prototype focused on games, combining backend development, REST APIs and machine learning concepts.

Main contributions:

• Built backend services with Java and Spring Boot.
• Designed REST API endpoints for recommendation flows.
• Worked with PostgreSQL and structured data persistence.
• Participated in design thinking and agile prototyping.
• Delivered a functional prototype using ML-oriented logic.

Tech stack:
Java Spring Boot PostgreSQL REST API Machine Learning

Backend / AI Developer · Python

An end-to-end modular audio processing pipeline using FFmpeg, Whisper AI and Pyannote, designed with independently replaceable modules.

Main contributions:

• Built a modular pipeline architecture in Python.
• Integrated audio processing and AI-based transcription components.
• Designed the system to support evolving requirements and independent module execution.
• Worked with FFmpeg, Whisper AI and Pyannote.

Tech stack:
Python FFmpeg Whisper AI Pyannote Modular Architecture

Solo Developer · Python · Automation

A Python automation script for translating Stardew Valley mod files, focused on recursive JSON processing and localization workflows.

Main contributions:

• Automated recursive translation of JSON files.
• Integrated Google Cloud Translation API.
• Helped streamline i18n workflows for mod localization.
• Built a practical tool for game community content.

Tech stack:
Python Google Cloud Translation API JSON i18n Automation

2025 – Present · Freelancer · Remote

• Developed a production-oriented ESG/waste management platform using Python, FastAPI, Angular and PostgreSQL.
• Worked on MTR emission flows, service order features, company management, authentication and external API integrations.
• Applied DDD, Hexagonal Architecture, SOLID and async-first backend design.
• Implemented JWT/RBAC authentication, tenant-aware access control and request-scoped company context.
• Built asynchronous workers with RabbitMQ, retry queues and DLQ handling.
• Used Redis for caching, locking, idempotency and rate-limiting support.
• Integrated with external government systems for waste transport documentation.
• Contributed to frontend modules using Angular and TypeScript.

Mar 2026 – Present · Porto Alegre, RS, Brazil

• Researching Reinforcement Learning optimization and efficiency applied to Game AI.
• Studying hierarchical planning approaches such as HTN and GOAP for intelligent NPC behavior.
• Bridging academic AI concepts with practical game development use cases.

Apr 2025 – Mar 2026 · CEIA · Goiânia, GO, Brazil

• Developed scalable APIs and AI pipelines using Python and FastAPI.
• Worked on modular architecture, performance, reliability and production-oriented services.
• Applied clean code, testing practices and versioned API design.

Feb 2024 – Nov 2024 · LabTIME / UFG · Goiânia, GO, Brazil

• Developed gameplay systems using Unreal Engine 5 and C++.
• Worked with Gameplay Ability System, modular gameplay features and multiplayer concepts.
• Co-architected a reusable Unreal Engine plugin following SOLID principles.
• Contributed to educational and entertainment-oriented interactive projects.

Nov 2024 – Apr 2025 · Goiânia, GO, Brazil

• Delivered full-stack features using Angular, React, Python, FastAPI and Spring Boot.
• Designed and implemented scalable system components.
• Built an internal LLM/RAG chatbot to support team workflows.

Oct 2021 – Aug 2023 · Goiânia, GO, Brazil

• Maintained enterprise ERP systems using Spring Boot, Angular and SQL.
• Built ETL pipelines using Python and Node.js.
• Worked with GCP, Terraform and Azure DevOps for automation and deployment workflows.

In progress

Focus areas:

• AI for Games
• Multi-Agent Systems
• Reinforcement Learning
• Planning
• Game AI
• NPC Behavior

2020 – 2025

Focus areas:

• Software Engineering
• Game Development
• Backend Systems
• AI and Data Systems

• Advanced Software Testing & QA — UFG / Penn State University
• Advanced English C1 — Cultura Inglesa

• Participated in the game development community through Global Game Jam activities.
• Worked under short production cycles and rapid prototyping constraints.
• Started a Unity/C# 2D side-scroller survival/stealth concept based on the theme Mask.

• Provided teaching support in programming and computing fundamentals.

• Contributed to web development and Agile collaboration activities.

• Game Development
• Gameplay Architecture
• Game AI
• AI and Emergent Gameplay
• RPG Systems
• Action RPGs
• Sci-Fi
• Tools Development
• Technical Game Design
• Backend / Game Services
• Distributed Systems for Games

• GitHub: github.com/AndersonGACFilho
• LinkedIn: linkedin.com/in/agacf
• Itch.io: vertex-shift.itch.io
• Email: andersonfilho09@gmail.com