Unity Developer Intern
(Feb - Jun 2025)

Stichting GameLab Oost

I joined GameLab Oost as an intern to gain experience in developing serious games that make a real-world impact.During the internship, I contributed to a roguelite-inspired game for ’s Heeren Loo, designed to teach safer social media navigation to people with mild intellectual disabilities.Highlights:

• More About the Project

Creative Media and Game Technologies (2022 - 2026)

Hanze University of Applied Sciences

Relevant Coursework:

Computer Science
(2021 - 2022)

University of Bucharest

Relevant Coursework:

Technical Skills

Soft Skills

My name is Radu Duicu, known online as "capnRadu." I began my gaming journey at a young age with classics like Counter-Strike and Minecraft, which sparked my passion for gaming. During high school, I developed my programming skills in C++ and explored editing tools like Photoshop and Sony Vegas, enjoying the creative process.My curiosity about how code creates engaging experiences led me to study computer science, where I gained valuable insights into Python and x86 Assembly, enhancing my critical thinking skills. Despite the field not fully satisfying my aspirations, this experience solidified my passion for programming.Currently, I am a fourth-year student at Hanze University of Applied Sciences, where I have been exposed to game industry programs and have had the privilege of collaborating with exceptional individuals on group projects. It is within this environment that I have discovered my passion for becoming a game programmer.

Overview

Our team aimed to address a specific challenge posed by our client, De Buitenschool. They needed a solution to attract a significant number of visitors to elevate Gilmmen’s primary school into a popular destination in the region.Employing Agile methodology, we embarked on developing an AR application. Our focus was on delivering an immersive experience, covering the school's architecture, history, art, and culture. We tailored the app for children aged 12 to 15.The outcome was an engaging AR application that showcased the school's features and heritage. Our solution not only met the client's objectives but also provided an interactive experience for the visitors.

Work Method

Before this project, I had no experience with augmented reality development, making it an exciting project for me. To acquaint myself with AR concepts, I explored the Unity AR Foundation samples, experimenting with each one and studying the scripts.Given our app's emphasis on image recognition and multiple scanned images displaying specific prefabs, I delved into tutorials covering Unity's image recognition basics. Alongside programming the app's functionality, I designed the UI menu to present sticker information.

Gameplay

The app comes with a main flyer given to visitors upon arrival, featuring a QR code for app download. Once installed, scanning the flyer initiates a mini-story and objective: explore the surroundings, find stickers, and scan them.Each sticker scan prompts a related image puzzle, designed to engage users. However, the puzzle feature, created by another team member, was not integrated into the app. After the puzzle is completed, users can read the presented information, or press the history button, and read information about its past.Information is provided for four stickers, including a secret one unlocked after scanning the others. An inventory menu allows users to access unlocked sticker info at any time without revisiting the school.

Development

Regarding functionality, the PrefabTracking script handles the image recognition and instantiating of prefabs by having an array of GameObjects where the prefabs are placed. After the prefab is created, the scale and position are defined such that it appears on the right side of the tracked image.The FlyerEnable script handles information about the prefabs. When a prefab is created, the script checks if the prefab is not the main flyer or the secret sticker and if it wasn't already present in the scene to increase the scanned stickers count. This is important so the secret sticker is unlocked only when the first 3 stickers are scanned. The next part of the script, alongside the StickerStatusUI script, handles the UI from the inventory menu, specifically the locked/unlocked text.The ScannedStickers script is used only to keep track of the number of scanned stickers, so it can pass the value to the SecretStickerMechanic.The SecretStickerMechanic script handles the status of the secret sticker; if the other 3 stickers were scanned, then its content becomes available.The ButtonScript handles the logic of the "History" and "Back" buttons that are present inside each prefab, while the ButtonsUI script handles the button logic and functions from the inventory menu.

Demonstrated Skills

Gameplay

Overview

The objective of the project was to simulate a professional game studio environment by implementing a specific feature within an existing codebase, the FPS Microgame.This process involved three primary phases: research, writing the technical design document, and implementation.

Work Method

