GONÇALO PIRES

MY PROJECTS

1 / 3
EGO EGO
EGO In Development
Carzinga CARZINGA
Carzinga EARLY DEVELOPMENT
Multiplayer MULTIPLAYER C++
Multiplayer Replication

PROJECT : EGO

In Development

Role: Gameplay & UI Programmer
Focus: Multiplayer Possession, MVVM UI & Component Architecture
Year: 2026 (August - Present)

UE5 C++ 2 👥

An asymmetrical multiplayer Unreal Engine 5 dungeon crawler where a Hero battles through monster- and trap-filled rooms while rival Demon players possess AI Monsters, dungeon traps, and fallen Heroes in real time.

01. Asymmetrical Possession, AI Brain-Swapping & "Proxy Pawn" Traps

  • Unified Possession Interface (IPossessableInterface): Demon players fire a server-authoritative line trace (Server_AttemptPossession) to possess three distinct actor categories: AI Monsters, static Dungeon Traps, and fallen Hero bodies (blocking self-possession via PreviousOwnerController).
  • The Trap "Proxy Pawn" Pattern (ATrapBase & ATrapProxyPawn): Because traps are lightweight AActor instances rather than Pawns, possessing a trap dynamically spawns a transient ATrapProxyPawn linked to the trap, giving the Demon player a dedicated camera and custom EnhancedInput bindings to fire traps manually.
  • AI-to-Player "Brain Swapping" & Role-Based Visibility: Possessing an AI Monster pauses its UBrainComponent Behavior Tree (StopLogic) while the player drives it, and restores control to DefaultAIController on eject. Trap possession indicators automatically hide for Hero clients while displaying player-colored materials for Demons.

Testing Area — Possessing Monster

Testing Area — Possessing Trap

02. Decoupled C++ MVVM UI, Retry-Linking & Contextual Menus

  • Inheritance-Based ViewModels (UCombatHUDViewModel & UHeroHUDViewModel): Built a base ViewModel broadcasting normalized Health/Energy percentages via UE_MVVM_SET_PROPERTY_VALUE, and extended it into UHeroHUDViewModel to bind 8+ equipment slot icons and potion stack counts at runtime via UMVVMSubsystem.
  • Contextual Chest Comparison & 3D Shop Camera Blending (UHeroUIManager & AShop): Interacting with a chest instantiates a UMVVM_Chest ViewModel comparing the Hero's current weapon against the chest's weapon and refreshes via Client_RefreshChestUI after a server-validated swap. Interacting with the Shop blends the player's camera between physical 3D Weapon and Trinket counters (SetViewTargetWithBlend).
  • Asynchronous Cross-Pawn ViewModel Linking (TryLinkHeroViewModel): Demon and Monster HUDs locate the live Hero and bind to the Hero's ViewModel using a non-blocking 0.2s retry timer to safely handle multiplayer actor replication order.

Testing Area — Updating UI while picking up items & Interacting with Chest

03. Polymorphic Status Effect System & Zero-Tick Actor Components

  • 6 Zero-Tick Replicated Actor Components (bCanEverTick = false): Decoupled Health, Energy, Character Stats, Equipment, Status Effects, and UI Management into self-contained C++ Actor Components driven strictly by FTimerManager handles and delegates.
  • Polymorphic Status Effects (UIgniteEffect, UPoisonEffect, UBleedEffect, UFrostEffect, USludgeEffect): Built a UStatusEffect hierarchy that scales against target EffectResistancePercentage. Includes Ignite (which triggers a SphereOverlapActors check on expiration to spread fire to nearby characters), Poison (dynamic stack damage scaling), Bleed (% Max HP DoT), and Frost/Sludge (reversible percentage stat debuffs).

Testing Area — Poison Effect from Trap & Sword

04. Data-Driven Designer Workflow, Reflection Enchantments & Loadout Persistence

  • Dynamic UDataTable Tier Scaling & StaticEnum Reflection: Weapons and Armor query DataTables dynamically by upgrade tier (Tier_1 to Star_Tier) for combo hit multipliers and defense stats. High-tier armor rolls non-duplicate random buffs and uses StaticEnum<ECombatStatType>() reflection to convert enum values into DataTable row lookups automatically.
  • PlayerState Loadout Serialization (FSavedHeroLoadout): Serialized equipped Weapon/Armor classes, tiers, values, and rolled enchantments into ACodeNamePlayerState so full gear loadouts are reconstructed and re-socketed across deaths and revives.
EGO DataTables

Engine - Data Tables and Data Management

05. Custom C++ AI Behavior Tree Nodes & Dungeon Room Loop

  • Custom C++ Behavior Tree Service & Tasks (UBTService_Radar & UBTTask_Patrol): Built a 360-degree radar service in C++ that ticks every 0.5s with RandomDeviation = 0.1f (preventing multiple AI agents from evaluating on the exact same frame) alongside waypoint patrol and attack tasks.
  • Automated Dungeon Room Progression (ADungeonRoom): Tracks active room monsters, unlocks the room's Chest and Portal Doors once cleared, and teleports both Hero and Demon players (automatically ejecting Demons from possessed pawns) when transitioning to the next room.

Dungeon — Killing Monster to open Chest & Dungeon Door

CARZINGA

EARLY DEVELOPMENT

Role: Gameplay & UI Programmer
Focus: IDK
Year: 2026 (October - Present)

GODOT C# GDScript 3👤

An early-stage 2D top-down vehicular action-survivor built in Godot 4 with C#. Focused on building a scalable core architecture capable of handling hundreds of active projectiles, enemies, and loot drops at 60 FPS without garbage-collection spikes.

