• Weapon-Dependent Animation System Engineered combat around weapon Actors in UE5.4, enabling dynamic weapon spawning for enemies and data-driven animation definition via structs (S_AttackAnims),  separating logic from the character for scalability.

• Combo system Implemented a reponsive combo system driven by character state and a timing-based input buffer, designed intentionally without priority to maintain high-stakes, commitment-based gameplay.

• Camera targetting Built a camera targeting system using dot-product for centered enemy selection, with smooth switching between targets and automatic break conditions to keep combat focused and readable.

• AI & Feedback Developed reusable enemy AI with Behavior Trees, incorporating physics-based directional hit reactions and anim-notify-controlled attack commitment to create fair, telegraphed enemy behaviors.

• Spline-Based Patrol & AI State Machine Implemented a modular patrol system where the boss autonomously navigates along a user-defined spline path in the game world, providing a dynamic and customizable setup phase for the encounter. Architected a multi-phase AI state machine (Patrol -> Investigate -> Chase <-> Combat) to create a structured and dramatic boss introduction, controlling distinct behaviors and animations for each phase.
• Progressive Player Detection: Designed an “Investigate” state triggered by player proximity, where the boss ceases patrolling, focuses on the player, and begins a cautious approach, building tension before combat initiation. Programmed a threshold-based combat trigger, where reaching a specific distance prompts a distinctive scream animation, formally signaling the transition to the combat phase and enhancing narrative pacing.
• Dynamic Combat Behaviors: Created a chase-and-attack combat loop with unique “unblockable” attack properties, enforcing specific player responses like dodging, and increasing the encounter’s difficulty. Prototyped a responsive damage-reaction system where the boss actively creates space by jumping backward (currently a teleport placeholder) upon taking significant damage, preventing player stun-locking and forcing engagement re-evaluation.

• C++ Ability system Designed and implemented a C++ Data-Driven Ability System using  (GAS) principles, featuring modular ability components (trigger, targeting, execution phases) with designer-friendly data asset confguration. 

• MotionMatching:Independently built a Motion Matching system in Unreal Engine 5.4 from the ground up, implementing Pose Search, Animation Databases, and Chooser Tables using animations from Epic’s Animation Sample Project. Engineered the full pipeline including feature vector extraction, pose matching logic, and animation blending for a custom character, resulting in a production-ready locomotion controller developed without reliance on the pre-built sample character.

• Complex Locomotion Engineered a deliberately over-specified locomotion system using 40+ animations from the sample project implementing edge-case coverage typically excluded due to diminishing player perception returns.

• Camera system with weighted interpolation, with dead zones and event-driven screen shakes tied to attack impacts and boss encounters. Implemented smooth follow behaviors with configurable damping.
• Character FSM managing locomotion, combat phases, and animation synchronization.  Designed encapsulated state objects with transition predicates maintaining precise control flow.
• Multi-Layer Parallax System  depth-based parallax scrolling with layer-specific speed multipliers for 3D depth simulation
• Collision system that generates different size colliders for player or enemy attacks and applies damages, knockbacks and state transition triggers.
• Adaptive Boss AI System FSM done entirely in C#, controls movement, states, combat states and all animations for the boss. mplemented adaptive routines including dodge prediction, jump trajectory attacks, and phase-based pattern variation. It is a situation-responsive AI that escalates difficulty through progressive attack pattern unlocking.

• 3D ray intersections to draw spheres and planes even if they intersect between them
• Local illumination ambient diffuse and specular
• Hard shadows
• Reflections
• Refractions
• Distance fog
• plane patterns

• Done in Unreal Engine, Myrmica is an 8h long investigation and puzzle game with an isometric camera where you explore a petrol station while being chased by a time anomaly. To achieve this, manipulate the routine of 5 characters for your needs and create your situations on a time loop that repeats the same day over and over. And discover the truth of Complex B13B

• Co-designed narrative-driven puzzles integrating time-loop mechanics with 5 NPC routines