For the feature, I opted to implement a leveling system, driven by my desire to understand the FPS Microgame codebase and enhance my ability to plan ahead for scripts by envisioning how different mechanics will interact with each other.Regarding the research phase, the feature draws inspiration Brotato and Hades. These influences converge to create a dynamic leveling system that enriches player progression and customization.Based on this, the requirement list for the leveling system mechanics included XP and coin gain, a level-up menu, a shop menu, a stats menu, and the persisting upgrades.

Gameplay

The FPS Microgame's leveling system adds depth and challenge, shaping gameplay into a series of escalating enemy waves. Players initiate runs from the main menu, respawning at the first wave upon death, retaining persistent upgrades but forfeiting skills and coins. Each wave increases in difficulty, rewarding successful eliminations with XP and coins.After each wave, players access the level-up menu for stat boosts and the shop menu for skill purchases using coins. The stats menu tracks upgrades and skills.

Technical Design

Various UML diagrams were used during development to visually represent the feature's systems, aiding in understanding design, code architecture, and implementation.Object Diagram

This diagram illustrates multiple gameplay objects instantiated within the FPS Microgame's main scene, including hoverbots and Patrol GameObjects utilizing the PatrolPath script. To integrate the leveling system, the WaveManager script spawns multiple enemies. However, using the Enemy_HoverBot prefab led to shared patrol routes, requiring a prefab with unique routes. Two issues arose: Enemy_HoverBot lacked a PatrolPath reference, resolved by obtaining it from the parent, and hoverbot destruction left the Patrol GameObject, addressed by checking if the EnemyController component from its child was null. The second part depicts the Skill script and its instances, representing skills in the shop menu, with additional details provided in the class diagram section.

Flowchart

The flowchart visually breaks down the multiple interactions, processes, and decision points that contribute to the logical functioning of the system during gameplay.

Class Diagram

The class diagram visualizes the object-oriented aspect of the system. The WaveManager script serves as the foundational component, managing player upgrades, resources persistence, and the wave system. Key functionalities include NextWave and SpawnEnemies methods for enemy spawning and progression, along with a ResetWave method for new run initialization. It has a composition relationship with the GameFlowManager script for sound effects during wave starts.During final testing, I identified a chance to improve the wave system. The original design, relying on a fixed enemy count to progress, felt static. Building on playtesting insights, I introduced a second iteration with a 45-second wave timer, spawning mini waves upon eliminating the previous enemies.The GameFlowManager script controls the game flow, checking objectives, player death, and scene transitions. It has a composition relationship with PlayerResources, loading the level-up menu on level-up and the shop menu otherwise.PlayerResources maintains player resource information, with methods like GainCoins, GainXP, and HandleXP for updating values upon enemy elimination. It has composition relationships with WaveManager and SkillManager to update persistent values.The Health script manages player and enemy health, using RegenHP, Heal, TakeDamage, HandleDeath, and Kill methods. It has an aggregation relationship with PlayerResources for coin and XP updates, and composition relationships with WaveManager for health upgrades, and SkillManager for HP regeneration updates.SkillManager handles player skill persistence, level, and stats. It uses InstantiateSkills to spawn skills in the shop menu.The Skill script, associated with each skill prefab, initializes skill values and updates UI text. It has a composition relationship with SkillManager for communication and value updates.The BuySkill script manages skill purchases and upgrades, checking and updating player coins through WaveManager and stats via SkillManager.ChooseUpgrade handles upgrades within the level-up menu, using the Upgrade method. It has a composition relationship with WaveManager for persistent value updates.PlayerCharacterController controls player movement, with a composition relationship with WaveManager for applying speed upgrades.WeaponController maintains the weapons system, aggregating WaveManager for damage upgrades.

Demonstrated Skills

Gameplay

Overview

Into the Backrooms is a first-person horror prototype developed in Unreal Engine. The project was created to experiment with Unreal’s visual scripting system, standard first-person template, AI tools, and horror gameplay mechanics.Inspired by the uncanny atmosphere of the Backrooms, the game challenges players to explore a maze-like environment, collect seven scattered images, complete skill checks, manage limited resources, and avoid a hostile entity.