01. Generic C# Object Pooling Architecture (IPoolable & ObjectPool)

  • Zero-Allocation Queue Pooling (ObjectPool.cs): Built a generic Queue<Node2D> pooling system that pre-allocates bullets, enemies, destructible scrapyards, and loot drops off-screen with ProcessModeEnum.Disabled. Dequeuing an instance resets physics interpolation and invokes IPoolable.OnActivate(), with an automatic emergency instantiation fallback if a wave exceeds initial pool capacity.
  • Thread-Safe Deferred Physics Toggling (Bullet.cs): Pooled projectiles calculate lifetime from MaxDistance / Speed, apply directional knockback forces (Impact) on hit, and use CallDeferred / SetDeferred to safely disable collision shapes and return to their parent pool without mid-step physics errors.

02. Arcade Drift Vehicle Physics & Auto-Targeting Turrets

  • Dynamic Grip-to-Drift Interpolation (CarBase.cs): Supports both mouse-steered and keyboard driving. Calculates normalized steering angle difference (angleDiff / Mathf.Pi) every physics tick to smoothly interpolate lateral traction between tight StraightGrip (8.0f) and sliding TurnDrift (1.5f), alongside RPG stats for Evasion dodge rolls, flat Endurance armor, and passive Regeneration.
  • Modular Auto-Turrets & Precision Spread (WeaponBase.cs): Weapons dynamically generate a CircleShape2D detection zone from their Reach stat, track valid enemies and scrapyards in range, acquire the closest target using squared-distance checks (DistanceSquaredTo), and apply Precision-based angular spread and critical hit multipliers.

03. Kiting AI, Context-Aware Loot Drops & Sleeping Magnet Collectables

  • Radial Wave Spawner & Kiting Ranged AI (EnemySpawningSystem.cs & RangedEnemy.cs): Spawns pooled enemies along a randomized perimeter ring around the player. EnemyBase handles decaying knockback velocity, while RangedEnemy reverses its movement vector to kite away from the player while its attack cooldown is recharging.
  • Context-Aware Scrapyards & Sleeping Magnet Drops (Scrapyard.cs & Collectables.cs): Destroying a Scrapyard inspects the player's HealthComponent—dropping healing Scrap when damaged or bonus Coins when at full HP. Pooled drops keep _Process disabled until overlapped by the car's MagnetArea, waking up only when pulled toward the vehicle.

MULTIPLAYER REPLICATION

Role: Network Programmer
Focus: Seamless Travel & Color Replication
Year: 2025

UE5 C++ 1👤

A C++ multiplayer session, server browser, and interactive 3D lobby architecture built in Unreal Engine 5—featuring password-protected session hosting, physical 3D color-selection readiness pads, seamless travel state persistence, and direct Steamworks SDK avatar rendering.

01. C++ Online Subsystem Sessions, Server Browser & Password Modal

  • Session Lifecycle Management (UMazeLunacyGameInstance): Implemented session creation, discovery, and joining in C++ via IOnlineSessionPtr. CreateLobby configures 8-player presence lobbies with custom advertised metadata keys (SESSION_NAME_KEY and SessionPassword) before calling ServerTravel to open the listen-server lobby.
  • Dynamic Server Browser & Password Verification (UUW_FindSessions, UUW_SessionRow & UUW_CheckPassword): Built C++ BindWidget classes that query active sessions and dynamically populate a UScrollBox with server rows displaying live ping (PingInMs), player capacity (Current / Max Players), and password protection—spawning a modal password check before executing ClientTravel.

02. 3D Color-Platform Readiness & Seamless Travel Persistence

  • Server-Authoritative 3D Readiness Pads (AA_ColorPlatform & ALobbyCharacter): Instead of clicking a static 2D "Ready" button, players walk onto physical 3D color platforms in the lobby. Overlapping a pad on the server invokes ServerSetColor, applying the material to the character mesh, updating replicated AMazeLunacyPlayerState variables, calling ForceNetUpdate(), and broadcasting readiness across all connected controllers.
  • Host Start Validation & Seamless Travel Persistence (AGM_Lobby & AMazeLunacyPlayerState): AGM_Lobby::CanStartGame() verifies that minimum player counts are met and every connected player has claimed a color before enabling the host's Start button. Enabled bUseSeamlessTravel and overrode AMazeLunacyPlayerState::CopyProperties to preserve each player's chosen material across map transitions, paired with retry-guarded OnRep_PlayerColor timers if a client's PlayerState replicates before their Pawn finishes spawning.

03. Direct Steamworks SDK Avatar Pipeline & 8-Slot Lobby UI

  • Steamworks RGBA Buffer to UTexture2D Pipeline (UUW_LobbyPlayerStatus::GetSteamAvatar): Integrated steam_api.h directly in C++ to extract each player's 64-bit CSteamID from FUniqueNetIdRepl, fetch their avatar handle via SteamFriends()->GetLargeFriendAvatar, read raw RGBA bytes through SteamUtils()->GetImageRGBA, and copy the pixel buffer into a transient UTexture2D mipmap (BulkData.Lock + FMemory::Memcpy).
  • 8-Slot UWidgetSwitcher Lobby Synchronization (UUW_Lobby & APC_Lobby): Managed an 8-slot array of UWidgetSwitcher components that automatically flip between empty and occupied player cards on PostLogin and Logout via Client RPCs (Client_UpdateLobbyList, Client_UpdatePlayerReadiness), while restricting StartGameButton visibility strictly to the listen-server host (PC->HasAuthority()).