• Scripted all time-based events using a full day-cycle system 

• Implemented event trigger system managing quest progression across multiple day loops affected by branching conversation and player decision trees that affected each loop events.

• Programmed animation state machines handling locomotion, interactions, and scripted sequences for the player character and the NPCs

• Created and co-designed time-aware AI behaviors maintaining routine consistency across temporal resets

• Built key puzzle mechanics integrating environmental interactions with NPC manipulation

• Implemented story progression systems tracking player decisions across branching timelines

• Programmed event memory system preserving player discoveries and NPC relationship states between resets

My experience across programming, design, and art pipelines helped bridge communication gaps between departments, foreseeing technical challenges and designing around engine and team limitations while ensuring smooth art content integration. This broad technical understanding resulted in my appointment as Game Producer for the last three months, where I oversaw project needs, organized deliverables, and managed the workflow of our 27 people team.

The team successfully navigated a challenging 10-month development timeline, demonstrating sustained high level dedication and resilience throughout the project's intensive production phase.

Co-developed a complete The Witcher-inspired video game in three months using a custom C++/OpenGL game engine built collaboratively by a 17-person programming team.

• Pre-production engine development: Created the 3D model and animation import system months before the main project began, establishing core content pipeline infrastructure

• Enemy design & implementation: Designed multiple minion enemy types and scripted their behaviors using Lua, including a mini-boss with custom AI patterns

• Systems scripting: Developed enemy AI, combat mechanics, and progression systems within the Lua scripting layer

Developed a Custom 3D Game Engine in C++ & OpenGL from the ground up, featuring a modular architecture for rendering, resource management, and animation.

• Built a Flexible Asset Pipeline: Engineered an FBX import system supporting 3D models, textures, and skeletal animations, paired with a custom file system for organizing resources (shaders, scripts, textures) and enabling runtime asset management.
• Implemented a Forward Renderer with Culling: Developed a renderer with local illumination (ambient, diffuse, specular) and a camera frustum culling system to optimize performance by efficiently managing draw calls.

• Architected Skeletal Animation Support: Created an animation system capable of loading and playing skeletal animations, establishing the foundation for dynamic, skinned character rendering.

Co-developed a Real-Time Strategy Game, taking primary ownership of the entity architecture, player command layer, and AI/navigation systems. 

• Systems Architecture: Built the game's entity management framework and player interaction system, enabling unit selection, formation control, and order execution (attack, move, defend).

• AI & Pathfinding: Programmed multiple enemy archetypes with unique tactical profiles and implemented a performant pathfinding solution with dynamic collision avoidance for believable squad movement.

Developed a Rhythm Game Engine & Level Creation Tool in C++/SDL2, enabling players to both play and design custom Guitar Hero-style levels.

• Real-Time Rhythm System: Built the core gameplay loop detecting input timing (keys 1-4, Enter) against musical beats, complete with scoring and feedback visuals.

• Architected a Developer-Generated Content Pipeline: Created a level editor that records player keystrokes during song playback and serializes them into structured XML files, allowing seamless creation of custom game levels.

Reverse-Engineered & Recreated "Last Resort" (Neo Geo) in C++, implementing core gameplay systems and a complete level from scratch.

• Built a 2D Animation & Rendering Pipeline: Engineered a sprite animation system with frame timing, flip states, and rendering optimizations allowing us to have all game sprite frames in one single sheet by defining sprite positions with xml files.

• Developed Boss Encounter Logic: Programmed mid level and the final boss's AI pattern, attack phases, and visual behaviors, recreating the authentic challenge and telegraphing of the original.

• Architected Player Progression Systems: Designed and implemented a UI and stat management system that tracks player upgrades, power-up effects, and persistent state across the level.

A Unity engine resource management game developed in a 32-hour game jam. Players balance production and pollution to gain resources without damaging planets.

I don't even remember what I did, lack of sleep I guess. If you readed until here, contact me asking if I'm the guy who does not remember things when he does not sleep.