Development

Enemy AI

I created an enemy AI system using Unreal’s Behavior Tree and Blackboard workflow. The entity can roam the map, detect the player, chase them, and attack when close enough.The AI uses a sensing system to determine whether the player is visible. When the player is detected, the entity switches from roaming to chasing. If the player escapes detection, the AI eventually returns to roaming behavior.Custom Behavior Tree tasks handle roaming, chasing, and attacking. The attack logic triggers a jumpscare sequence and restarts the level when the player is caught.

Player Survival Mechanics

The player has several limited survival tools. Sprinting increases movement speed but drains stamina, forcing the player to manage when to run. The flashlight uses battery power and can slow the entity when aimed at it, but it cannot be used endlessly.Leaning allows the player to peek around corners, adding a stealth and tension mechanic without exposing the full character position.

Images & Skill Checks

The main objective is to collect seven images. Each image has multiple possible spawn points, improving replayability and preventing the player from memorizing a single route.When interacting with an image, the player enters a skill check. The skill check randomizes the target zone, disables player movement during the interaction, and determines whether the player succeeds or fails. Success collects the image, while failure respawns it and prolongs the objective.

Demonstrated Skills

Gameplay

Overview

ARPG Mechanics is a Unity gameplay prototype inspired by action RPGs such as Diablo. I developed it to improve my understanding of software design principles, especially SOLID, DRY, modularity, and scalable gameplay architecture.The prototype includes point-and-click movement, hold-to-move input, player abilities, health and mana potions, enemy AI, combat interactions, and continuously spawning enemies.

Development

Player Movement

I created a point-and-click movement system using Unity’s Input System and NavMesh. The player can either click on a location to move there or hold the left mouse button to continuously follow the cursor position.The system also checks whether the cursor is targeting an enemy or a walkable location, allowing movement and combat interactions to work through the same input flow.

Combat and Abilities

The prototype includes a modular ability system built around a shared base ability class. Common ability behavior, such as cooldowns, cast duration, buff duration, activation, and deactivation, is handled in the base class, while each ability defines its own specific behavior.Implemented abilities include:

Enemy AI

Enemies use NavMeshAgent movement to chase the player and attack when within range. Their attack logic is timed with animation delays, so damage is applied at the correct moment instead of immediately when the animation starts.Randomized attack delays make enemy behavior feel less mechanical and reduce repetitive attack patterns.

Stats System

The Stats system manages core character attributes such as health, mana, damage, healing, and death. It is used by both the player and enemies, which helps avoid duplicated logic.The system also provides percentage values for UI elements, making it easier to update health and mana bars consistently.

Demonstrated Skills

Gameplay

Overview

Meal Master is a fast-paced mobile time-management game where players run a kitchen, prepare customer orders, and upgrade their tools to survive increasingly difficult rounds.The project focused on learning the full mobile development workflow, from gameplay design and UI implementation to analytics, rewarded ads, in-app purchases, and save/load functionality.

Development

Player Interaction System

I developed a point-and-click interaction system where players move through the kitchen using a NavMeshAgent. When the player clicks on an interactable object, the system stores the target and triggers the correct interaction once the player reaches it.This system supports item pickup, tray placement, grilling, frying, soda refills, and serving orders to customers.

Customer & Order System

Customers move through a waypoint system, place an order, wait for a limited amount of time, and react based on the player’s performance. Their emotional state changes from happy to confused or angry depending on how long they wait.The system validates whether the served item matches the customer’s order and rewards or penalizes the player accordingly.

Upgrade System

Players can spend earned money on upgrades that improve kitchen tools and player abilities. These upgrades affect gameplay variables such as cooking speed, refill time, and movement speed.The upgrade system includes level limits, increasing costs, UI feedback, and persistent saved progress.

Analytics & Monetization

I implemented Unity Analytics to track important gameplay events, including completed orders, failed orders, round progression, upgrade purchases, and game-over points. Analytics only start after the player gives consent through a consent menu.For monetization, I integrated rewarded ads as an optional revive feature. Instead of interrupting gameplay with forced ads, players can choose to watch an ad after losing all chef hats to continue the run.I also implemented basic in-app purchases through Unity IAP, allowing players to buy optional currency packs.

