Tanklike

Behavior Tree System

As we added more and more enemies, it became apparent to us that our state machine system was starting to get messy. Even though it was implemented in a modular and reusable way, creating connections between states and keeping track of them was something we struggled to manage.

So, to help us steamline that part of the development, and to get to do what I enjoy doing a lot (creating tools,) I implemented a behavior tree node-based system for the Unity Editor using Unity’s built-in Graph View, UI Toolkit and UI Builder.

The visuals of the node editor were inspired by the ones in Unreal Engine. I used UXML and USS to accomplish the current state of the tool, and it's still work in progress.

I added a minimap to make navigating through the graph easier. This was one of the feature that I wish Unreal had in their editor.

The Blackboard was a crucial feature of the system. I implemented it using Unity's built-in Blackboard system and customized it to meet the specific needs of the project. This implementation allows for the creation of various data types that can be easily accessed through code using a BlackboardKey variable.
Unlike the blackboards found in Unity's Shader Graph and Animator, where variable names must be typed manually, this system is foolproof, with all variables conveniently listed in a menu in the Inspector.

The behavior tree system is a flexible and visual approach to creating AI behaviors in games. It organizes actions and decisions into a hierarchical structure of nodes, where each node represents a specific task or condition. The tree traverses these nodes, evaluating conditions and executing actions based on their success or failure which allows complex and dynamic decision-making.

The graph view makes it easy to create new behavior trees, and add, delete, copy, and paste new nodes.

Tank recoil system

In Tanklike, tanks experience a recoil effect when moving, halting, or firing, akin to real-life vehicles. Initially, we implemented a static recoil animation, which did the job at the time. However, to account for the varied dynamics of different actions, I developed the Tank Recoil System. This system performs dynamic animations by adjusting intensities and motion curves specific to each action. I used Unity's Scriptable Objects to store and reuse the values passed to the system to make it easy to adjust the values when needed.

Local Multiplayer

I added a couch multiplayer option. The system was implemented using Unity's new input system. The difficulty of the game dynamically increases in multiplayer mode.

Aim-assist

The game has an aim-assist feature that takes place when the player stops both movement and aim. This adds a little boost to players who have difficulties aiming in the game.

Player Skill Tree

In Tanklike, players can enhance their tanks by upgrading weapons, gaining new abilities, and increasing stats through a skill tree. A key challenge was enabling the UI to be navigable with button inputs for controller users, eliminating the need for cursor control. I addressed this by developing a custom UI element framework. This framework includes a parent component that manages navigation through four directional slots, with each slot having a definable destination. The process of setting these destinations is streamlined with a custom editor script. This navigation setup is applied across all UI components, including the skill tree cells.
I only implemented 5 skills in the skill tree as we haven't fully tested the game's overall progression. It's still far down the project's timeline, but the system's core functionality is working.

Procedural Level Generation

I designed and implemented a procedural level generator that dynamically constructs levels by connecting random rooms from a pool. The game is a room-based game with camera transitions between rooms. This design simplified the complexity of the level generation algorithm, as there were no hallways to connect the rooms. The system places key rooms—the boss room, the player start room, and the shop within the level layout and ensures they are not directly connected to one another. As for further regions in the level, the player will be forced to look for 3 keys that unlock the boss room throughout the entire level.
P.S. The scale and number of rooms in the screenshot are exaggerated. The actual game has fewer rooms.

Dynamic Camera Controls

Camera control in Tanklike evolved as the project progressed. Initially, we utilized Cinemachine for basic follow mechanics, tracking the player's movement. However, to better meet gameplay needs, I developed an enhanced camera controller with several key features:

• The camera follows the player's cursor instead of the player directly, providing a better feeling when aiming and exploring.
• In two-player mode, the camera follows the midpoint between both players' cursors, ensuring both are always in view.
• The camera's following speed increases when a player is boosting, keeping the action in frame during high-speed movements.
• The camera zooms out during combat for a broader view and zooms in during safe periods for a more focused exploration.
• During key events, such as entering a boss room, the camera automatically focuses on the main targets to enhance the dramatic impact.
• At all times, the camera keeps the outer boundaries of the room out of view.

Tools Shop

Players have the opportunity to customize their gameplay through the Tools Shop. Here, players can purchase special tools that offer a range of abilities, which enhances their tactical options. These tools include attack enhancements, healing capabilities, and the ability to summon assistant bots, among others. Each tool has limited uses, adding a strategic layer to resource management. Additionally, players can sell tools they no longer need back to the shop in exchange for coins.

Editor Tools

I love messing with the Unity Editor scripts and frequently invest some development time creating tools that improve project and feature management. In addition to the bahavior tree I talked about above, I also added the following:

Mapmaker

I implemented a mapmaker tool that made the process of desinging rooms easier. With this tool, we could build the room using tiles, set spawn points for enemies, level props, and destructibles that drop collectables. The visuals of the individual tiles and props change depending on the level. The room is then saved as a scriptable object and can be viewed by the inspector by drawing a simplified version of it using a custom editor script.

Component Breaks

I implemented a little custom editor script that acts as a visual representation of a break between groups of components that are placed on the same game object. The font size, text, and colors can be set through a collapsable button in the break itself.

Other Responsibilities

Here's a list of other tasks that I was responsible for in the project:

• UI Programming: Developed scalable UI interaction systems compatible with both keyboard and controllers.
• Custom Utilities Scripts: Created attributes that ease the task of assigning references in the inspector, creating new Scriptable Objects, null checking, and more.
• QA sessions and playtests: Organized and conducted multiple playtests at community indie events, collecting feedback and addressing areas for improvement in weekly team meetings.
• Shaders creation: Designed and implemented a variety of custom shaders using Shader Graph, enhancing the visual style of the game.
• Documentation: Maintained thorough documentation for features, concepts, and systems to support future development and team reference.
• Script Templates: Created a custom script generator that streamlined adding new child classes—such as abilities, UI windows, and editor cheats—by integrating them seamlessly with pre-existing game features.