"Total Defense: Commander" Pre-Alpha Build blog - Midkar

Welcome to the first entry for Total Defense: Commander and its pre-alpha build release.

Game Focus

Total Defense: Commander will be a tower-defense game where the player establishes a defensive perimeter and defends it from waves of enemies. The game does not follow the formula commonly associated with the tower defense genre (consisting in having a stream of units pushing along a path surrounded by towers) but rather aims at a style closer to RTS games, with large fronts of enemies colliding with a wall of defenses supported by mobile units.

The main inspirations for Total Defense: Commander gameplay come from titles like Revenge of the titans and the cooperative survival modes of Supreme Commander and Zero-K.

The key features of the game will be:

• Allowing informed decisions about the placement of defenses using tool such as range/damage previews and terrain traverse cost visualization. These tools will be simulated using the same rules that run the game, ensuring their accuracy.
• Units customization by combining and tweaking parts (weapons, means of propulsion, chassis, utility/ability parts, …).
• Meta progression between maps where the player unlock new parts and expands its available units roster.
• The variety and replayability of a roguelike but relying on procedurally generated maps and enemies that lead the player to take different choices along an upgrade paths that is always fully available.
• Planned and coordinated attacks that change dynamically based on the map, position and type of defenses the player sets, and enemy strategy and personality.

Game Engine

The game is made in Unity, and the engine is used mostly for managing input and rendering the scene. The game simulation runs instead on custom C# code independent from Unity, ie. no GameObject, MonoBehaviour or transform is used to determine how the game progresses (excluding the fact that the simulation code is ran by a MonoBehaviour for simplicity).

This allows for a code-first approach that I personally prefer and that makes it easier to work with things like multithreading (where Unity tight bound to the main thread would often be inconvenient), or relying on a fixed-point numerical type without worrying that all transforms’s properties are of the floating-point type Vector3.

This said I still use plenty of Unity features for things like selection, detecting inputs, managing the interface and for the entirety of the scene rendering. Currently all assets found in the game are either free or part of Slava’s excellent packs.

Pre-Alpha Build

This is the first build of the game released to the public. It should run fine on any Windows with at least 5Ghz CPU. The interface is not very responsive yet, but renders fine on any resolution between Full HD and Ultra HD.

The game is still in a very early state, and features a simple random-generated map containing a few objectives that the player must defend from fixed waves of enemies. Objectives generate money every wave, and the game is lost upon loosing all of them.

There are 20+ waves of enemies that will compute dynamically their paths toward the objectives. Direct waves move toward the objective along the fastest route (concrete block and steep terrain slows them), while Sneaky waves tries to find the least defended sections of the perimeter.

The range preview (colored spheres on the ground) shows the cumulative damage that the currently selected towers deal in each position. It start loading when the game boots, and will take a few seconds to become active. When placing and moving towers, the game will compute asynchronously changes and update in real time.

The damage is represented by a scale from green to red-purple, depending on lines of sight and how many tower can hit the position.

The current collision avoidance is very primitive, and units will get stuck between structure and each other often. Units will attack the closest enemy always, there is not yet any kind of attack order or priority.