Demonstrated Skills

Gameplay

Overview

Fast Food Worker Simulator is a VR tutorial game set 30 years in the future, where fast-food workers learn to operate 3D food printers. The project explores how interactive training can help workers adapt to new technology in a future workplace scenario.

Development

Customer System

I created a customer system where NPCs spawn, move to the counter, generate an order, wait for the correct food item, and leave once the order is completed or failed. Later iterations added order timers, multiple recipes, difficulty scaling, and more complex validation logic.A recipe index system was used to compare player-created food items against the NPC’s requested order. This allowed the system to check whether the correct ingredients were assembled in the correct combination.

Recipe Assembly System

The recipe system allows players to physically build food items in VR by combining ingredients. Each ingredient contributed to an order index, which was used to validate the final recipe.The system supported multiple recipes, including hamburgers, hotdogs, and a daily special. Ingredient placement logic was improved throughout development to make stacking more accurate and readable in VR.

3D Printer System

I developed an interactive 3D printer system that allows players to spawn ingredients using VR interactions. To avoid object clutter, printers could only spawn a new object when the print area isfree.In the final version, printers also included deterioration, smoke particles, damage bars, and a cleaning mechanic. This added an extra layer of time management and maintenance to the gameplay.

Demonstrated Skills

Gameplay

Overview

During my internship at Gamelab Oost, my team was tasked with developing a serious game for ‘s Heeren Loo, an organization supporting people with disabilities. The goal was to help individuals with mild intellectual disabilities learn safer ways to navigate social media.We addressed the challenge by creating a roguelite game. Players progress through zones inspired by platforms like WhatsApp and Instagram, encountering NPCs whose dialogues simulated real online interactions. Success in conversations rewards buffs, while failure gives direct negative feedback. This loop teaches players to recognize unsafe behavior, disengage from harmful interactions, and seek help from their caretakers.

Personal Learning Goals

Development Process

Research & Ideation

Prototyping & Systems Design

Development & IterationI was primarily responsible for the core gameplay systems, ensuring the “fun” side of the game was engaging and scalable:

Testing & User Feedback

Teamwork & Communication

Challenges & Solutions

Concepting Tunnel Vision
We got stuck refining early concept ideas to improve them without experimenting with new ones. The fix was to step back, focus on what we found fun, and pivot to a roguelite format, which opened new creative directions.Slow Research Phase
The research and ideation phases felt unproductive. To stay engaged, I built general-purpose systems, which later became core building blocks.Late Concept Reset
We realized too late that early ideas didn’t fit the client’s needs. Restarting forced us to adopt a “fail faster” mindset and reinforced the importance of time management.

Demonstrated Skills

Trailer

Overview

For my graduation project, I worked with IWP Campus Design to address a gap in how accessibility issues get handled on the Zernike campus: barriers are typically fixed reactively, one complaint at a time, without a Universal Design framework to guide decisions. This risks solving one user's problem while creating a new barrier for someone else.My solution is ZP11: A Universal Design Experience, a first-person simulation that puts facility managers in the perspective of students with physical and neurodivergent impairments navigating a campus building. Users move through a before route (the building as it currently is) and an after route (the same journey with Universal Design principles applied), experiencing firsthand how accessibility gaps affect independence, effort, and dignity. The tool is designed as a conversational tool to help facility managers understand accessibility and inclusivity barriers.

Development Process

The project followed a Double Diamond design process across a 20-week timeline, working directly with Campus Design as the client.

Discover Phase

Define Phase

Develop Phase

Deliver Phase

Wheelchair Controller System

Built a custom wheelchair controller on top of Unreal's Chaos Vehicles plugin using an enum-based state machine (Idle, Forward, Backward, Brake). During development I redesigned the controller from a traditional throttle-based vehicle into a manual push-based movement system, resulting in more deliberate and realistic wheelchair controls.

Neurodivergent Overstimulation System

