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