Tailwind Tropics
Location
Stockholm
Date
2024
Team size
9
Role
Programmer
Engine
Unreal Engine
Trailer
Overview
Tailwind Tropics is a stylized, 3D, round-based team party game where players gather resources, build battleships, and compete in chaotic team-based minigames. Developed over 9 weeks as part of my studies at Stockholm University, the project served as an introduction to multiplayer game development in Unreal Engine 5.
​
In this project, I worked primarily on procedural content generation, player interaction mechanics, and resource systems. I also created systems for how players interact with objects in the world, such as gathering and throwing resources, depositing them into team storage, and using crafting stations for upgrades. My work involved ensuring smooth replication of interactive elements and maintaining a responsive experience for all players in a networked environment.
Project goals
The goal of Tailwind Tropics was to create a fun and chaotic team-based party game where players work together to gather resources, build battleships, and compete in lively minigames. We wanted to explore multiplayer development in Unreal Engine 5 while building a vibrant and replayable experience. A big focus was on making interactions feel smooth and satisfying, whether you’re collecting resources, throwing them to teammates, or crafting upgrades. We also aimed to use procedural generation to keep each match fresh and exciting, all while encouraging teamwork and friendly competition.
Unreal Engine's PCG Plugin
In this project, I used Unreal Engine's Procedural Content Generation (PCG) plugin for the first time. While it was initially challenging, I quickly got comfortable after researching, testing, and exploring the documentation.
​
The PCG plugin is typically used for static foliage, but I adapted it to spawn interactive resource objects like trees, bushes, and rocks. I created a blueprint actor with an attached PCG graph that generated points across the landscape, sorted them by resource type, and added logic to prevent overlaps for a clean layout.
​
These points were passed to a custom UPCGBlueprint that spawned gameplay-relevant, interactive resources. I also integrated splines to define exclusion zones (e.g., water or empty areas) and exposed parameters in the blueprint to allow our designer to easily tweak resource quantity, spacing, and spawn regions.
​
This system supported both gameplay and level design, and the experience helped me learn how to use PCG creatively for procedural and interactive content.
Script that sort points into different arrays.
PCG graph blueprint.
The code that gets executed when the Custom PCG script starts.
Script that sort points into different arrays.
Player Interaction
In addition to my work with PCG, I was responsible for implementing the player interaction system. I designed a custom Interactable interface, applied to all objects the player could interact with—such as trees, rocks, and barrels.
​
The player character uses an overlap sphere to detect nearby interactable objects. When one is found, the system highlights it with an outline effect, providing clear visual feedback. To make repeated interactions feel smoother, I added logic that rotates the player toward the most recently interacted object, even if they’ve slightly moved away.
​
To prevent multiple objects from being highlighted at once, which could confuse the player, I used the dot product to determine which object was most directly in front of the player. This ensured that only one interactable object was outlined at a time, giving the player a more focused and intuitive experience.
Interactable interface.
Overlap sphere.
Rotate player event.
Interactable interface.
Resource Barrels
I also developed interactive resource barrels that allowed players to deposit and withdraw resources for their teams. These barrels were central to the game’s economy system, enabling players to contribute gathered resources to a shared team account or retrieve them for crafting upgrades at designated stations.
​
The system was built using interfaces and inheritance to support different barrel types across various game phases. In the early phase, barrels only allowed resource deposits. In later phases, upgraded barrels enabled withdrawals as well. This flexible architecture made the system scalable and easy to extend.
​
All resource transactions were managed through the GameState class, which served as the central authority for each team’s resource account. Deposited resources were added to the team’s total, while withdrawals subtracted the appropriate amount.
​
By combining clean interface design with modular inheritance, I created a reusable system that supported consistent interactions across multiple levels and allowed designers to easily place the appropriate barrel types based on the current phase of gameplay.
Resource Chunks
To manage the game's gatherable resources, I created a parent class that handled all core functionality, including rotation logic, launch behavior, pickup interactions, and spawn mechanics. From this base, I built subclasses for each specific resource type—wood, metal, and fiber—using an enum system to define and distinguish them.
​
Each resource chunk featured an outline effect that appeared when a player was within interaction range, offering clear visual feedback and making the system more intuitive and responsive.
​
For smooth performance in a networked environment, I used Unreal’s Projectile Movement Component, which ensured reliable replication and minimized lag—especially when resources were thrown between players or across the map.
​
This modular and network-friendly setup allowed us to easily introduce new resource types while maintaining consistency, responsiveness, and visual clarity throughout the game.
Resource Nodes
The resource nodes that players interact with to collect materials were built using object-oriented inheritance. I started with a parent class that handled all shared logic, including health, interaction behavior, and visuals. From this base, I created subclasses for each resource type—such as wood, metal, and fiber—by simply adjusting the mesh and a few configurable parameters.
​
The parent class also implemented our custom Interactable interface, enabling player interaction and triggering an outline effect when within range. This provided clear visual feedback and made the system feel intuitive.
​
By leveraging inheritance, the implementation remained clean, efficient, and easy to expand with new resource types as the game evolved.
Lessons Learned
Tailwind Tropics was a great learning experience that helped me grow both technically and creatively. It was my first time using Unreal Engine’s PCG system, and adapting it to generate interactive, gameplay-focused resources taught me how to approach tools in new ways. I also built systems for interaction and resource management using interfaces and inheritance, which showed me how important modular design is, especially in a multiplayer setting. Working in a networked environment challenged me to think about replication, responsiveness, and performance when players interact with objects or throw them across the map. This project sharpened my problem-solving skills and gave me a stronger understanding of how to create scalable systems that support both gameplay and design flexibility.