Developed a dynamic overstimulation system that gradually accumulates sensory fatigue as players progress through neurodivergent scenarios instead of treating each barrier as an isolated event. A single overstimulation value drives multiple audiovisual effects, including post-processing, field-of-view changes, and audio filtering, with smooth interpolation to create a gradual increase in sensory overload.

Universal Design Learning System

Designed a GameInstance-driven quest/checkpoint architecture shared between the before and after routes. Each checkpoint stores both "before" content (Challenge, Why It Matters, Reflection) and "after" content (Solution, UD Principles, Key Lesson) in a shared data structure, so the same location can present different information depending on route state. A separate runtime/default database split allowed the quest state to reset cleanly between route sections without duplicating checkpoint data.

Environment

Modelled the ZP11 building in Blender from real floor plans, following a consistent per-floor workflow (exterior walls → interior walls → openings → floors/ceilings → UVs → materials). Experimented with post-processing and HDRI-based lighting workflows before settling on an HDRI + Lumen combination for a more realistic atmosphere.

Testing & Iteration

I ran five testing sessions across three audience types, combining think-aloud observation with follow-up questions:

Challenges & Solutions

Reliable ground detection for the reset system
My first approach used a single sphere trace from the wheelchair's center, which missed cases where one wheel was suspended off the ground. Switching to the Chaos Wheeled Vehicle Movement component's per-wheel contact state was unstable, flickering between true/false. I ended up tracing from each of the four wheel sockets individually, which gave a reliable grounded check across uneven geometry.Performance optimization without a clear bottleneck
I tested Instanced/Hierarchical Instanced Static Meshes, occlusion culling, and reduced lighting complexity, expecting clear frame rate gains on low-end hardware. None of these produced the improvement I expected in isolation, which pushed me to test across four build configurations (DX11/DX12 × default/Forward Shading) directly on a low-end laptop rather than relying on assumptions from my development machine — DX11 with Forward Shading ultimately gave the best result for lower-end devices.Scope correction mid-project
I initially considered a smaller, more heavily redesigned building for the simulation, but the client informed me it was scheduled for demolition. Pivoting to ZP11 meant working with a significantly larger, more complex layout, which required narrowing the simulation to one specific student route and a defined set of checkpoints rather than the whole building.

Demonstrated Skills

Trailer

Overview

Soulspire is a 3D isometric tower defense survivor game where the player defends a single arcane tower, operated by a mage, against endless waves of enemies that grow in number, variety, and strength over time. Combat runs automatically, the tower auto-targeting and attacking nearby enemies, so the core decision-making happens between waves, where the player chooses how to spend earned currency to grow stronger.Progression is built around four systems. Coins provide temporary upgrades during a run, while Souls permanently improve the player's baseline stats between runs. Tower Level unlocks access to new stats, and Sigils are required to unlock them before they can be upgraded. A premium currency, Diamonds, is limited to cosmetic purchases and progression acceleration.

Combat & Enemy AI

Developed a modular combat system built around shared enemy base classes with specialized melee and ranged behaviours. Enemy waves are generated through weighted random selection and scale using ScriptableObject-driven difficulty settings, allowing balancing changes without modifying gameplay code. The player's tower automatically targets nearby enemies and fires projectiles along curved trajectories, with combat behaviour influenced by the player's chosen upgrades, including critical hits, lifesteal, and distance-based damage scaling.

Progression & Stats Architecture

Designed a data-driven progression system that separates stat definitions from their runtime values using ScriptableObjects. Permanent upgrades, temporary run-based bonuses, and unlocked stat categories are managed independently before being combined into the player's effective stats. Separating stat unlocking from stat upgrading allowed Tower Level to provide meaningful long-term progression without directly increasing combat strength, creating clearer progression milestones and greater build variety.

Skins & Cosmetics

Implemented a ScriptableObject-based cosmetics system supporting persistent unlocks and equipment through PlayerPrefs. Cosmetic customization remains completely separate from gameplay systems, reinforcing the project's design goal of avoiding pay-to-win mechanics while allowing visual personalization.

Unity Analytics Integration

