Warborne [Unreleased Prototype]

Overview

Multiplayer RTS/MOBA where players control a team of 4 heroes and fight for control of PVE objectives to gain points. First player to reach 1000 points wins.

Players start with a team of units that can be changed at any time.

My Role

Sole developer and designer.

Inspiration

I love RTS and Mobas games, but I found each had some issues that left me wanting more when it comes to online play:

• RTS: Controlling massive armies is very stressful. Maximizing APM can be fun sometimes, but most of the time I found myself avoiding starcraft because it felt like work.
• Mobas: My favorite part of the game is the strategy, but unless you have a full team of friends it is hard to execute any meaningful macro level play.

Design

To solve the issue of stress in RTS games:

• Slow down movement speed of units (slow turn rate, slow movement speed). I found this gave me plenty of mental bandwidth to think as I commanded units.
• Consistent set number of units (4). No need to create new control groups on the fly, consistency made controlling units a lot easier to learn.
• Each unit has 1 unique ability
• New control schemes.
  • [1], [2], [3], [4] selects each unit individually
  • Combinations of unit selection keys selects multiple units. Ex: [1] + [2] selects 1/2 at same time
  • [q], [w], [e], [r] each cast the ability for 1 unit ([q] = unit 1, [2] = unit 2, [e] = unit 3, [r] = unit 4)

To solve the issue of lack of meaningful macro play when playing a moba solo:

• Create a map with objectives that give points
  • Killing enemy units gives points
  • Bosses
  • Capture zones
• Each team has a "nexus" that stores all points. If destroyed by the enemy points a cut in half (comeback mechanic)
• Any unit can create buildings (walls, turrets)
• Units that can be swapped at any time. When a unit is swapped players incur a spawn timer penalty.
• Units are designed to counter each other (rock/paper/scissors style). This encourages scouting enemy units and adjusting accordingly

Outcome

Playtesting revealed some fundamental design flaws in the game. The most fun part of the game was fighting against another player with all 5 heroes, but the most optimal strategy was to split up heroes and capture different objectives in parallel. The goal of the game incentivized playing in the least fun way. The combat had promise, but the game loop needed to change. If I could keep the team of heroes together the game would be a lot more fun.

I pivoted the game to a single player Roguelike RTS (Magna Mater) to address these issues.

Featured Work

Multiplayer Networking

I used Mirror Networking to quickly build a prototype that allowed playertesters to connect to a server from anywhere in the world and battle against each other.

Networked gameplay features:

• capture zones
• player unit selection
• building turrets/walls with units
• unique abilities per unit (AOE slash, Mortar)
• building destruction
• networked game score

Multiplayer Unit Tests

Extended unity's test framwork to make writing multiplayer unit tests easy. I added an attribute NetworkedTest that started a new server/client and spawned networked prefabs for each test.

Having a solid bed of tests on stable functionaltiy helped me iterate on the parts of the game that were in flux.

Ex: Testing unit attack functionaltiy

[UnityTest, NetworkedTest(new [] { AssetsService.GaurdianPrefab, playerUnitTestId }, true, new [] { AssetsService.GaurdianPrefab, enemyTestId1, AssetsService.GaurdianPrefab, enemyTestId2}, false)]
public IEnumerator Attack_IsHittingTarget_NewTargetSelected_NewTargetAttacked()
{
    yield return null;
    var unit = GetSpawnedUnit(playerUnitTestId);  
    var enemyUnit1 = GetSpawnedUnit(enemyTestId1);
    var enemyUnit2 = GetSpawnedUnit(enemyTestId2);
    yield return HitEnemy(enemyUnit1, unit);
    Assert.That(enemyUnit1.CurrentHealth, Is.LessThan(enemyUnit1.MaxHealth)); 
    
    yield return HitEnemy(enemyUnit2, unit);
    
    Assert.That(enemyUnit2.CurrentHealth, Is.LessThan(enemyUnit2.MaxHealth)); 
}