Turn Based ToolKit 3 (TBTK-3)

About Turn Based ToolKit 3 (TBTK-3) – Unity Editor Tool & Plugin

Turn Based ToolKit 3 (TBTK-3) Unity Asset Overview

In my experience building tactical strategy games in Unity, writing a grid and turn manager from scratch is usually where projects get bogged down. Turn Based ToolKit 3 (TBTK-3) is engineered specifically to eliminate that low-level framework overhead. Architecturally, TBTK-3 relies on a decoupled, event-driven pattern that separates tile graph generation, unit state management, and turn-order scheduling from the presentation layer.

The system is built around three major manager components: GridManager, TurnManager, and UnitManager. Instead of hardcoding logic into monolithic scripts, TBTK-3 makes extensive use of ScriptableObjects for unit stats, abilities, status effects, and perk trees. This makes balancing game parameters straightforward without touching underlying C# code. Communication between grid movement, combat calculations, and visual animations happens through delegates and static events, keeping performance steady even on lower-end devices.

Core Technical Features & Highlights

Under the hood, TBTK-3 provides a clean feature set tailored for tactical depth. Here is a technical breakdown of what stands out in this iteration:

• Flexible Grid Generation: Native support for square, hexagonal, and node-based custom grids. Includes built-in elevation tracking and dynamic dynamic path cost modifiers.
• Optimized A* Pathfinding: Uses an efficient implementation of A* (A-Star) with support for variable tile height, directional obstacles, dynamic cover mechanics (full/half cover), and dynamic line-of-sight checks.
• Customizable Turn Systems: Switch effortlessly between standard Turn-Based, Phase-Based, or Speed/Initiative-Based turn ordering without rewriting core battle loop logic.
• ScriptableObject Ability Pipeline: Complex skills, area-of-effect (AoE) patterns, cooldowns, action point (AP) requirements, and status overlays are configured via data containers.
• Render Pipeline Compatibility: Includes lightweight, custom shaders for tile highlighting and movement path overlays that work reliably across URP (Universal Render Pipeline), HDRP, and Built-In renderers.

Grid & Pathfinding Optimization

Honestly, the pathfinding optimization here deserves special recognition. The custom pathfinding routines avoid expensive runtime array allocations by reusing internal node lists. Tile visibility calculations use ray-casting caches, keeping framerates solid during high-unit-count turns.

Ideal Use Cases & Game Genres

While TBTK-3 can be tailored to various styles, it excels in specific gameplay structures where grid positioning and action economy are core loops:

• Tactical RPGs (TRPG): Games matching the style of XCOM or Final Fantasy Tactics with cover mechanics, elevation advantage, and turn order queues.
• Hexagon-Based Strategy: Classic 4X strategy skirmishes or tabletop war games utilizing hex movement grids and zone-of-control rules.
• Deckbuilder / Turn-Based Battlers: Single-screen turn battles where positioning, action points, and status effects dictate encounter logic.
• Mobile Tactical Games: Lightweight memory footprint and optimized pathfinding loops make it very friendly for mobile CPU constraints.

Quick-Start Unity Setup & Integration Guide

Integrating TBTK-3 into a fresh Unity scene is straightforward once you understand its manager setup. Here is how I usually initialize a operational tactical grid scene:

Step 1: Scene Initialization

Drag the primary manager prefabs into your scene from the project window: GridManager, TurnManager, and FactionManager. Ensure your project layer collision matrix reserves a dedicated layer for dynamic dynamic obstacles and selectable grid terrain.

Step 2: Configuring Grid & Tiles

Select the GridManager inspector. Set the Tile Type to either Hex or Square. Configure the dimension sliders (e.g., 10x10) and assign your visual tile prefab. Click Generate Grid to populate the runtime map layout.

Step 3: Subscribing to Event Handlers

To write custom game logic (such as updating custom UI or firing triggers when a turn ends), hook directly into TBTK-3's event API. Here is a production-ready C# example showing how to listen for turn cycles and manipulate unit Action Points:

using UnityEngine;
using TBTK;

public class TacticalTurnHandler : MonoBehaviour
{
    private void OnEnable()
    {
        // Register listeners to TBTK static delegates
        TBTK.onTurnNew += HandleNewTurn;
        TBTK.onUnitSelected += HandleUnitSelected;
    }

    private void OnDisable()
    {
        // Unregister listeners on disable to prevent memory leaks
        TBTK.onTurnNew -= HandleNewTurn;
        TBTK.onUnitSelected -= HandleUnitSelected;
    }

    private void HandleNewTurn(Unit activeUnit)
    {
        Debug.Log($"[TBTK Log] New turn initiated for: {activeUnit.unitName}");

        // Example custom logic: Grant bonus Action Points if the unit is a commander class
        if (activeUnit.IsFactionPlayer() && activeUnit.customID == "Commander")
        {
            activeUnit.RestoreAP(2);
            Debug.Log("[TBTK Log] Commander bonus AP applied.");
        }
    }

    private void HandleUnitSelected(Unit selectedUnit)
    {
        // Focus camera or trigger sound effect on selection
        Debug.Log($"Unit Selected: {selectedUnit.unitName} | Current HP: {selectedUnit.GetHP()}");
    }
}

Pros & Cons Assessment

Here is my honest developer evaluation of TBTK-3's performance and design tradeoffs:

• Pros:
  • Extremely clean, decoupled C# codebase that avoids deep inheritance headaches.
  • Highly customizable turn-order models out of the box (Per-Unit, Per-Faction, Initiative).
  • Native dynamic cover and height-difference advantage math built into damage calculations.
  • Modular Data asset structure makes item, unit, and perk balancing straightforward.
• Cons:
  • The included sample UI is functional, but you will likely want to rewrite UI controllers completely for a production game.
  • Advanced custom grid shapes (non-rectangular/non-hex) require manual node editing or scripting extensions.

Frequently Asked Questions (FAQ)

1. Can I switch rendering pipelines (URP/HDRP) without breaking tile highlights?

Yes. TBTK-3 includes standard shaders alongside URP-compatible surface shaders for tile grids and dynamic paths. If you switch pipelines, simply re-assign the provided URP material variants to the GridManager visual material slots.

2. Does TBTK-3 support real-time fog of war and dynamic obstacles?

Yes. The framework includes an optional line-of-sight and fog-of-war visualizer. When units move, obstacle colliders update the node graph dynamically, recalculating dynamic path availability and visible enemy units in real time.

3. What is the standard usage policy for evaluating this asset framework?

Assets retrieved from educational repositories or evaluation packages are strictly provided for educational, testing, and architecture-evaluation purposes only—never for commercial production releases. If you intend to ship a commercial game using Turn Based ToolKit 3, you must purchase an official license directly from the Unity Asset Store to support the original author.

Related Unity Tools Assets

Simple Car Positioning System

Easy Minimap System MT - GPS, Radar, Worldmap, Fog of War & More

Racing Game Starter Kit

Invector Third Person Controller - Basic Locomotion Template