Implemented a centralized analytics system that tracks gameplay progression, player behaviour, and shop interactions through custom events. Analytics are initialized only after player consent has been given and support complete data deletion requests, ensuring the system complies with privacy requirements.

Unity IAP Integration

Developed a complete in-app purchase pipeline covering product retrieval, purchase processing, entitlement restoration for non-consumable purchases, and reward distribution through a dedicated shop manager.

UX

Development was guided by a structured UX process centred on mobile players who prefer strategic, low-input gameplay over fast reflexes. A defined target audience, persona, and set of functional and qualitative design requirements informed key design decisions, including automatic combat and the separation of temporary and permanent progression systems.

Publishing & Store Preparation

Beyond gameplay development, the project included preparing the game for release on Google Play. This involved configuring in-app products, completing Google's privacy and data safety requirements, generating signed Android App Bundles, preparing internal and closed testing builds, and creating visual assets.

Demonstrated Skills

Trailer

Overview

For the Artificial Intelligence elective, the project was to research and implement an AI technology of my choosing. I chose behaviour trees so I could focus on building something solid and well-understood using tools and a language I already knew well.The result is a Unity ecosystem simulation where autonomous "blob" agents wander, chase food and prey, flee larger threats, throw food strategically as bait, and sprint, all driven by a custom-built behaviour tree framework. Players can spawn blobs with different behavioral profiles and manipulate simulation speed to observe how decisions evolve over time.

Why Behaviour Trees

Before committing to the architecture, I compared behaviour trees against three common alternatives.

Behaviour trees offered the best balance for this project: hierarchical, modular, and transparent enough to debug and extend without rewriting existing logic.

Development Process

Base Behaviour Tree Architecture
Built the core BT structure from the beginning: a base Node class exposing Process() (returns Success/Failure/Running) and Reset(), with Sequence (logical AND), Selector (logical OR), and Leaf nodes wrapping individual actions. This gave the AI a working hierarchical decision-making foundation before any actual blob behaviours existed.Core Behaviours: Wander, Chase Food, Chase Prey
With the tree structure in place, the first behaviours were added. Testing at this stage focused on confirming the tree transitioned cleanly between behaviours as conditions changed, validating that the modular structure supported real-time reactivity.

Flee Behaviour
A flee behaviour was added so blobs could react to larger threats, computing a flee point away from the detected danger. Early playtesting exposed a real bug: blobs could get trapped against arena boundaries with nowhere safe to flee to. This was fixed by adding an edge margin and a "wall flee boost" that pushes cornered agents back toward the arena center.

Throw Food (Baiting) Behaviour
Originally built as a simple test of multi-action decision-making, this behaviour evolved through observation into a deliberate baiting mechanic once it became clear prey blobs would reliably prioritize nearby food over fleeing. Tuning the throw interval and random chance made the behaviour read as intentional rather than random.

Player-Controlled Blob
Added a manually controlled blob sharing the same underlying functionality as the AI blobs, enabling direct player-perspective testing of whether chase and flee interactions felt fair and responsive from the receiving end.

Sprint Mechanic
Introduced a temporary speed burst at the cost of mass, tuned through iteration on cooldown, mass-loss rate, and duration so it enhanced chase/flee encounters without producing erratic movement. Later extended to the player blob as well, for parity and easier balance comparisons between human and AI play.

Dependency Injection Refactor
As the system grew, strategies increasingly held hard references to concrete blob components, making changes cumbersome. This was refactored so strategies take Func<>/Action<> delegates instead of direct references, decoupling behaviour logic from any specific blob implementation. This was the single most impactful architectural change in the project — it enabled modular reuse across agents, simplified testing, and meant new systems could be added without structural rewrites.

ScriptableObject Configurations
Following the refactor, all tunable AI parameters were externalized into ScriptableObjects — behaviour priorities, perception radius, flee/movement/throw-food parameters. This turned blob "personality" into swappable data rather than code, making it fast to create and compare Aggressive, Timid, Baiter, and Default archetypes purely through Inspector assets.

Demonstrated Skills

Gameplay