Combat

### Introduction

Combat in Transistor is played out in either real-time, or in pseudo-turn based combat. In real-time, all of your Functions have a use-time and a cooldown before they can be used again (refer to specific Function pages for the relevant times). In Turn(), however, all attacks are accelerated and executed in a very short time, but you can only use so many Functions per turn as dictated by the planning cost of each Function (again, refer to specific Function pages). As such, Turn() is a cornerstone of Transistor's combat, and using it effectively can be the difference between victory and defeat. The primary difference between Turn() and real-time is that enemies can move significantly and can attack you in real-time, whereas they are effectively frozen during Turn().

### Turn-Based Combat

Turn() is a powerful tool that can let you destroy a single, tough target with minimal risk, or plan out a varied assault against multiple targets simultaneously. How you use Turn() is up to your playstyle and the Functions you have at your disposal, but there are a few basic universals for Turn(). First, using Turn() enters a planning phase, in which you have 100 "planning points" to use. Moving during Turn() uses up part of your planning points, so pre-positioning yourself before using Turn() can be critical. If you were to queue up a Crash(), it would deduct 20 points, and leave you with 80 - room for four more uses of Crash(). However, if you are in a situation where you have use 95 of the 100 planning points, you can overload the planning stage with a final Function regardless of how many points it would normally take. The downside to overloading the planning stage is an increased recovery time: once your Turn() has been executed, all of your Functions (except Jaunt(), Mask (), and any Function using Jaunt as a modifier) are disabled until Turn() is ready again. Deliberately overloading the planning stage can have devastating results, but it also increases the time you spend vulnerable in real-time.

Another handy aspect of Turn() is that it displays all relevant information about what a Function will do, such as its blast radius, its maximum range, its damage, and even when there's a risk of the target moving out of position before the attack gets there. If you were to use Breach() for example, a line would be drawn showing the Function's maximum range, direction, and which targets will be hit by it. A useful tip is that when you hold down a Function during Plan(), you can choose which direction it is executed while standing still. This lets you line up targets as efficiently as possible without having to reposition. What Turn() does not show is whether a target can teleport during Turn()'s execution or not, which the Young Lady can do.

### The Combo System

Transistor does not go out of its way to explain the combo system, but it does in fact have one. The system consists of linking attacks in Backstabs, Unmasks, and hitting Crashed or Voided enemies.

* Positioning yourself behind an enemy allows your Functions to deal extra damage in the form of a **Backstab**. Backstabs add 50% to the damage your Function would do (a 1.5x multiplier, as is used by the game). Backstabs can happen in both real-time and in Turn(), but you will only be able to predict the damage in Turn(), unless you already know how much damage a Function should do.

* Using Mask() renders Red invisible, while at the same time making her next Function deal 200% damage (2x multipler). Mask()'s damage bonus will be applied to any offensive Function in either real-time or in Turn(), but once again the damage will only be predictable in Turn().

* Using Crash() or any Function with Crash() as a modifier, temporarily renders an enemy vulnerable. Any offensive Function that hits a **Crashed** enemy deals an extra 50% damage (1.5x multiplier). In real-time, landing multiple Functions on a target in the period that an enemy is vulnerable can be difficult, but Turn() allows multiple Functions to hit during that vulnerable period. If Crash() was used, offensive Functions will appear to be modified by a "combo"; if the vulnerability was caused by any other Function using Crash() as a modifier, Turn() will report the modifier as "Crashed".

* Void() causes any enemies affected by it to take 75% extra damage (a 1.75x multiplier). Because Void() can affect a large area, it is useful in debuffing clusters of enemies before unleashing more powerful offensive Functions on them. Void() can stack up to three times.

##### Stacking

While each of the above can be used individually, they can be used in combination to devastating results. Here's an example: in Turn(), your first move is to Crash() your enemy from behind. Then you use Mask(), and follow up with a Breach(). Crash() would deal 75 damage (50 base damage x 1.5 from Backstab), Mask would deal nothing, but Breach() would deal 450 damage (100 base damage, (1.5 \* 1.5 \* 2). Here, Breach() recieves a 1.5x damage bonus from Backstab, a 1.5x damage bonus from hitting a Crashed enemy, and a 2x damage bonus from Unmasking. If you had used Void() before even entering Turn(), its damage bonus would still be applied; Mask()'s bonus would also apply if triggered before Turn().

### Things to Remember

Remember to refer to the pages of individual Functions for information about their use. The game also allows you to Inspect Functions to see the same information. No two battles will play out the same way, so use Combos to take out targets efficiently and effectively, whether you're taking down a big ol' Jerk, or mopping up some Badcells. Also take note that adding Jaunt() as a modifer to any Function allows it to be used during Turn()'s recovery period so you don't leave yourself completely defenseless. Which Functions you choose to take with you are up to you, but proper use of Turn() and the combo system will help you survive difficult encounters.