The Debug Menu is a window drawn over the game by OpenCAGE's runtime utils, the plugin OpenCAGE puts in the game folder. It shows what the game is doing as it runs, from what each character senses and is about to do to the zones, nav mesh and collision your level was built with, and it has tools that act on the game: cheats, debug checkpoints, pausing and stepping, a free camera for filming, and a switch that keeps the game away from your saves.

Its tabs are in groups:

• Overview: lines of information in the corner of the screen, such as the level, the zone you're in, the player's position and the frame rate.
• Characters: every character the game is running, with what it senses and is doing, its orders and state, controls to change it, its animation and skeleton; the player, with cheats such as Stench of Evil, teleports and their inventory; the input; and the alien, with what it has learnt.
• AI: the characters' behaviour trees, the squads NPCs fight in, the trees' debug switches and log, a log of their state changes with breadcrumb trails, a few tuning numbers, and the AI's config files read again while the game runs.
• World: what's under the crosshair, the zones streaming in, trigger boxes, doors and pickups, the nav mesh, cover and jobs, and the physics.
• Scripts: a debugger for the level's scripts, their errors, triggers, progression and events, CAGEAnimations, debug entities, a profiler and the cameras.
• Sound: what's playing and why, what the AI hears, the sound network, and tools to move the listener, make noises for the AI, play sounds and check the sound network by having the AI hear in straight lines.
• Rendering: the game's own rendering switches and debug views, the lights, radiosity, post-processing, render targets and why something is or isn't drawn.
• Performance: the frame and the renderer's limits, timing, memory and streaming.
• Game: the game's flow and levels, saves and achievements, and tools: checkpoints and snapshot slots, pausing and game speed, a fixed time step, and actions on the AI.
• Cinematic: the free camera, camera tracks, visuals, the HUD, the cast and screenshots (the game's own capture too), which take the place of Cinematic Tools.

Nearly everything in it has a name, so OpenCAGE and AI assistants can read it and switch it over Live Link (see Live Link & AI Assistants).

The Debug Menu on the Torrens, on Characters > State, with the crew's labels and the Info lines drawn over the game.

Press Launch Game on the main toolbar, tick Debug Menu at the top of the Debug tools group, and pick the key that opens it from the dropdown beside the box: F7 by default, with the same choices as Launch Game's other keys. Then press Start Alien: Isolation.

The runtime utils support the Steam, GOG and Epic Games Store versions of the game, so on other platforms the box is greyed out. The Debug Menu runs alongside the rest of the Debug tools: tick Live Link as well if you want OpenCAGE's script debugger or an AI assistant to work the menu (see Live Link & AI Assistants). Starting the game from Launch Game, or by saving with Options → Misc → Open Game On Save ticked, sets it up as it's ticked there, and it then stays in the game folder, so a game started from Steam has it too until OpenCAGE next starts the game without it.

The Debug Menu can't share its key with Hot reload, Unlock mouse or Possess characters while they're ticked: Launch Game says so and puts the dropdown back. It also warns you if you pick a key the Debug Menu's free camera uses (F8 turns it on and off, F9 takes a screenshot, and F1 to F3, Home, Delete, End, Page Up and Page Down act while it flies), because the free camera then goes without that key.

Cinematic Tools are now part of the Debug Menu. Launch Game no longer has an Enable Cinematic Tools box (hover over Debug Menu there and its tooltip says where they went): the free camera, camera tracks and visuals are in the Debug Menu's Cinematic group, and the separate Cinematic Tools program no longer comes with OpenCAGE. See Coming from Cinematic Tools for where everything went.

So are three more of Launch Game's old options. The Debug Menu also does what Enable UI Memory Overlay, Enable Debug Checkpoints and Enable Level Selection did, so they've gone from Launch Game: the UI memory overlay is a checkbox in Performance > Memory, the debug checkpoints are in Game > Tools, and any level can be loaded from Game > Game flow. See Removed Options.

Don't Write Saves

Under the Debug Menu box, Don't write saves keeps the game from writing to your saved games while it runs, so testing a level never changes them. It's a Debug Menu feature, so it's greyed out until Debug Menu is ticked. Ticked, the game starts with the Debug Menu's own Don't write saves switch already on, before the game first saves, so even the save a campaign level makes as it loads is kept back.

Like the Debug Menu itself, it stays in the game folder, so a game you start outside OpenCAGE afterwards writes no saves either, until OpenCAGE next starts the game without it. In the game, Game > Saves says what it keeps back, and turns it off or on as you play. Launch Game has more on it.

In the game, press the key to open the Debug Menu, and press it again or Escape to close it.

Groups & Tabs

Along the top of the window is a row of groups in amber: Overview, Characters, AI, World, Scripts, Sound, Rendering, Performance, Game and Cinematic. Under the group in front is its own row of tabs. Overview and Sound have one tab each, so they show it straight away.

• Opening on a tab. The window opens on the group and tab you left it on, Overview the first time.
• Long tabs. Several tabs are made of parts, one under another with a line between them: scroll down for the rest. Headings with an arrow fold and unfold.
• Selecting a character. Click a character in the Characters table, or pick one from the Character dropdown at the top of the tabs that work on one character, such as State, Control, Animation and Behaviour Tree. The selection is shared by every tab.
• Hover for more. Most switches and buttons say what they do when you hover over them, and many say why they're greyed out.
• Greyed out. A view that needs a level says No level running until one is. Anything your release of the game can't support is greyed out and says not available on this game release, rather than running and failing.

The Window

• Moving it. Drag the window by its title bar, Debug Menu (F7 or Escape closes it), or by its bottom-right corner to resize it. It starts in the top-left corner. On a screen 1000 pixels tall or more, its text is drawn larger.
• Your keyboard and mouse are the window's. While it's open, your mouse cursor is shown and the game doesn't see your keyboard or mouse, so you can click through the window without the player moving. A gamepad still reaches the game.
• The game keeps running. To hold it while you look, tick Pause while this window is open in Game > Tools, or press Pause there. While the game is paused, changes that act on characters (the Control tab, the alien's setup, the AI actions) wait until it runs again or steps.
• Notes along the top of the screen. A few things put a short line at the top of the screen, such as a save kept back or the scripts held at a breakpoint. They stack, so none covers another.
• What lasts. Switches stay as you left them until the game closes, level loads included, with a few exceptions: the tree switches go back to unticked when a level loads, and a level change turns the free camera off, along with the tests that change how the game plays, such as Stench of Evil, the Control tab's damage choices and the fixed time step.

Drawn Over the Game

Many tabs have switches that draw over the game: labels and view cones over characters, skeletons, the nav mesh, collision boxes, trigger boxes and more. They're drawn whether the window is open or not, so close it to play with them on screen.

• Through walls. What the Debug Menu draws isn't hidden by the level. Most of it is only drawn out to a distance you can set, and the nav mesh has a height band to keep other floors out.
• From any camera. It follows the camera the game draws from, the free camera and Live Link Camera included, so you can look down on a room from above.
• Out of the window's way. The Info lines sit in the top-left corner, and move beside the window while it's open.

The Overview group has one tab, Info, so choosing the group shows it.

Info

The Info tab puts lines of information in the top-left corner of the screen, whether the window is open or not (while it's open, they move beside it). Tick the ones you want, or All or None:

• Level: the level running.
• Zone the camera is in: the zone the game has the camera in, by the name of its Zone entity, and how many of the level's zones are loaded. Zones loaded, by name lists them, handy when an area streams in wrongly (World > Zones has the rest).
• Player position and facing, and Player speed: how fast the player is moving across the ground and up or down, over the last half second of game time.
• Player health, stance and light: their health, whether they're crouched, hiding, in a vent or have the torch out, and how lit they are for the AI.
• Camera position and direction, Frame rate, and the Game clock, with the speed it runs at while the game speed isn't 1.
• Nearest alien: how far away it is, its branch, whether it's in the vents, and its menace. Characters: how many are alive and dead, and the nearest one.
• Draw calls and primitives, GPU frame time and Memory and address space: the game's draw calls a frame, how long the graphics card takes over a frame (with GPU timing on in Performance > Timing), and the game's memory with how much of its address space is left. See Performance.

The frame-time graph from Performance > Frame goes under these lines.

Names

The Overview group's switches, for Live Link & AI Assistants:

The Characters group is about the characters the game is running, the player included: what they know and are doing, and tools that change them. Its tabs:

• Characters: every character, with what it senses and is aware of, its health, mood and target, and where it's going, with labels, view cones and paths drawn over the game.
• State: the selected character's orders, what its body is doing, and its state flags.
• Control: change the selected character: what it may do, its mood and its health, make it invulnerable, try damage effects on it or ragdoll it, or take it out of the level and spawn it again; and choose the damage every NPC takes.
• Animation: its animation trees, layers and clips by name, its skeleton, animation switches, and the level's animated objects.
• Player: the player's cheats, health and teleport, how lit they are for the AI, hiding, what's under foot and the objectives, Stench of Evil's options and the screen effects.
• Inventory: what the player carries, and giving them more.
• Input: what the game thinks is pressed.
• Alien: the alien's menace, ambushes, sweep and vents, and what it has learnt.

Characters

The Characters table lists every character the game is running, the player first, with:

• Name: the name the game gives the character. On many levels the game leaves every human with the same name (the Torrens crew are all Andy, and the alien is Alen), so look at the selected character's ids to tell them apart.
• Class: Player, Alien, Android, Human, Security, Facehugger, Innocent, Heavy android, Tracker or Human (melee).
• Distance from the camera, and Health.
• Awareness / menace: how aware it is of the player, from Unaware upwards, or for the alien its menace.
• Alertness, aggression, Mood and Branch: the behaviour branch it's in, such as an idle job, a search or an attack.

Click a character to select it. Its details appear under Selected, in sections you can fold:

• Who: its name and class; its unique id, and the ids of the Character entity it was spawned from and the composite instance that entity is in; the behaviour tree it runs; and where it is.
• State: its health, awareness of the player, alertness, aggression and mood, its branch and the one before it, and whether its enemies sense it. The alien shows its own awareness too, a character working towards spotting the player how far it has got, and any character what it's doing now: crouched, torch out, in the vents, stunned and so on. The player shows how long they've been hiding.
• Target: who or what it's targeting.
• Senses: each sense's level against its four thresholds (trace, lower, activated and upper), and which senses and view cones it's using.
• Last known positions: where each sense last placed the player, and how long ago.
• View cones and hearing: each of its view cones, with its type, length, width and height and whether the player is in it, and how far it can hear.
• Path: whether it's moving and how fast, the path it's following and how far along it is, where it's going and how far it has left, and what its pathfinding is doing.
• Flags and timers: the logic flags set on it, and the timers it has running.

With more than eight characters in the level, only those within 60 m of the camera are read in full: the table shows what it can for the rest, and a far character's details are read once you select it.

The Characters tab on the Torrens, with one of the crew selected.

Drawing Over the Game

The switches under Draw over the game, at the top of the Characters tab, draw for the selected character only, or for every character with For every character ticked beside them:

• Labels over heads: a label over each character with its name and class, its branch, its awareness, alertness and aggression (for the alien, its menace), what it's targeting, and a bar showing how close its senses are to noticing the player, against their thresholds. The player's label shows how lit they are for the AI, and is only drawn while the player is selected.
• View cones: each of its view cones, from its head, coloured by its place in the character's set of cones. A cone the player is in is drawn thicker and filled in.
• Hearing range: a blue circle at its feet, as far as it can hear.
• Paths: the path it's following: the part already passed in grey, the way to the node it's heading for in white and the rest in blue, with the corridor it may walk in green and a yellow cross where it's going, labelled with the distance left.
• Last known positions: a cross where each sense last placed the player, labelled with the sense and how long ago.

Labels, view cones, hearing ranges and paths for every character, seen from above the Torrens bridge with the game's camera following OpenCAGE's Viewport over Live Link. From up here the level isn't drawn, only what the Debug Menu draws.

State

The State tab shows the selected character's orders and what its body is doing. It only reads the game, so it changes nothing:

• Orders: the command a script gave it (a command entity of the level's scripts, such as CMD_Follow, by its name there, with how far it has got) and the command its own behaviour tree's tasks gave it, each with the one queued after it. A script's command shows the ids of its entity and composite instance, so you can find it in OpenCAGE. Then the layered states its body is in (the overall one, moving and cover, with an arrow to the state it's about to go to, and dying), how it idles, and what has been asked of its body (moves, turns and the like) with how each went and where to.
• Doing: the action it's in and the one before it, and the secondary actions layered on it, such as breathing, looking and aiming.
• State flags: its alliance (and its alliance at spawn), the traversal it's on, and its stress; whether it takes no damage, doesn't react to hits, is very important or is untargetable, each with what set it (an action, an activity, combat, a script, a cutscene or debugging); then its 105 state flags, in the game's three sets. Tick Only those set, or type in the filter, to find one. A flag that changed in the last two seconds is drawn brighter.

Control

The Control tab changes the selected character through the game's own calls. The changes are made as the game next updates its characters, so nothing happens while the game is paused. The Last line at the bottom says what was done.

• Motivations (NPCs only): the families of behaviour its behaviour tree may run (attack, stalk, systematic search, idle job, use cover, melee, retreat, panic and the rest), as tick boxes: untick one to keep the character out of that behaviour. Back to its defaults puts them back as they were when it spawned. Force idle (debug) is a debug motivation: the tree's idle branch runs ahead of everything else while it's on, where the tree has one.
• Mood (NPCs only): the mood shown, and what each of the four layers moods are set on (the AI's, scripts', other code's and dialogue's) holds and for how long. Force mood holds neutral, scared, angry, happy, sad, suspicious or injured on the top layer until you choose (not forced). The face and voice follow the mood shown.
• Health: its health against the most it can have. For an NPC, set it with the slider (at least 1), or press Damage 10% (it reacts as to a hit), Down to 1, Set on fire (it burns for 5 s) or Kill (as the game's own death actions kill). The alien can't be killed, as the game has no death for it, and a character set to take no damage doesn't die. Under them are its retreat and stun damage gauges against their thresholds, and its stress. The player's health is on the Player tab.
• Spawning: Despawn takes an NPC out of the level, as a script calling despawn on its Character entity would. It's then listed under Despawned here with a Respawn button, which calls spawn on that entity: the game makes the character again where the level placed the entity (not where it was despawned), with a new unique id, once it has a free character slot and has loaded the character's assets. The list shows how far each has got. A script waiting on a despawned NPC may stall.
• Invulnerable (NPCs only): tick it and the selected NPC takes no damage, as God mode does for the player. It's the game's own debug switch, kept on every frame. It still reacts to hits, and the game's forced kill (the level's scripted deaths, and Kill above) doesn't kill it either. Several NPCs can be invulnerable at once: they're listed under the tick box, each with an Off button. It goes off when you untick it, when the character leaves the level, or when the level changes.
• Damage to every NPC: one choice for the damage every character but the player takes. As the game deals it; One-shot kill: any damage kills; One-shot maim: any damage leaves 1 health, for injured animations and behaviour; At most 1 damage: a fight lasts, and every hit reaction can be watched; Nobody dies: a hit that would kill leaves 1 health, to keep story NPCs alive while you test. The alien never goes below 1 health whatever you choose, as the game never lets it die, and androids set up as showroom dummies are left as the game deals with them. Nobody dies holds the level's scripted deaths (and Kill above) at 1 health too, which can stall a scripted sequence that waits for a death. A level change sets it back to as the game deals it.
• Don't end the game when an ally is hurt or killed: the game tells the level's "player killed an ally" monitor when the player damages a character that isn't an enemy, and when one dies, and the levels that have that monitor end the game. While this is ticked it isn't told: handy for tests that kill characters, such as Stench of Evil, one-shot kill or the damage effects below. The tab counts the reports kept back and let through. A level change turns it off.
• Damage effects: Stun, EMP, Blind, Acid, Gas and Fire, on the selected NPC or on everyone within the Radius around the player (20 m to start, measured straight through walls and floors; a ring shows it while you choose). Each is the game's own explosion damage, from the player, carrying that effect as a grenade does, and the character takes it as it would a real one: a human is stunned, gassed or blinded and only flinches at fire or acid; an android takes EMP (it is stunned, and takes more damage meanwhile), blind and fire (it is set alight) but not stun or gas; the player's allies shrug off stun, gas, blind and EMP; the alien's stun gauge fills. Each effect comes from the game's ammo files as loaded, so an edited ammo file is what you test: stun is the stun grenade's nearest range, blind its middle range, EMP the large EMP burst's outer range, acid the small acid burst, gas the smoke grenade and fire the fire grenade's middle range. Hover over a button to see which ammo and range it uses now, with its times and damages. With With its damage off (the default) it's the effect alone; ticked, it also does the damage that range does to that kind of character, which can kill. A kill counts as the player's, and the next checkpoint keeps it, so turn on Don't write saves first; and as hurting one of the player's allies can end the game, Don't end the game for hurting an ally sits beside it, the same switch as the one above.
• Ragdoll: tick Ragdoll to let the selected NPC's body fall as a ragdoll, and untick it to stand it back up, for checking a skeleton's ragdoll, an imported one above all, without killing anything. It's the game's own ragdoll switch for a living character, as the level scripts' CMD_Ragdoll uses it. Push gives it a speed away from the camera as it falls. The ragdoll is only the body's: the character's behaviour carries on underneath, so it would walk on, turn, aim and talk while its body lies there, and stand up wherever that took it. Hold its AI still while it is down (on to start) turns its force idle motivation on meanwhile, and back off when it stands up. If it dies while down, the ragdoll becomes its death's and it stays down; if it leaves the level, or the level changes, it's simply let go. Down lists those down with a Stand up button each.

Animation

The Animation tab shows what the selected character's animation system is doing, with the names of its trees, nodes, clips and bones, which the game itself keeps only as numbers: the Debug Menu reads the names from the game's DATA\GLOBAL\ANIMATION.PAK the first time it needs them, so they follow a modded package too.

• Character: its rigs (the gameplay one and the finer cinematic one, with their bone counts), its animation set and tree set, its stance, mood and equipment, which of its animation features are on, how often it's posed (characters far away are posed less often) and its ragdoll.
• Layers: the eight layers its pose is built from (full body, general additive, breathing, look at, gun or tail, hand, face, and the final pose), with whether each is used, its weight, and how many trees and clips it has.
• Trees: the animation trees running on each layer, with their weights. Expand one to follow its nodes down to the clips: each node's type, name and weights, what a selector picked and from which parameter, and for a clip node the clip, its time and length and its speed. Only nodes with weight hides the branches that contribute nothing.
• Clips: every clip playing, split into those with weight and those without, with how far through each is, its speed, how many times it has looped and whether it's mirrored.
• Movement, Reference locator and IK: the movement the animation extracts this frame, the velocities the character wants and gets, the point a matched animation (a kill, a door) is lined up to, and the IK solvers with their targets.

Skeletons

The switches at the top of the Animation tab draw over the game, for the selected character or, with For every character, every one:

• Skeletons: each character's posed bones, the pose the game skins its mesh with, left bones blue and right orange. A character the game didn't pose this frame (far away, or out of view) is drawn dimmer. Bones near the camera, such as the player's own head, are left out. Pose drawn picks the final pose or any one layer's pose instead.
• Bone names (the selected character), Bone axes and Helper bones (the head, hips, root, hands and feet the game tracks).
• Velocity: arrows for the velocity the character wants, the one its animation gives and the one it ends up with. IK targets: where its IK is reaching for.
• Tree and clip over heads: each character's full-body tree and the clip carrying the most weight.

The alien's skeleton over its mesh, seen through the game's camera placed by OpenCAGE's Viewport over Live Link.

Animation Switches

Further down the Animation tab are the animation Switches. Each changes one of the game's own steps in posing a character, for every character, or only the selected one with Only the selected character ticked:

• IK off: feet are no longer placed on the ground, hands on what they hold or touch, or heads turned to look.
• Velocity warping off and Turning warping off: the character moves and turns only as its animations do, so it can slide off its path.
• Level of detail off: every layer at full weight, and the character posed every frame however far away it is (characters out of sight still aren't posed).
• Reference pose: every layer is put in its rig's reference pose, the pose it was modelled in. IK still applies unless it's off too.
• Ragdoll pose off: a character in ragdoll keeps the pose its animations give. Its body still falls.
• Layers off: General additive, Breathing, Look-at, Hand and Face, each given no weight, as the game does for distance, so the layers under it show.

Under them, Reference locator has Draw the reference locator: while a matched animation (a kill, a door, a ladder...) lines a character up with a point, the point is drawn as axes with a line from the character. Layer weights by bone group shows how much each layer's pose counts on each group of bones, as the game combines the layers.

Environment Animations

Folded at the bottom of the Animation tab, Environment animations lists the level's animated objects, what PlayEnvironmentAnimation entities play, nearest the camera first: each one's rig, clip, time, state, distance and script entity (hover over the entity for its composite instance). Draw their skeletons and With labels draw their skeletons over the game, Within a distance of up to 300 m. Click one in the list to pick it out: it's drawn highlighted, however far away it is.

Player

The Player tab is in parts, from the top: the cheats, health and teleport; the player as the AI sees them, below; then hiding, what's under foot and the objectives; and at the bottom, Stench of Evil's options and the screen effects.

• Light: whether the player is dark, partially lit or fully lit for the AI, with the brightness the game measured and what it comes to through the AI's light curve, against the thresholds. The game measures the light at three heights on the player, each listed with the colour it found; tick Show the sample points to draw them in the game. The game turns the meter off for a while after the player is detected, and says so here.
• Light meter tint: tick Tint the screen by light level to tint the screen by how lit each part of it is for the AI, blue where it's dark (the game's own debug view). Opacity sets how strong the tint is.
• Stealth: the player's exposure, stance, cover and movement, whether they're hiding (and for how long), and which character is closest to spotting them, and how close. The alien's own progress is shown separately, as the game doesn't count it there.

The light meter tint: the dark parts of the room, where the player would be hard to see, turn blue.

Cheats & Teleport

The top of the Player tab has the player cheats:

• God mode: the player takes no damage. It's the game's own debug switch, kept on every frame, since the game turns it off on some deaths and when a level script turns its own invincibility off. The alien's grab and a facehugger's leap aren't damage: they switch that protection off and kill in the same moment, so god mode keeps them from happening at all. The alien still sees, hunts and chases you, but never finds an attack it can make on you (as when it can't get at you) and doesn't drop on you from a vent; a facehugger waits beside you instead of leaping. Deaths the level's own scripts cause, such as a script ordering the alien to attack or killing the player, still happen.
• Untargetable: the AI doesn't choose the player as a target to attack, though it can still see and hear them. Invisible to the AI: the AI's senses no longer pick up the player; a character already hunting them keeps what it last sensed until it loses track.
• Invisible but audible: the AI can't see the player, or their torch light, but still hears them (footsteps, gunfire, thrown items, noise makers) and still feels being touched, hit or burned. Use it to test what the AI hears on its own: a character that comes to a noise you made did it by ear. A squadmate passing on what it sensed still gets through, since with sight kept back that can only be something heard or felt.
• The alien can't grab the player: the alien part of god mode on its own, for when you still want to take damage from everything else. Every alien, including ones that turn up after you tick it, still hunts and chases you, but never grabs you or drops on you from a vent.
• Break free of strangles: a human or android that grabs and strangles the player lets go, as if you pressed the button to break free five times a second. It's the game's own handling of the press, so its grapple icon pulses and fills as the presses are counted, and the grab breaks when it would have for a player pressing that fast. The alien's grab is a kill, not a strangle: tick The alien can't grab the player for that.
• Stench of evil: every enemy of the player within 5 m of them dies, every frame while it's on. See Stench of Evil.
• Infinite ammo: the player's weapons use no ammo from the clip when fired, so turn it on with ammo in the clip. Infinite items and Never run out of torch batteries are described under Inventory.
• Health: a bar of the player's health, what's keeping them from taking damage (god mode, or the level's scripts), and their last hit. Full heal; Set health to a share of the most they can have, for checking injured animations and medikits; and Kill the player, the game's own forced kill that its scripted deaths use, so you can test the death and game-over screens on demand (god mode is lifted for it).

Teleport moves the player to a position you type (Copy puts where they are now in the box and on the clipboard), To the camera (fly the free camera there first; the player's feet go where the camera was, so expect a short drop), To the crosshair (the point under World > Inspect's crosshair), or Back to where the last teleport took them from. It's done the way the game puts back a character that fell out of the world, at the end of the next physics frame. Somewhere with no floor loaded, the player falls, and the game puts them back where they last stood.

Hiding, Under Foot & Objectives

The bottom of the Player tab:

• Hiding: whether the player is hiding, for how long, and whether in a vent; where the AI looks for a hiding player (the point the script of the hiding place they last used sets, which the alien goes to when it comes to pull them out), drawn with Draw where the AI looks for the hiding player; for each alien, whether it's going for the hiding player and whether the player won the struggle; and what the alien has learnt about hiding: whether it searches lockers and under things yet, and how often the player has hidden from it.
• Under foot: what's under the player's feet, from the four rays the game casts down from them: the sound material the footsteps use, the physical material and whether it's walkable or climbable, the zone that puts them in and whether it's visible, whether they're in water or off the ground, where they're supported and the drop below their feet. A table gives the row of the level's collision map each ray hit, with its entity, composite instance and zone. It's a quick check of OpenCAGE's collision and material changes in place: a wrong footstep sound, or a zone that streams out underfoot, shows up here. Draw the support point and the surface draws them.
• Objectives: the primary, secondary and exit objectives as the player's inventory holds them, with their text in the game's language, and the motion tracker's objective and how far it is by its route. Draw the motion tracker's route draws that route. Show the objective popup shows the game's objective popup with any text or text key you type, and Popup beside an objective shows it for that one; the objectives themselves aren't changed.

Stench of Evil

Stench of evil is a super power the game still has the code for, though nothing in the shipped game turns it on: every enemy of the player within 5 m of them dies, every frame while it's on. Tick it among the cheats at the top of the Player tab, or in its own section near the bottom of the tab, which has its options:

• Radius: how far from the player it reaches, 5 m unless you change it. It's a straight line, so it reaches through walls and floors and into vents. A faint ring on the ground round the player shows it while it's on (untick Show the ring to hide it).
• Who counts as an enemy comes from the game's own alliances, which the level's scripts change as a mission goes on: characters friendly or neutral to the player are left alone. Every character within the radius is listed under the options, with what the stench did to it.
• Include the alien: off unless you tick it. The alien can't die from it, as the game never takes it below 1 health. It's still hit, though, and forced into a death reaction every frame it stays near the player, which hasn't been tried in game yet. Androids set up as showroom dummies are always left out, as the game never lets them die.
• Spare the script-invincible: as the game does it, the stench clears every "takes no damage" flag on the characters it reaches, invincibility set by the level's scripts included, so they die too. Tick this to leave characters set to take no damage alone instead. NPCs made invulnerable in the Control tab are always left alone, and nothing happens while the Control tab's damage choice keeps a hit from killing outright. A character that survives (the alien, say) gets its flags back when you turn the stench off.

The deaths are normal ones: the level's scripts hear of them, and the kills are the player's, so they count towards achievements and stats. Tick Block awards and stat writes and Don't write saves (Game > Saves) first, and expect a mission to stall if the stench kills a character it still needs. A level change turns it off.

Screen Effects

At the bottom of the Player tab, Screen effects sends the events the game sends the HUD when the player is hurt, strangled, healed or killed, without any of that happening: for testing mods of the HUD and damage-overlay composites. The level's ScreenEffectEventMonitor entities pass each one on, so the composites play what they would for the real thing. The line above the buttons says which effects are showing and how many monitors the level has registered (the game takes up to eight).

• Low health on and off, Strangle on and off, Death on and off: states the game keeps, so each change goes out once (pressing on while it's showing sends nothing).
• Melee hit, Bullet hit, Acid hit, Flashbang hit, Medkit heal, Hit and run and Cancel hit and run: one-off events, sent every time.

The game ends low health and death by itself as soon as it next checks the player's health, unless the health really is low or the player is dying. Tick Hold low health and death to stop that check, so they stay until you send them off. The hold lets go when you untick it, or when the player changes (a checkpoint restart or a new level), and the game then ends whatever doesn't apply. Strangle stays until sent off; a level change or restart clears all three.

Inventory

The Inventory tab shows and changes what the player carries. Everything here changes what the next save holds, so while Don't write saves is off an amber line at the top says so: turn it on first to keep a campaign save clean.

• Current weapon: the weapon in the player's hands, its ammo type, clip and the ammo carried, overheating and charge where it has them, and the torch with its battery. Fill this weapon's ammo gives every ammo type it takes, as much as can be carried; Fill ammo for every weapon carried does it for all of them.
• Inventory: slot by slot, each item with its kind, its count against what can be carried, and whether it's in hand, selected or locked, with a Fill button. Top up everything fills all but the weapons.
• Give: the game's own item list, so modded items are in it too, with a filter. Give a count, or Fill up to what can be carried; double-click an item for a batch. Items are given as the level scripts' AddToInventory gives them: only with a free slot, and capped at what can be carried. Give all gives medikits, flares, every IED and crafting part as many as can be carried, and every blueprint. Give every weapon adds each weapon with its ammo filled; it hasn't been tested in the game yet, so a weapon may not land in the weapon wheel as a picked-up one does.
• Blueprints and keycards: which blueprints are available, with Give every blueprint (the game's own call, which also marks them collected), and the keycards, with Collect every keycard.
• Gating tools: the key, axe, crowbar, gas mask, cutting tool, hacking tool, rewire tool and cable clamps, ticked when carried, each with its level (type one and press Enter). A hack's or a rewire's difficulty follows the tool's level, and the tab shows the hardest hack each hacking tool level opens. Give every tool at level gives them all, at 50 by default, which opens every hack.
• Infinite items: using up an item (throwing, placing, using or equipping a flare, an IED, a noisemaker, a medikit...) leaves as many in the inventory, as one more is added just before the game takes one. It hasn't been tested in the game yet. Never run out of torch batteries keeps the inventory full of them; the battery in the torch still drains, as that's up to the level's scripts.

Input

The Input tab shows what the game thinks is pressed: every action of the player's input, or from the dropdown the menus' or the debug input, with its state (pressed, held, released, toggled or disabled), each analogue value that isn't at rest, and whether the input is enabled, movement let through, and the input locked by the interface. Every action lists those at rest too.

While the Debug Menu is open it has the keyboard and mouse, so the game sees nothing from them: tick Show what is pressed over the game and close the window to watch it as you play, or use a gamepad.

Alien

The Alien tab shows the alien's own state, once it has spawned:

• Its setup (its difficulty set-up, such as MODERATE) and the branch it's in.
• Menace: its menace gauge against its thresholds, whether it's menacing the player, its menace timer, how many times it has menaced the player, and whether it's withdrawing.
• Ambushes and killtraps: what it has decided about lying in wait, and who asked for a killtrap.
• Sweep area: how it's sweeping the area (round the player, or in and out between the player and a point), the point and the box it sweeps. Tick Draw the sweep area to draw them in the game.
• Vents: whether it's in the vents (backstage), how many vents it knows, and where it's heading. Tick Draw where it heads in the vents, and the best vents to draw that, with the best vents near the alien and near the player.

The alien after being drawn to the player a few times (as Alert the alien to the player does): it has menaced the player twice and is back in the vents, sweeping the area.

What the Alien Has Learnt

Under the alien's state, the Alien tab has three more parts:

• What the alien has learnt: the difficulty, the lowest played, and the furthest mission the alien has spawned in this run. Then its tricks (threat aware, closes in through the vents, kill traps, flanks, flanks from threat aware, ambushes, searches lockers and searches under things), each with whether it's unlocked, what its behaviour tree's own check answers, and the counter that unlocks it against the number it unlocks at on this difficulty: how many times the alien was driven off with fire or searched for the player, or the player hid from it or hid in a deep crouch (ambushes only come with a stage). On Nightmare every trick is on, whatever is unlocked. Tick or untick a trick to give it or take it away, or Set a stage, one of the alien's four learning stages: Naive, Threat aware, Getting sneaky and Really sneaky.
• Setup and the director's numbers, with an alien in the level: switch the alien's setup to any of the level's, as NPC_AlienConfig does, and read what the game's director makes of the setup at the difficulty played: how fast the menace gauge fills, when a menace counts, the sweep box and how fast the sweep widens and narrows, when the alien is drawn to the vents, how long it sweeps backstage, and the most menaces before it withdraws.
• Draw the alien to a point: every alien hears the player moving at the point under the crosshair (World > Inspect), at the camera or at the player, past its Suspicious threshold (it comes to search) or its Alerted one (it comes to hunt). It's greyed out with no alien in the level.

What the alien has learnt belongs to the game rather than to one alien, so it can be changed with no alien in the level, and every alien uses it. The game keeps it in memory only, never in a save: the level scripts set a stage at points in the campaign (NPC_SetAlienDevelopmentStage), and the alien's first spawn in one of the first three missions starts it over, so a change lasts until then, or until the game closes. A trick you take away comes back the next time its counter counts, if the counter is past its number.

Names

The Characters group's switches, values and commands, for Live Link & AI Assistants. The State and Control commands act on the selected character, or on the one given as id= its unique id; help gives each command's arguments.

player.give takes an item and a count or max, such as medikit,max: the item by the game's own name for it, the name the game shows, a name players use (medkit, revolver, stun baton...), or enough of one to tell which. player.teleport takes x,y,z. ai.damage_mode takes normal, kill, maim, max1 or nobody_dies (no argument says which is on), ai.invulnerable takes on or off, and ai.hit_from_player an amount of damage (with none, a tenth of the most health the character can have), dealt as a hit from the player. ai.damage_effect takes an effect (stun, emp, blind, acid, gas or fire), or any ammo type and range as ammo=GRENADE_HE range=1, then radius (or radius=10) for everyone around the player, and damage or nodamage; ai.damage_effects all lists every range of every ammo type. ai.ragdoll takes on, off or toggle. player.screen_effect takes an event's name or number, as player.screen_effects lists them.

The AI group shows how the characters decide what to do. Its tabs:

• Behaviour Tree: where the selected character is in its behaviour tree, node by node.
• Squads: the NPCs that fight together, their objectives and their cover.
• Tree Switches: the behaviour trees' own debug switches.
• Tree Log: what the trees' debug actions log.
• State Log: the characters' state changes, and breadcrumb trails of what each did where.
• Tuning: five tuning numbers the game reads as it runs, and under them, the AI's config files read again.

Behaviour Tree

The Behaviour Tree tab shows where the selected character is in its behaviour tree, the same trees you can open in the Behaviour Tree Editor:

• Tree: the tree it runs, and its outer branch (and the one before it).
• Active path: the nodes it's running, from the root down to the leading node, each with its name, what a condition answered, and whether it's running a child or running itself. Hover over a node for the tree file it came from, its number in that file (as the Behaviour Tree Editor numbers them) and its other attributes.
• Active branches, and Recent events: the branches it has switched on and off and the actions that succeeded or failed, newest first, with how long ago.
• This character's debug texts and asserts: what its tree's debug actions have logged (see Tree Log).
• Tree files loaded for this level: each tree file the level loaded, with its node count.

Tick Show over characters to draw each character's leading node, outer branch and latest debug text over it in the game (the nearest twelve at once).

The node names are noted as the level loads its trees. If a level's trees ever loaded before the Debug Menu could follow them, the tab says so: its nodes show only their class, and the Tree Switches tab has no switches for that level.

The alien in a Survivor map, sweeping the area round the player after breaking out of the vents (the one-shot Force_Breakout tree switch sent it, and unticked itself).

Squads

The Squads tab shows how the game organises NPCs that fight together:

• The group of NPCs: every NPC the game's group holds (the alien is never part of it), with its awareness of the player and the highest it has reached, its objective (a move, its start, cover or a safe point) and where, its nearest safe point, its target and how far away, and whether it may melee and pursue. Under it, how many safe points the level has.
• Squads: the squads the game makes of them while they fight together, each with its aggression, members and how many are searching, its centre, how its cover search is going, each member's cover request with the cover slot it asked for and the one it was given, and the targets they share.

Squads and objectives draws an arrow from each NPC to its objective, labelled, and each squad's centre with lines to its members; Safe points draws the level's safe points as green rings. With no NPCs fighting together, there are no squads and the tab says so.

Tree Switches

The behaviour trees have debug switches of their own: the DebugMenuLinkTest and DebugMenuLinkItem nodes in the Behaviour Tree Editor. The Tree Switches tab lists those in the level's trees, with each one's default and the trees it's in. Tick a switch to make its test go the other way from its default; an action with the same label sets it back to its default when a tree reaches it, so a one-shot switch, such as Force_Breakout, unticks itself.

The switches act for every character, or only for the selected one with Only for the selected character chosen (the Character dropdown is greyed out until it is). Untick all puts them all back, and they all go back to unticked when a level loads. The shipped trees have 18, among them Disable All Aliens, which sends the alien into an idle action until you untick it, Force_Backstage_Stalk, Allow Hit And Run, Force Android Idle, Human Direct Control and Force Idle.

Two of them need a word. Allow Hit And Run is on by default, so ticking it turns hit and run off. Alien Gamepad control, Android Direct Control and Human Direct Control lead to branches that also need the game's own free camera (not the Debug Menu's), which the game never turns on, so on their own they do nothing: Possess Characters does that job.

Tree Log

The behaviour trees' DebugString action logs its text whenever a character's tree runs it, and the Assert action its message. The Tree Log tab lists them for every character, newest first, with how long ago, the character, the text, the node it came from and how many times it repeated (a line counts its repeats until a second goes by without one). Clear empties it.

The shipped trees use no DebugString, and their five asserts only fire in rare cases, so the log is for trees you've edited: add a DebugString to a branch in the Behaviour Tree Editor to see when characters reach it.

State Log & Breadcrumbs

The characters' state machines (moving, cover, dying, the weapon and shooting) still hand a line to a logger from 29 places in the game, which then throws it away. With Log state changes ticked, the State Log tab keeps each one: the time, the character, the machine, and the change from one state to another, with what it wants or the state it's in alongside. Only the selected character narrows it to one, the filter finds a character, machine or state, and Clear empties it. Nothing is logged until it's ticked.

Breadcrumbs are a trail of what each character did where. Draw breadcrumbs draws, for the selected character or with For every character every one, a trail of where it went, and a labelled crumb wherever its behaviour tree branch, awareness, mood, body state, action, script command or health changed, where it went into or out of the vents, and where it died (and each state change, with the log on). They fade over a minute, or as long as Kept for says, from 10 seconds to 10 minutes.

The alien's breadcrumbs over the last minute: where it went, and what changed where.

Tuning

The Tuning tab has five numbers the game reads every time it uses them. Each is given here with the game's own value:

• Human and android melee range: how close a human or android must be to land a melee attack (2.5 m).
• Android melee spot kept for: how long an android keeps to the melee spot it chose round its target before choosing again (60 s).
• Android grapple: delay before it hurts: how long an android's grapple holds the player before it starts doing damage (1.5 s).
• Player throw speed: how fast the player's thrown items (flares, noisemakers, pipe bombs...) leave the hand (20 m/s).
• Explosion damage to the player's allies: how much of an explosion's damage the player's allies take (half).

Reset beside each puts it back to the game's value. Changes last until the game closes.

Config Files

The game reads three of its config folders once, when it starts, and keeps them for as long as it runs: the alien configs, the difficulty settings and the viewcones. Under the Tuning tab's numbers, Config files has the running game read them again from the files, and has the characters take them up, without restarting it:

• Alien setups: each alien works out its timings and its menace numbers again from its setup.
• Difficulty: every character takes up the difficulty's settings again. The difficulty you're playing, and the lowest you've played this campaign (what the difficulty achievements go by), stay as they were.
• View cones: the characters see with the new cones from the next frame.
• All: all three.

You don't need the buttons when you edit these in OpenCAGE: with Live Link connected, the Alien Configs, Difficulty Settings and Viewcones editors have the game read the folder again after each change, and say how it went on their status line (see Live Settings). The buttons are for files edited some other way.

A file that's missing, or can't be read as a config file, stops its folder being read again, with nothing changed, and Last says which file. If a setup or difficulty the game holds isn't in the files any more, it keeps its old numbers. With the game paused, or no level running, the request waits until the game runs again. What the game holds can be listed with the command ai.configs: each alien setup's numbers at the difficulty being played, the difficulty, how far each NPC hears, and each set's view cones.

Names

The AI group's switches, values and commands, for Live Link & AI Assistants:

The World group shows the level around the camera and the player. Much of it is what Save and Build bakes, as the game loaded it, so it's the place to check a rebuilt level. Its tabs:

• Inspect: what a crosshair in the middle of the screen is on, from its row of the level's collision map to the model drawn there.
• Zones: the zones streaming in, and why each view is in its zone.
• Overlays: trigger boxes, doors, splines and pickups drawn over the game, and measuring rings.
• Navigation: the nav mesh, its barriers and doors, the AI's path searches, and who can get where.
• Cover & Jobs: the level's cover and the AI's jobs.
• Physics: static collision, bodies and capsules, physics systems, and the rays the game casts.

Inspect

The Inspect tab tells you what the camera is looking at. Tick Crosshair inspector and a crosshair appears in the middle of the screen: a ray is cast from the camera along the way it looks, through the game's own queue of rays (the one its zone streaming, footsteps and AI sight use), so the answer is what the game itself finds on that collision layer. The game works the ray out during its next frame, so the answer is a frame old, and no ray is cast while the game is paused (the last answer is kept while the camera still looks the same way).

• Label (the distance and what was hit, under the crosshair), Model box, Collision box and Glow (the model hit drawn with the game's own glow for usable objects) show it in the game. Freeze keeps the answer while the camera moves away.
• Ray layer: the collision layer the ray tests against. The surface-test layer is the default (the one the zone and footstep rays use); the list also offers what AI sight uses, ballistic collision, triggers, sound, door blockers, the player's and the rest. Ray length goes up to 500 m.
• Under the crosshair: where the ray hit, how far away and the surface's normal (Copy puts it all on the clipboard), then everything the level's collision map says about what was hit: its row and flags, the script entity and composite instance it belongs to (with the composite's name and the instance's path from the level's root, as OpenCAGE addresses it), its zone, its render and physical material (the physical one decides footsteps and impacts), the static collision it's stored as, and the model drawn in its place, with its elements, materials, textures and LOD ranges, its environment map, radiosity slice and tint. Something with no row, such as a physics body, shows the body instead.
• Any row of the collision map: look any row up by its number (The one hit fills in the row under the crosshair), and tick Draw it to see where it is.

Other tools use the crosshair too: the Player tab's To the crosshair, Draw the alien to a point, the Navigation tab, and OpenCAGE's Select Entity Under Game Crosshair in the composite display's Script Debugger menu, which selects the entity under the crosshair in OpenCAGE.

Zones

The Zones tab shows the level's zones as the game's zone streaming keeps them:

• The summary: how many zones are loaded, streaming in and wanted, the links between them and how many are open, the zone the camera is in, whether streaming has stopped because it ran short of memory (nothing more loads until zones unload), what is loading or suspending now, and whether a script holds the screen faded out.
• Every zone, with its priority this frame (a zone a view is in gets 100, and its neighbours through open links that less the link's cost; zones at 80 or more are wanted), which views see it, its state (loaded, loading or unloaded, suspended, or asked to load or unload by a script), its links, how many of its entities are still loading, and how many composite instances live in it. Loaded only, Wanted only and a name filter narrow the list.
• Choose a zone for its id, the Zone entity that made it, its links (to which zone, open or closed, locked, their cost and the entity that made each), the zones it's excluded with, and the composites in it. Under the list are every link, and the viewpoints the views registered this frame.

Why each view is in its zone: a view whose camera follows a character (the player's camera) is handed the zone under the player's feet; any other casts a ray 500 m straight down from the camera, and the collision map row it hits gives the zone. The tab names the row each view's ray hit, with its entity, composite instance, layer, flags and zone, and the rows under the player's four foot rays. A wrong zone on a rebuilt collision row, or a piece of collision under the camera that shouldn't be there, shows up here as the reason the zones around the camera never stream in. Draw the zone rays over the game draws them (Every view for all the views, not only the first).

Overlays & Measuring Rings

The Overlays tab draws script entities over the game, each kind with a switch: the player's trigger boxes (PlayerTriggerBox) and use trigger boxes (PlayerUseTriggerBox), doors with the zone link they open, splines with their points and direction, and the interaction points the game keeps for pickups, weapons, ammo, doors, computers and save points, with their quantity.

• Colours: trigger boxes green, use trigger boxes blue, disabled ones grey (Only enabled boxes leaves those out). A box flashes yellow as the player walks in and orange as they walk out. Doors are yellow closed, green open, cyan opening or closing and red locked. Interaction points have a colour per kind.
• Labels give a box's composite, state, collision row and zone, and how long ago the player last walked in and out; a door's state, whether it's locked or scripted, and its zone link with that link's state; an interaction point's name, kind and quantity. Labels are drawn within Labels within (12 m at first), and everything within Distance (25 m), nearest first.
• Found in the level lists what was found, nearest the camera first, one kind at a time. The level's entities are looked through again every few seconds while any of these are on or the tab is open, so something a script has just spawned shows up a moment later; Look again looks at once.

Measuring rings, at the bottom of the tab, draw up to four rings on the ground (2, 5, 10 and 20 m; Default radii puts those back) Around the player, the selected character, the point under the crosshair, or a point you drop with Drop a point here, with the distance along the ground to each character inside: handy for checking the ranges the AI works to.

Navigation

The Navigation tab shows the nav mesh the game loaded for the level's current state, as the game holds it: the quickest way to check what OpenCAGE's nav mesh bake wrote. Its sections fold:

• Nav mesh: whether one is loaded and which state it came from, its polygon, vertex, off-mesh connection and barrier counts, and how often it has changed since (doors). A level whose state's nav mesh file is missing, of the wrong version or won't load runs with no navigation at all, silently: here it says NO NAV MESH LOADED. Tile header and ids has the rest of the header (walkable height, radius and climb, the bounds...).
• Drawing: the polygons near the camera (or Around the player), filled and outlined, coloured by markup (normal, backstage, expensive), the classes of character they let through, height (standing, crouch, deep crouch), enabled, the barrier they belong to, traffic (how long since a character pathed through), or a flood's reach or islands; the barrier polygons; off-mesh connections as arcs coloured by kind, with an arrow on one-way ones; traversals; and polygon numbers. Distance, Height band (to keep other floors out), Most polygons and Fill set how much is drawn and how.
• Polygons under the player, characters and crosshair: the polygon under each, with every flag decoded (enabled, the classes it lets through, its height and markup, the door barrier it belongs to, its links, when it was last pathed through). Show it highlights one, and Flood from it floods from it. Each NPC shows the polygon under its feet beside the one its own movement says it's on.
• Barriers and doors: doors are barriers on the nav mesh. The level's barrier table (each area, what it lets through now, the door, the barrier entity, how many polygons it cuts out, its collision row and zone); a door audit against the sound network, since a door sets its nav barrier and its sound doorway by the same id, so a barrier with no doorway, a doorway no barrier has, or the two disagreeing (open for the AI, shut for hearing) shows up here; and a log of every change a door makes.
• Off-mesh connections and Traversals: those near the camera, nearest first, with their entities (vaults, ladders, vents...), and what the player can climb or vault now.
• Path searches: the AI's path searches as they finish, with who asked (movement, cover, a path length, a route check...), whether they succeeded, failed or only got part of the way, and where they started and ended. The failed and partial ones can be drawn.
• Who can get where: floods the mesh from the player, the crosshair, the camera or the polygon shown, with the game's own rule for what a class of character may cross (with or without the vents and deep crouch), showing what's reached and splitting the mesh into islands, largest first.
• Path tester: runs the game's own path search between two points (the player, the crosshair, the camera or the selected character) for a class of character, and draws the path it finds.

Cover & Jobs

The Cover & Jobs tab shows the level's cover and the AI's jobs as the game holds them, what OpenCAGE's cover bake wrote. Its sections fold:

• Cover: how many segments there are (low, standing, disabled), slots (free, reserved, occupied) and traversals. Segments draws each piece of cover as a wall, standing cover pink and low cover cyan (grey when disabled), with an arrow on the side it's used from; Slots colours its slots green when free, amber when reserved and red when taken; Links draws the links round its corners and in line with it; Labels gives each segment's number, kind and height, and who has each slot. The list holds the segments nearest the camera (up to 200, whatever the draw distance), and clicking one draws it in white and shows its slots and who has them. Under it are the characters the cover system follows: the segment and slot each is in (or not in cover), the slots it has reserved, and its stance and facing.
• Baked job positions: the spotting, crawl-space spotting and assault positions the bake placed. The game only makes jobs from those in cells near the player (unless the level uses them all), so those are drawn brighter, with a ring where a job is made and a line to where the AI stands to look; Active cells only leaves the rest out.
• Jobs and their tasks: every job the AI has, scripted ones too, by type, with each task's state and who is doing or has reserved it. Draw the tasks draws a line from each character to its task. Each NPC's job lists them the other way round.

Physics

The Physics tab shows what the physics engine holds for the level:

• Static collision (the level's COLLISION.HKX and COLLISION.MAP): Count reads every static collision instance and collision map row once, and says how many there are by compound and collision layer, how many are disabled, have collision turned off, or have no row or a row that points elsewhere. Static collision boxes near the camera draws them as boxes, coloured by layer, zone, compound or state (red: collision off, magenta: disabled, yellow: no row). Show the models flagged as collision turns on the game's own switch for drawing collision models in place of the normal ones; the game only reads it as a model is shown, so reload a checkpoint to see it everywhere.
• Bodies: how many bodies are awake, asleep and fixed, and the triggers. Bodies near the camera draws them as boxes with their velocity, with Triggers, Phantoms and Labels. Character capsules draws each character's capsule, the game's upright shape for its kind of capsule, from its feet to its top, and the tab lists each one's state (on the ground, in the air, climbing...), kind and size, and whether it's over a drop. Key on screen, on at first, puts a key to the colours at the right edge of the screen while any of these are drawn.
• Physics systems (the level's PHYSICS.MAP): every dynamic physics system the level made, with its composite, bodies, position, entity and composite instance. Show them draws axes at each one's transform with lines to where its bodies are now, so a twisted transform shows at once.
• Collision layers: which layers collide with which, as a grid of the world's collision filter. Hover over a square for the two layers' names.
• Rays the game casts: with Note them ticked, each frame's rays grouped by what in the game asked for them (AI sight, weapons, pickups, zones, footsteps...), with how many hit something. Draw them draws them, green where clear and red up to where they were blocked, within Drawn within and on one layer or all; Hold this frame keeps one frame's rays.
• Collision turned on and off by script: every collision map row whose collision a door, collision barrier, trigger, model or water entity turned on or off, when, and what kind of entity did it. Show the rows switched in the last 5 seconds draws them.

Names

The World group's switches, values and commands, for Live Link & AI Assistants:

The Scripts group shows what the level's scripts are doing. Its tabs:

• Debugger: where OpenCAGE's script debugger has stopped the scripts, with Continue and Step.
• Errors: the problems the game finds with the level's script entities, which the shipped game never reports, and the calls it drops.
• Triggers: the calls waiting to run, and how often each entity's methods are called.
• Progression: the saved script variables, the player's objectives and the campaign's progress.
• Events: the messages the scripts broadcast, and who listens for them.
• CAGEAnimations: the level's CAGEAnimations, and which are playing.
• Entities: four debug script entities brought back to life.
• Profiler: where the scripts spend the game's time.
• Cameras: the game's cameras, their behaviours and paths.

The shipped game keeps no names for script entities, so every tab shows an entity by its type, its id and the id of the composite instance it's in, with the name of its composite. The ids are the ShortGuids OpenCAGE shows with Show ShortGuids on; hover over an entity for them. Methods are named as OpenCAGE names them where the name is known, and by their id otherwise. Most lists have a filter box and a Copy button, and each has a command that gives it as text (see Names).

Debugger

OpenCAGE's script debugger stops the level's scripts, and the game with them, just before a method is called on an entity you've set a breakpoint on. Breakpoints are set in OpenCAGE: right-click a node in a composite's flowgraph and choose Set Breakpoint, or press F9 over it, with the game started with both Debug Menu and Live Link ticked. The Debugger tab shows the same thing from the game's side:

• Whether the scripts are held: Scripts running, or held at a breakpoint, held after a step, or paused by the debugger. While they're held the game is paused as it is for its pause menu, and a line along the top of the screen says where they're held, so the game doesn't just look frozen.
• Continue lets the scripts go on. Step makes the held call and the rest of the calls due at the same moment (one round), then holds them again. Step frame lets one whole frame of the game run. Pause scripts holds them now, as a breakpoint would.
• The held call: the method, the entity it's called on, the composite and instance it's in and the path of instances to it, when it was due on the scripts' clock, and the calls that led to it, latest first. A call nothing in the scripts made (the game, or a timer, queued it) says so.
• Breakpoints: each one set, with a box to switch it off and on, how many methods it stops on, how many running instances it's in (not in when there are none; hover for why), how often it has been hit, and Remove. Stop at breakpoints unticked keeps them all but lets the scripts run past them, and Remove all takes them away.

OpenCAGE brings the held node to the front of its flowgraph while it's connected, and its Continue and Step (F8 and F10) do the same as the buttons here. While the scripts are held, your edits over Live Link wait until they go on. A level that unloads, or loads again, while the scripts are held lets them go. Where this release of the game doesn't match what the debugger needs, the tab says Script breakpoints are not available on this game release.

The scripts held at a breakpoint set in OpenCAGE, with the line along the top of the screen that says so.

Errors

The game still checks that the level's script entities are set up properly, and words what it finds: a pickup spawner that names no item, a door with no animation, a speech entity with nothing to speak through, an animation set missing the animation asked for, a zone link the wrong way round, a Global Event value out of range, and so on. The game makes those checks but never tells anyone. The Errors tab lists every failed check (Check, in amber) and error (Error, in red), one line per message and entity, with how many times it has happened and how long ago it last did:

• Click a line to see it under Selected: the message, the entity and its ids, how many times and when first and last, with Copy ids and Copy line. By message counts each message across every entity, and Every occurrence lists them one at a time instead.
• Keep script errors (on) notes them; Show new ones on screen (off unless you tick it) puts each new one at the top of the screen for six seconds, whether the window is open or not. Clear forgets them.
• Dropped calls: methods called through links that the game threw away without running, because the entity that started their chain of calls had been shut down (its zone unloaded, or it was deleted) by the time they came due. That's often meant to happen, but a delayed link that never fires shows up here, with the method, the entity it was for, the entity that started it and how long ago.

The grey line at the top says how many of the game's 173 checks and errors are being watched; on a release of the game where some aren't where they should be, it says how many were left alone. Both lists start afresh when another level loads.

Triggers

When an entity fires an output, each method its links call is queued, and runs when it comes due. Waiting calls lists those that haven't run yet, soonest first: how long until each is due, the method, the entity it's called on and the call that queued it, with the start of its chain (hover over the time for the link's delay). A link with a delay waits here; entities that time things themselves, such as delays and timers, don't show. Keep reading (on) reads the queue four times a second, and Read now once.

Trigger counts: tick Count to count every call the scripts run, by method and entity, busiest first, with how many ran in the last second and in all. An entity calling itself in a loop, or a timer firing far more often than you meant, shows at the top.

Progression

What the level's scripts carry beyond the level. Nothing here can be changed; it's read again every second while the tab is open.

• Saved variables: script variables marked persistent. The game keeps their values for the whole game and saves them, so later levels see them. One in the running level shows its type and where it is; one from another level only shows its raw value. Only those in this level hides the rest.
• Objectives: the player's primary objective, with its title and text and whether it's done, the secondary objectives (each with its position, marker and level) and the exit objective. Mark the secondary objectives' positions marks them over the game.
• Campaign progression: the storyline and how complete it is, the mission, how many saves have been made and humans killed, the time spent hunted by the alien, the crafting blueprints unlocked, the downloadable missions' objectives done, and the missions' achievement checks.

Events

Entities that aren't linked can still talk through messages the scripts broadcast: Global Event entities' events and their values, Update Global Position entities' positions, and characters being damaged, killed or stunned. Entities such as Global Event Monitor listen for them. The Events tab shows:

• Sent: each message as it's sent, with the time on the script clock, its kind, its name, its value or position, and for a global event the entity that started the chain that sent it.
• By name: how many of each were sent.
• Listening: every entity listening for a message, and the messages waiting to be handed out.

A message's name shows once an entity that uses that name has run; until then it's shown by its id. Keep messages (on) notes them, and Show character messages unticked hides the damage, kill and stun messages.

CAGEAnimations

The level's CAGEAnimation entities: those playing first, then those started but held, each with its state (marked (cutscene) when it plays a cutscene), its time against its length, its entity and its composite. Show every one (stopped too) lists the rest. It's read four times a second while the tab is open. Nothing is changed from here: Animation Mode in OpenCAGE holds and scrubs a CAGEAnimation in the game.

Debug Entities

The Entities tab brings back four debugging script entities that the shipped game still creates but leaves doing nothing. Each has a switch here, off unless you tick it or set its key in the settings file, so a level that still holds one plays as it shipped:

• DebugGraph: while started, plots the numbers linked to its Inputs (up to eight) in a panel at the right of the screen, following its duration, samples_per_second, scale and auto_scale. The tab lists the graphs running. Key DebugGraph=1.
• DebugMenuToggle: when triggered, sets the Debug Menu switch its debug_variable names (any of the names the Debug Menu gives its switches, such as characters.view_cones) to its value, or flips it when it has none. A name no switch has is noted in Errors. Key DebugMenuToggle=1.
• DebugObjectMarker: shows its marked_name over its marked_object. The tab lists the level's markers. Key DebugObjectMarker=1.
• DebugCaptureScreenShot: when triggered, saves the next frame, without the Debug Menu, as a .bmp named after its capture_filename, in a DebugCaptureScreenShot folder next to AI.exe. Its field of view, clip planes and wait for streaming are ignored. Key DebugCaptureScreenShot=1. It's not available on the GOG release, whose version of the entity differs.

The other debugging entities are elsewhere: DebugText, DebugTextStacking and the two markers are switched on by Launch Game's Debug entities box (see Debug Text & Markers), and the debug checkpoints are in Game > Tools.

Profiler

Tick Profile to time the level's scripts: each entity's own updates (for the entities updated every frame) and the methods run on it, in milliseconds per second of play, busiest first, by Entities, Types or Composites. The table gives the total, the updates and the methods, and how many of each ran a second. Time spent inside a composite instance's update is counted to the entities in it, not to the instance as well.

It costs a little while it's on. The counts start again when you tick it, press Start again, or another level loads.

Cameras

The game's cameras as it keeps them:

• The active camera, the player's, a trigger's and a transition's, and any transition between two cameras in progress, with how far through it is.
• The stack of cameras (the player's, scripted cameras, cutscene cameras...), the last on top, each with its role, field of view, number of behaviours and the script entity that controls it. Click one for where it is, its field of view and clip planes, its flags, what it looks at, the character it's linked to, and its behaviours (shakes, paths, look-ats and the like), each with its priority and how far it has blended in.
• Folded underneath: the behaviours on every camera, the camera paths made, and the depth of field and camera animations loaded.

Draw the cameras over the game and Draw the paths over the game (With labels) show them in the level.

Names

The Scripts group's switches, values and commands, for Live Link & AI Assistants:

The Sound group has one tab, Sound, which shows what the game is playing and why, in sections you can fold:

• Overview: where the listener is (the camera, or the player's head) and the space they're in: its sound network, room type, reverb and ambience, and the blend the game gives it near a doorway. Then the alien's state and how far it is from the player through the network, the threat and stealth levels, and counts of sound objects, sounds playing and speech. Occlusion and Reverb are the game's own debug switches for what blocks sound through closed doorways and for the room reverb.
• Playing now: every sound playing, with what's playing it (a character's sounds, speech or breathing, a script entity, the music, a space's ambience), how many voices, how long it has played and how far away it is, occluded or obstructed. Tick Draw them to label them in the game; click one to draw how far it can be heard and the doorways it reaches the listener through.
• Event log: every sound event played, newest first, with what played it, where, and its arguments (the surface a footstep is on, the alien's voice state...). A script Sound entity is shown by its id. Pause holds the log, and the filter finds events, owners or arguments.
• Speech and dialogue: the lines speaking and waiting, the subtitle on screen with its text and speaker, and the dynamic dialogue the NPCs ask for.
• What the AI hears: every noise the AI can hear (footsteps, gunfire, impacts) with its loudness and who made it, and for each character that checked it, how loudly it heard it. The Debug Menu works out the same route through the sound network as the game, and says if its answer ever differs. Test route shows how well the selected character would hear the player at a chosen loudness, and why: the route's length, the doorways on it, and whether one is closed.
• Sound network: the level's networks, nodes and doorways, by name, with each doorway's state, and a log of every doorway a door or Sound Barrier entity sets (a door moving sets its doorway every frame; those sets are one entry). A doorway id that no doorway has, or a doorway no door ever sets, shows that the level's sound network and its doors don't match.
• States and music: the sound states the game set, by name, and the music: what's playing, what drives it (the threat level, stealth or the alien's distance) and the last music request. Sound banks lists the banks loaded.

Below them come the Sound Tools.

Drawing Over the Game

• The sound network near the camera: its nodes coloured by network (the listener's two nearest circled), each node's three shortest links, fading with obstruction and distance, and its doorways as squares, green open, amber partly open and red closed. Doorways within 20 m are labelled with their number and state, and (never set) when nothing has set them since the level loaded. Tick Every link to draw all of the links, which in most rooms is a dense web.
• Playing sounds, labelled with their event, at where they play.
• The stimuli and who heard them: rings that fade where each noise was made, sized by its loudness, with lines to the characters that heard it.
• The selected route: the doorways a sound or the test route passes through.
• Speech: the line and subtitle over each character speaking.

Sound Tools

Under Tools, after the views:

• Listener: the game hears from the camera, so flying a free camera takes the hearing with it. Freeze where it is keeps the listener where it was when you ticked it, facing the same way, wherever the camera goes; At the player puts it at the player's head, facing the way they face. Either way it's drawn over the game. Occlusion is still heard from the player's head, as the game always does.
• Make a noise for the AI: Gunfire at the player, or at the crosshair (the point under World > Inspect's crosshair), at the Loudness chosen, from 0 to 1: a character hears it at (1 − distance / its hearing distance) − (1 − loudness), so at 1 everyone in hearing range hears it, and at 0.5 only those within half their range. The game's own weapons use 0.6 and 1. It's made by the player, as the AI only listens to noises characters make, so even at the crosshair it's routed through the sound network from where the player is; the AI goes to the point. What the AI hears then shows who heard it.
• Play a sound event: any of the running level's sound events, found by name, played at the camera, the player or the crosshair point, and Stop it. It shows in the Event log, and only plays if its sound bank is loaded. The list is the level's own and is read again when another level loads; an event is played by its id, so a name works on any level whose banks hold it.
• Squad dialogue: whether the level lets NPCs talk, and how near; each squad's aggression, its dialogue state (idle, searching, escalating or in combat, and the state within it), its call and response (hover), its last line and its members.

After the tools, AI hearing:

• AI hears in straight lines (leave out the sound network): every character works out how loudly it heard a sound from the straight-line distance to it, instead of the shortest way through the sound network's open doorways, as if every doorway were open and every room linked. It's a one-click check of a level's sound network, for after a rebake: if an NPC hears the player with it on but not with it off, the network is the cause, such as a doorway stuck closed or a missing link. Make a noise (Make a noise for the AI, above) or walk near the NPC, once with it on and once with it off.
• While it's on, each sound is worked out both ways, and the section counts the sounds heard only in a straight line (the network would have kept them from the character altogether) and those heard louder, and lists the last eight: who heard whose sound, how loudly and how far away. The counts start again each time you tick it. What the AI hears, above, still works each sound out through the network, so it says differs for these.
• It changes nothing in the level, and turns itself off when another level is loaded. Restarting the same level, or loading a checkpoint, leaves it on.

Names

The Sound group's switches, values and commands, for Live Link & AI Assistants:

sound.make_noise takes where: player (the default), pick (the crosshair point), camera or x,y,z, and optionally ; and a loudness from 0 to 1. sound.play_event takes an event's name, and optionally ; and where to play it: camera (the default), player, pick or x,y,z.

The Rendering group has the game's own rendering switches and debug views, and shows what the renderer is doing. Its tabs:

• Rendering: the game's own rendering switches.
• Debug Views: the game's own views of the bounce light and the surfaces, drawn over the whole screen.
• Lights: the real-time lights, their shadows, and muting or soloing them.
• Radiosity: what the bounce light has loaded and is streaming.
• Post: the post-processing and fog, with the engine's switches for them.
• Targets: the renderer's own targets and textures as pictures.
• Visibility: why something is or isn't drawn.
• Developer: the Direct3D debug layer and shader hot reload.

While the Debug Menu is changing how the game draws (a rendering switch, a debug view, a muted light, a Cinematic look setting...), OpenCAGE won't capture environment maps: it names what to turn off first, so none of it gets baked into the level. Switches that don't change the picture a capture takes, such as No HUD and the anti-aliasing ones, don't count.

Rendering Switches

The game has rendering switches of its own, and the Rendering tab lets you flick 69 of them while the game runs, in groups you can fold:

• Passes: leave a part of the frame out: the solid geometry, decals, the real-time lights, light decals, the bounce light (radiosity), transparent geometry, lens flares, the atmosphere, distortion, hair softening, skin scattering, character morphs, face wrinkles, the HUD, and the glow round usable objects.
• Anti-aliasing: skip FXAA, SMAA or the temporal part of SMAA T2x (each only changes anything while the game's own anti-aliasing setting is the one it names).
• Radiosity: leave the level's static, dynamic or surface lights out of the bounce light, stop it passing through doors, or stop it using its cube maps.
• Radiosity debug, Shadows, Level of detail and Alpha and post-processing: debug switches, such as Constant ambient, No shadow maps, Disable LODs, where transparent geometry is drawn and how it's lit, the exposure scaling and light shafts.
• Culling and sorting: No occlusion culling (the quick test for an object that pops in or vanishes), No occluder drawing, Update particles out of view and Sort by depth only.
• Debug drawing: lens flares drawn as plain quads, and the game's surface effect overlay (only where the level has its material).
• Output: the lit scene straight to the screen, without the tone mapping and grading: linear, sRGB, gamma 2.0 or gamma 2.2. The first one ticked wins, and each only turns on while the shader it uses is loaded.
• Developer (experimental): shader hot reload.

Hover over a switch to see what it does: some do only part of what their name suggests, and a few only show in certain places or with certain settings. A switch that doesn't match this release of the game is greyed out; Update particles out of view isn't available on the Epic Games Store release. Reset all puts every switch back to how the game has it.

A corridor before and with No solid geometry ticked.

Debug Views

The game still has the shader for its own debug views of the bounce light (radiosity) and the surfaces. Pick one from Debug view, or press its button, and it's drawn over the whole screen in place of the lit scene:

• Irradiance: the bounce light reaching each surface, without the surfaces' own colours or glow. Irradiance map and Direction map: the same, and the direction it comes from, as stored in the level's lightmaps. Direction: the main direction the bounce light comes from.
• Radiosity texture coordinates: where each surface reads its bounce light from, so surfaces with none, or badly laid-out ones, stand out. Blocked probes: the probes stuck inside geometry, which make dark blotches. Slices: which part of the level's bounce-light data each surface is in, each its own colour.
• Albedo, Normal, Specular normal, Shininess, Shininess scale, Specular levels, Emissive and Ambient occlusion: what the surfaces are made of, as the game's G-buffer holds it.

Transparency and post-processing still draw over the view. With Show the view alone ticked (as it is to start with), the real-time lights and decals are left out too, by ticking the Rendering tab's No deferred lighting and No decals while the view shows; otherwise a view of the lighting looks much like the normal frame wherever lamps light the room. Leaving the real-time lights out also makes the player read as darker to the AI. Back to the game's picture turns the view off, and a switch you had ticked yourself stays ticked.

A room as the game draws it, and with the Irradiance debug view showing alone.

Lights

The real-time lights, to see what each does to a scene:

• The lights drawn this frame, nearest first (or with Every light of the level, all of them): each one's type, mover index, colour, reach, features (shadow, gobo, specular, volume...; hover for them in words), state (drawn, with a shadow map, wanting a shadow map but over the budget, feeding the bounce light) and distance. Click one for its details: where it is, its colour, the distances its light starts and ends at, its cone, its shadow and bounce-light settings and its material's textures.
• The shadow budget: how many lights this frame may cast shadows (4, or 16 with ExtraShadowLights=1), how many did, and how many wanted to but missed out; and the shadow maps' resolution and filtering.
• Mute a light, or Solo one to leave out every other. A muted light isn't drawn, casts no shadow, has no lens flare and no longer feeds the bounce light. Leave out does the same for whole kinds: spotlights, point lights or strip lights, every light without a shadow, or every light without a gobo. Unmute all brings them all back.
• Overlay draws each light over the game, within the distance set: a cross where it is, its reach as a sphere or a spotlight's cone in its colour, thicker with a shadow map and grey when muted. Labels adds each light's number, type, mover index and state.

ExtraShadowLights=1 in the settings file starts the game with the capture mode's budget of 16 shadow-casting lights a frame, for up to four times the shadow work.

Radiosity

What the bounce light (radiosity) has loaded and is streaming. A level whose radiosity data didn't load is lit only by its real-time lights and looks flat; the tab says whether it loaded, and from which file. Then:

• How many slices (the parts the level's bounce-light data is split into) the level has, whether the bounce light is applied to the frame, and what is streaming.
• The four slots the game keeps slices in: the slice each holds, its state, how many frames it took to load, and its size: scatter points, surface lights, probe tree nodes, doors and the volume grid.
• Streaming ranking: each slice's score, by which the game picks what to stream next. Cube map users: the objects lit from the bounce light's cube maps.

Overlay draws each loaded slice's volume of probes in its slot's colour, its probe trees faintly, and the cube map users as yellow crosses. Warn when a level has no radiosity data shows a warning over the game while one runs without it; RadiosityWarning=1 in the settings file has it on from the start.

Post

The post-processing as the game has it this frame, with the engine's own switches for it. Each switch holds the game's own flag or value, and the game's comes back when you let go; Reset all lets go of them all.

• Exposure and tone mapping: how the picture is adapting to the scene's brightness, with its histogram. Hold the exposure stops it adapting; Exposure scale sets the scale instead (Now holds the scale it has now). Tone mapping picks the operator: Exponential, Linear, Irawan, Hable, Hejl-Burgess-Dawson, Haarm-Peter Duiker or the game's default, Day.
• Effects: tick one to leave it out, with the game's own state in brackets: film grain, motion blur, full-screen blur, vignette, bloom, the distortion overlay, fisheye, the full-screen overlay, the colour grading, depth of field, chromatic aberration, the screen fade, the low-resolution frame blend, and ambient occlusion and its blur.
• Colour grading (LUTs): the grading in use and the one it's blending to. Settings and stacks: each effect's settings this frame, and the stack the level's scripts push them in, the top one winning.
• Fog: whether it's on, No fog, and the fog settings the level has stacked.

These are the engine's switches, for finding out what the post-processing is doing. To set the look of a shot, use the Cinematic group's Visuals.

Targets

The renderer's own targets and textures as this frame left them, as thumbnails; click one to see it large (Size scales it, and Large view in its own window moves it into a window of its own). They're grouped:

• G-buffer: its five targets, which hold each surface's glow (emissive), normals, colour (albedo), shine (specular) and specular normals, and its depth, normal copies and velocity.
• Lighting: ambient occlusion, the secondary (bounce) light, and the lit scene with its early transparency.
• Frame: the frame being drawn, distortion, the low-resolution particles and depth, the quarter-size copies, motion blur and the colour grading's current and target LUTs.
• Shadows: the shadow maps of this frame's shadow-casting lights, filtered and cached, and the gobos.
• Radiosity: the bounce light's lightmaps and the objects' probe textures.

The pictures show the raw values, without their alpha: floating-point targets are clamped to 0 to 1, single-channel ones (depth, ambient occlusion) show in red only, and depth crowds so close to 1 that it shows as almost solid red. A black picture is a target with nothing in it this frame (velocity while nothing moves, for one), and an empty tile says why it has nothing to draw; cube maps, volume textures and multisampled targets are listed but not drawn.

Visibility

Why something is or isn't drawn:

• Why isn't this drawn? Give an object's mover index (World > Inspect shows it for the model under the crosshair) and press Check: it's taken through each step before the renderer draws it, whether it's loaded and active, whether its zones are visible, its visibility state, whether it's in this frame's list of things to draw (with its models) and how far away it is, and the first step it fails is why it isn't drawn. No occlusion culling and Disable LODs, the Rendering tab's switches, are here too: if an object appears with occlusion culling off, that was why it was missing.
• Level of detail: the distance factor for switching models to their less detailed versions, as the game works it out, with an override: below 1 they switch nearer, above 1 further away. Reset gives the game's back.
• Visible zones: the level's zones, and which the renderer treats as visible from the main view, with whether each is loaded and its priority.
• Reflection maps: the level's reflection maps, with how many objects use each, its priority, colour and texture, and whether it still needs baking. Overlay the selected map's objects marks them in the game.

Developer

• Direct3D debug layer: with D3DDebugLayer=1 in the settings file, the game's graphics are checked for errors as it runs, and its errors and warnings are listed here: the messages that broken imported models and shaders cause. It needs Windows' optional Graphics Tools feature installed, and the tab says when it isn't. It makes the game much slower. Warnings too, a filter, Clear and Copy.
• Shader hot reload (experimental): every 120 frames the game checks whether a shader pack it loaded has changed on disk and, if one has, reloads every shader. The game never turns it on: a reload can stall or crash it, so pause and save first, and new materials or permutations that aren't in the loaded tables won't appear. It's the same switch as the Rendering tab's.
• Shadow budget: how many lights a frame may cast shadows, raised to 16 by ExtraShadowLights=1.

Names

The Rendering group's switches, values and commands, for Live Link & AI Assistants:

The light commands take a light by the id light.list gives it, or as mover: and its mover index.

The Performance group shows how hard the game is working and how close it is to its fixed limits: when a limit is full, the game quietly leaves out what comes next, which explains lights, shadows, effects and models that go missing in a busy custom level. Its tabs are Frame, Timing, Memory and Streaming. Nothing is measured until one of them is shown, or one of their switches, Info lines or commands is used. The Info tab has three lines from them: draw calls and primitives, the GPU frame time, and memory and address space.

Frame

• Frame time: the frame rate and frame time over the last second, the fastest, slowest and 1% slowest of the frames kept, and a graph of them. Graph over the game draws the graph over the game, under the Info lines in the top-left corner (or beside the window while it covers that corner), with lines marking 60 and 30 fps.
• Renderer counts: the draw calls, primitives, buffer writes and bytes written for the last frame, their average over the last second and the highest over the last 600 frames, and how many textures, render targets and depth buffers the renderer holds.
• Limits: how much of each fixed limit is in use: the lights a view can draw (64 with shadows, 2,048 without), the lights chosen to cast shadows against the budget and those left without, the particle systems (200) and ribbons (40), the effects' shared buffers, the views the renderer keeps (32), and each of its pools of GPU resources.
• Main view by material priority: what the main view draws, by kind (solid, skin, hair, decals, lights, transparent effects...). Views: every view the renderer keeps, with its size and how much it draws.

The renderer's counts aren't kept exactly in step with its other threads, so they can be a few short.

Timing

Both parts are off until ticked:

• Time each render stage on the GPU: how long the graphics card takes over each stage of the frame (setting up the scene, the views before the main one, solid geometry, lighting, transparency, post-processing...) in milliseconds, with each stage's share of the frame, and the whole frame's GPU time, averaged over the last 60 frames measured while a level runs. The GPU frame time also shows on the Frame tab, the graph over the game and the Info lines. It costs about 30 timestamps a frame, and includes the Debug Menu's own drawing.
• Time each task on the CPU: every task of the game's frame (the scripts, the AI, physics, building and sorting what to draw, the render stages...), slowest first, with its average and last time, how many times it ran in the frame and which thread ran it, and the main and worker threads' totals. A task's time includes any task it ran while it waited for another.

Memory

At the top of the tab, The game's UI memory overlay turns on the game's own overlay of the memory its UI (the menus and the HUD) takes: the game writes it in MB on the right of the screen, white while it's within budget, yellow from 29.5 MB, and red from 30.5 MB with a line under it saying the UI is out of its memory budget. It takes effect straight away, and can be switched from outside the game as perf.ui_memory_overlay; UiMemoryOverlay=1 in the settings file has it on from the start. It takes the place of Launch Game's old Enable UI Memory Overlay option. On a release of the game where it can't be found, the box is greyed out and says so.

Below it:

• The process: the memory the game has committed and how much of it is in physical memory; how much of its 32-bit address space is used, and its largest free piece, which is what a big allocation needs (when it gets small, loading more can fail even with memory free overall); and the graphics card's memory against the budget Windows gives the game.
• Heaps: each of the game's memory heaps, fullest first, with how much is used, its size and the most it has held. A full heap fails the next allocation from it, even with memory to spare elsewhere. Measure fragmentation adds each heap's largest free block and how fragmented it is.
• Script entities' memory: each kind of script entity, with how many there are, the size of one, and the memory they use and have allocated.

It's read at most once a second while the tab is shown.

Streaming

Textures and models are streamed: a low-resolution copy of a texture is always in memory, and the full one streams in when a zone that uses it becomes active. The tab shows:

• The texture and model streaming heaps: how much is used of their size and the most they've held, what's waiting to stream in or be let go, and whether streaming is busy.
• The level's textures: how many stream, and how many of those are in at full resolution.
• Drawn now: the textures the main view draws right now that are still at low resolution, largest first, with their full and current sizes: the blurry surfaces.

It's read at most once a second while the tab is shown.

Names

The Performance group's switches and commands, for Live Link & AI Assistants:

The Game group acts on the game itself:

• Game flow: what the game is doing, its checkpoint and spawn point, the difficulty, and every level with a button to load it.
• Saves: Don't write saves, what the game's saving is doing, and its achievements.
• Tools: debug and level checkpoints and snapshot slots, pausing, stepping, the game's speed and a fixed time step, and actions on the AI.

Game Flow

• Game flow: the game's state (in a menu, starting gameplay, playing, game over, restarting...), the level and the level asked for next, whether the level's scripts are running, paused, at the pause menu, stopped at a breakpoint or stepping, and what has paused the game.
• Checkpoint and respawn: the checkpoint the level is at; the checkpoint in memory that a death, or Reload last checkpoint, goes back to, with its mission and how long ago it was reached; a checkpoint save waiting for the player to be able to save; and where the player spawns.
• Difficulty: the difficulty, with buttons to change it on the spot as the pause menu does (every character takes up the new settings), and the lowest the campaign was played at, which decides its difficulty achievements. Keep the campaign's lowest difficulty (on) puts the lowest back after a change, so trying an easier difficulty doesn't cost the campaign them. While the game is paused, a change waits for it to run.
• Levels: every level the game knows, with a filter and a Load button each, as OpenCAGE's load level. A campaign level saves as it loads, as it does in play, unless Don't write saves is on; the list says so when it's off. It takes the place of Launch Game's old Enable Level Selection, which added a list of levels to the main menu.

Saves

Tick Don't write saves and nothing the game saves reaches your saved games or the Steam Cloud: checkpoint and mission saves (save stations included), the progression (which also holds the game's settings), and the input and graphics settings. The game carries on as if each save had worked (a checkpoint still fires its outputs for a finished save), and loading still works, from what was saved before. Jumping to a checkpoint or loading a campaign level from the Debug Menu can save the game, as reaching it in play would; with this on, those saves are kept back too.

• On from the start. Tick Don't Write Saves in Launch Game (beneath the Debug Menu box) to have it on before the game first saves. Ticked here, it only holds from then on.
• What was kept back. The tab counts each save kept back and names the last one (Everything kept back lists them all), and with Notice on screen (on) a line at the top of the screen says so for a few seconds each time.
• Saving: what the game's saving is doing, saves waiting, the last save this run (and whether it was kept back), the level the campaign last saved, the deaths, and the campaign's progress.

It doesn't stop achievements: see Achievements for that.

Achievements

Under Achievements, in the same tab, the game's achievements as it holds them, unlocked or not. Don't write saves doesn't stop the game awarding achievements on your Steam, GOG or Epic Games Store profile, so a debug checkpoint, a cheat or a modded level could unlock one: tick Block awards and stat writes and the game awards none, and changes none of their progress, until you untick it. BlockAchievements=1 in the settings file has it on from the start. The tab counts what was blocked and names the last one. The game may still note an achievement as won in memory, which goes into its next save, so keep Don't write saves on as well.

Tools

The Tools tab gathers the tools that act on the game rather than show it: the checkpoints and snapshot slots, pause and game speed, a Free camera box that turns on the Cinematic group's free camera (with a button that opens its tab), the AI actions, the Havok Visual Debugger, and at the bottom the fixed time step. The player cheats that were here, Invisible to the AI and Infinite ammo, are now with the others in Characters > Player.

Checkpoints

Debug checkpoints: DebugCheckpoint entities in the level scripts that start a level part-way through. Each adds itself to the list when its part of the level activates it; levels with some include SCI_ANDROIDLAB, TECH_COMMS, HAB_AIRPORT, SCI_HUB, TECH_HUB, ENG_TOWPLATFORM and TECH_RND_HZDLAB. Press Jump beside one to jump to it. It takes the place of Launch Game's old Enable Debug Checkpoints, which added the same list to the pause menu.

Level checkpoints: below them, every Checkpoint entity the level has activated, in the order its scripts activated them, numbered, with the one the level is at marked (current). Jump goes to a checkpoint by its place in the list, so one with no name, or one sharing a name with another (there are several Save_stations), can be jumped to. Reload last checkpoint restarts from the checkpoint in memory as a death does: the level goes back to how it was when that checkpoint was reached, the player, the AI and the scripts. Nothing is read from or written to the saves for it.

Most checkpoints start a mission part: the player is spawned at the part's spawn point, and the screen fades back in once the part has loaded. A part loads only once each time the level loads, and the level's own start runs one too (with no progress saved, its ambient part), so jumping to a part that has already run leaves the screen black. Load the level again to jump to it. Jumping to a checkpoint can save the game, as reaching it in play would, unless Don't write saves is on.

Snapshot Slots

Under the level checkpoints, Snapshot slots (experimental) keep copies of the checkpoint in memory, the state a death or Reload last checkpoint goes back to, so you can try a scripted sequence again and again from an earlier checkpoint without real saves. Nothing is read from or written to your saved games.

• Save copies the checkpoint in memory, the last checkpoint the level reached, into one of four slots. Each slot shows its mission, the checkpoint the level was at, the game time it was captured at and the deaths so far.
• Restore puts a slot back as the checkpoint in memory and restarts the level from it, as after a death: the player, the AI, the scripts, the inventory and the rest go back to how they were at that checkpoint. The checkpoint it replaces is kept as Before the last restore, so you can go forward again the same way.
• Clear empties a slot. The slots are emptied when the level unloads or another level loads: a slot only goes back into the level, and the load of it, that it was saved in.

Restore needs Don't write saves on, because the game writes the checkpoint in memory over your checkpoint save when the player dies, and the next checkpoint saves as usual. It waits while the game is saving or loading, while a checkpoint save is waiting for the player to be able to save, and while the pause menu is open; the Debug Menu's own pause is let go, as Reload last checkpoint does. What the game keeps on your profile, such as missions reached, statistics and achievements, isn't put back, and Game flow may still name the later checkpoint as the one the level is at.

Pause & Game Speed

Pause holds the whole game, its clock, the AI, physics, animation, zone streaming and the level's scripts, without the pause menu; Resume lets it go. While it's paused, Step lets exactly one frame through and Step 10 ten, one a frame. The Debug Menu keeps working meanwhile, and OpenCAGE's edits over Live Link, the difficulty and the AI actions wait until the game runs again. Pause while this window is open holds the game whenever the Debug Menu is open.

The speed slider slows the game down or speeds it up, from 0.05 to 4 times its normal speed: everything the game times runs at that rate. Reset puts it back to 1. The game's own slow-motion moments use the same scale, so they're overridden while it isn't 1, and Cap FPS still paces the frames in real time. The free camera's Time section is the same pause, step and speed.

Fixed Time Step

At the bottom of the Tools tab, Fixed time step makes every frame move the game on by exactly the same amount of game time, however long the frame takes to draw: pick 24, 30 or 60 steps a second, or type another rate (from 4 to 1000, so 23.976, 29.97 or 59.94 work too) and press Use; Off goes back to real time. It's for smooth captures recorded slower than real time, such as the Cinematic group's image sequences, where each frame of the video is one step of the game, and for repeatable tests, where the AI, physics and the level's scripts see the same steps every run.

• Faster or slower than real time. The game moves on one step per frame drawn, so it keeps to real time only when frames are drawn at the step's rate: set Cap FPS or V-Sync to the same rate for that. Drawing faster runs the game faster; a capture that draws slower runs it slower, which is what keeps its frames smooth. The section shows how fast the game runs against real time.
• With the game speed. The speed slider (and the game's own slow-motion moments) still apply: at 0.5x with 30 steps a second, each frame moves the game on by a sixtieth of a second, physics included.
• With pause. Pause holds the game as before, and Step lets exactly one step through, the same game time every time.
• Sound runs in real time, so it drifts against the picture while this is on.
• Camera tracks still play in real time.

It goes off when the level unloads or another level loads. When it goes off, the game picks up real time again from where it has got to, as it does after a long frame.

AI

Pick a character from the dropdown, then:

• Alert the alien to the player: every alien hears the player moving, forced past its threshold, and comes to where the player is.
• Withdraw and Cancel withdrawal: the alien forgets what it sensed and withdraws into the vents until you cancel, as the level scripts' withdraw entity has it.
• Menace aggressive and Menace passive: force the alien's menace into its aggressive phase (it hunts the player more closely) or its passive one (it backs off).
• Reset: resets the selected character as the level scripts' reset entity did: its senses and memory, logic flags and timers (an alien's menace too). Reset senses and memory only makes it forget what it has sensed.
• Logic flags: the selected character's logic flags, as the level scripts set them: Prevent all attacks, Prevent grapples, Block ambushes and kill traps, Never aggressive, Totally blind in the dark, Lock backstage stalk, Should break out, Should attack, Should hit and run, Should ambush, Ignore the player in vents, Always knows when in a vent and Mute dynamic dialogue. Hover over one for what it does.

Havok Visual Debugger

The game still serves Havok's Visual Debugger on port 25001 of your own PC while a level runs, so a Havok 2012.2 Visual Debugger client connected to it shows the physics world, its collision and rigid bodies, live. The tab just tells you so: OpenCAGE doesn't include a client.

Names

The Game group's switches, values and commands, for Live Link & AI Assistants:

game.difficulty takes novice, easy, medium, hard or nightmare, or nothing to give the difficulty. game.load_level takes a level by its name as listed (Production\DLC\ChallengeMap1), without Production\, or by its last part alone (BSP_TORRENS), in any case. game.jump_checkpoint takes a number from the list, or a name for the first checkpoint with that name. game.step takes a number of frames, up to 600. game.snapshot_save takes a slot from 1 to 4; game.snapshot_restore takes one, or before for the checkpoint the last restore replaced; game.snapshot_clear takes one, before or all. game.time_step gives the fixed time step's state.

The Cinematic group is a free camera for shots and video, with what HattiWatti's Cinematic Tools offered around it, and it takes their place: Launch Game no longer has Enable Cinematic Tools (see Coming from Cinematic Tools). Its camera and camera tracks are ported from Cinematic Tools, and fly the way they did. Its tabs:

• Free Camera: turn the camera on, its lens, speeds and lock to a character, the game's pause and speed, and profiles of its settings.
• Tracks: camera paths through nodes you place, played back smoothly.
• Visuals: the depth of field, colour, bloom, effects and tone mapping, set in place of the level's.
• HUD: hide the HUD, or any layer of the game's interface.
• Cast: hold the other characters still, make the player invisible to the AI, and put the camera behind a character.
• Screenshots: the frame as the game drew it, without the Debug Menu, saved to a file, and the game's own capture of stills and image sequences.

Free Camera

Press F8, with the Debug Menu open or closed, or tick Cinematic camera on the Free Camera tab, to fly a free camera from where the game's camera is, looking the same way with the same field of view. Close the window to fly it (see Keys & Gamepad); while the window is open it has the keys and mouse, and the camera holds still, unless Fly with this window open is ticked. Press F8 again, or Back to the game camera, to go back to the player. The line beside the box says what the camera is doing, or why it can't turn on.

While it's on, the player is frozen and the game's keyboard, mouse and gamepad are kept from it (bar Escape, for the pause menu), and the zones around the camera stream in as they would around the player. Untick Keep the game's input to play on while the camera holds where it is, follows its track or follows its character. While the pause menu or the game over screen is up, the game has its input back and the camera holds still. A level change turns it off.

• Move the player here moves the player to the camera, and Go to the selected character puts the camera behind the character selected (in the Characters group, the Cast tab or the picker on this tab), looking at it.
• Lens: the field of view and roll (Level straightens it).
• Lock to a character: pick a character and tick Lock to the selected character, and the camera moves with it, kept where it is relative to the character's position and facing; flying then moves it relative to the character. Playing a track unlocks it.
• Flying: the move, turn, roll and field of view speeds and the mouse sensitivity; Smooth mouse (on); Start from the game camera (off, it goes back to where it was left in the same level); Keep the game's input, and its gamepad and Freeze the player (all on); Fly with this window open (off), with which the keys keep flying the camera while the Debug Menu is open (not while you type in one of its boxes), the mouse turns it while you hold the right button away from the window, and the wheel zooms while the mouse is away from the window; and which Gamepad flies it (the first connected, or pad 0 to 3).
• Time: Freeze time (pause the game), Step one frame and Time scale are the game's own pause, step and speed, the same as Game > Tools. Nothing streams in while the game is paused, so fly to your shot before pausing. Tracks play in real time whatever the time scale.
• Profiles: save the speeds, mouse sensitivity, field of view and depth of field by name, and load or delete them. They're kept in OpenCAGE.CinematicProfiles.ini, next to the settings file in the game folder.

The free camera takes the game's camera from OpenCAGE's Viewport while Live Link's camera sync has it, and gives it back when you turn the camera off; the Viewport following the game's camera follows the free camera. As with camera sync, anything in the game that checks what the camera sees reacts to the free camera, not the player's. An environment map capture takes the camera while it runs. It won't turn on while Possess Characters has a character, and turns off when one is taken. With Unlock mouse on, the mouse moves the cursor until Unlock mouse's key (F4 by default) gives it to the game; the camera then turns with it, and the keys and a gamepad fly it meanwhile. The Free camera box on Game > Tools is the same camera.

Keys & Gamepad

With the camera on and the Debug Menu closed:

On a gamepad: the left stick flies, the triggers go up and down, the right stick turns, LB and RB roll, clicking the sticks changes the field of view, the d-pad's up and down change how fast it turns, and B and Y how fast it moves.

Only the on and off key (CinematicCameraKey, F8) and the screenshot key (CinematicScreenshotKey, F9) can be changed, in the settings file; the rest are fixed. If you give one of the camera's keys to another option in Launch Game, such as the hot reload key, the camera does without it (see Keys). The tab's Keys section lists them as they are.

Tracks

A track is a list of nodes, each a pose of the camera at a time along the track. Played, the camera moves through them on a smooth path, easing its pace so it keeps to the nodes' times, as Cinematic Tools' tracks did.

• Tracks: pick a track, make a New one (with a name if you like), or Delete track. You can keep several; each notes the level it was made in, but isn't tied to it.
• Nodes: Add node where the camera is (F1 while flying), Update node to move the chosen one to where the camera is now, Delete node, Go to node, and change a node's time. A new node comes the chosen gap after the one before.
• Playback: Play and Stop (F3), To start, the playback Speed, and a timeline that moves the camera along the track as you drag it. Loop plays it round and round. Play manually moves along the track with up and down (Space and Ctrl, or the triggers) instead of in time. Lock rotation (on) turns the camera as the nodes do; off, it only moves along the path and you turn it yourself. Lock field of view and Lock depth of field follow the nodes' too. Playing a track, or going to a node, turns the camera on.
• Show the track draws the path and its nodes over the game while it isn't playing.
• File: Save and Load every track, in OpenCAGE.CinematicTracks.txt in the game folder, or another name you give there. Loading replaces the tracks you have.

Visuals

The look of the shot, each setting set in place of the level's by ticking the box beside it. The level's own value is shown beside each, and while a box is unticked the setting follows the level's, so ticking it starts from there. Back to the level's values unticks them all.

• Depth of field: tick Override the level's focus to set the Focal length (the longer, the stronger the blur; Cinematic Tools' DoF strength), Focus distance and F-number (the lower, the shallower the sharp part; Cinematic Tools' focus scale). The numeric pad keys change them while flying, and a track can carry them. With the game's own depth of field turned off in its graphics settings, it shows nothing, and the tab says so.
• Colour: brightness, contrast, saturation and a red, green and blue tint.
• Exposure and bloom: Frame scale and Frame offset (Cinematic Tools' brightness and gamma), how much bloom, and how it gathers. The game's fades to and from black go through the frame scale and offset, so no fade shows while either is set here.
• Effects: motion blur, film grain, vignette and its colour fringe, lens distortion, sharpness, full-screen blur and chromatic aberration.
• Tone mapping: the black, cross-over and white points, the shoulder and toe strength and the luminance scale, as in Cinematic Tools.

A value set while its box is unticked (by a command, a track or a profile) is kept for when you tick it. The Rendering group's Post tab has the engine's own switches for the post-processing.

HUD

Hide the HUD (Home while flying) hides the in-game HUD and the weapon HUD. In a challenge map it also hides the objectives, score and timer, which are a layer of their own, unless you untick Also hide the challenge mode's objectives when the HUD is hidden; hidden, they don't update, and catch up when shown again. Below, every layer of the game's interface (the motion tracker, subtitles, prompts...) can be hidden by itself. A menu hidden here stays hidden when it opens, so leave the pause menu's layer alone.

Cast

Freeze NPCs holds every character but the player idle where it stands, newly spawned ones too, until you untick it. People are held with the force idle motivation, which runs their behaviour trees' idle branch ahead of everything else, scripted orders included; the alien and the androids through their trees' debug switches, Disable All Aliens and Force Android Idle (see Tree Switches). The tab says how many are held. What it doesn't do:

• Their senses keep running, and they still react to being hurt. An android following a script's orders carries on with them, and facehuggers can't be held.
• Left on, it holds the next level's characters too.
• With Tree Switches set to the selected character only, the alien and androids are only held while selected; the tab warns when it is.
• The game keeps force idle in its saves, so a checkpoint saved while people are held brings them back idle. With Freeze NPCs still on they're let go with the rest when you untick it; otherwise, untick force idle for them in Characters > Control.

Unticked, it only undoes what it did: a character you'd set to force idle yourself, or a tree switch you'd ticked, stays as it was. For a world that stops altogether, freeze time on the Free Camera tab instead.

The tab also has Player invisible to the AI (the switch in Characters > Player), and for the character selected Camera behind it (the free camera on, 3 m behind it, looking at it), Lock the camera to it and Unlock, and Move the player to the camera.

Screenshots

Take a screenshot, or press F9 with the window open or closed, to save the frame as the game drew it, without the Debug Menu or anything else it draws over the game, as a .bmp named after the level and the time in a Screenshots folder in the game folder. Hide the HUD for the shot (on) hides what Hide the HUD hides for the few frames a shot takes, then shows it again. The tab names the last file saved.

Below, The game's own capture asks the game's own screen capture, which it keeps but offers nowhere, for the next frame it draws: press Capture still. The game saves it itself, as a 32-bit .tga, a Radiance .hdr, or both, in the same Screenshots folder, named after the level and the time with the game's own count on the end. It has the game's HUD unless Hide the HUD for the shot is on (the HUD stays hidden until the capture is finished), and never the Debug Menu.

• Quality: Low is one frame, as drawn. Medium, High and Ultra save 4, 16 or 64 frames, named _tile_x_y, with the film grain, motion blur, bloom, depth of field, anti-aliasing and the ambient occlusion's blur turned off and the ambient occlusion drawn at full resolution: a clean picture. The game works out a slight offset for each of those frames, meant for a sharper picture put together from them, but never applies it, so they come out alike: Medium is all you need. While a still is taken the game holds the AI, the characters and the physics. When it's done the game turns those effects back on, whatever your graphics settings said, so the Debug Menu puts them back as they were.
• Kind: Standard is a .tga, HDR a .hdr, Both one of each, a frame apart. HDR is expected to come out black on PC: the game copies the finished picture into its HDR image in a way Direct3D 11 doesn't allow. Check the file before relying on it.
• Capture environment map saves the view as it is, numbered as an environment map (_envmap_), always at Low. This release can't turn the camera to the six faces of a cube for it; Live Link's cubemap capture does that.
• Start image sequence saves a .tga for every frame drawn, into a folder of its own in the Screenshots folder (frame_0.tga, frame_1.tga...), until you press Stop image sequence or the level changes; a note along the top of the screen counts the frames. Each file is written as its frame is drawn (about 8 MB a frame at 1920×1080), so the game runs slowly while it records. Lock the time step while recording (on) sets the Game group's fixed time step to the rate beside it (30 a second by default) for the recording, so every frame is the same step of game time and the frames play back smoothly at that rate however slowly they were drawn; it's put back when the recording stops. Sound keeps to real time, so record it separately.

Only the combinations the game accepts are offered: on PC, stills at any quality and kind, environment maps at Low, and image sequences as standard at Low. The tab names the files of the last capture.

Coming from Cinematic Tools

Tick Debug Menu in Launch Game instead of Enable Cinematic Tools; if you had Cinematic Tools ticked, OpenCAGE ticks the Debug Menu for you the first time this version starts. Where everything went:

There's no injector to start, nor antivirus exclusion to add for one, and Live Link and the rest of Launch Game's Debug tools run alongside the camera, which they never did with Cinematic Tools. See Launch Game for the rest of the change.

Names

The Cinematic group's switches, values and commands, for Live Link & AI Assistants:

cinematic.camera_set takes x,y,z, and optionally the yaw, pitch and roll and the field of view, in degrees, and turns the camera on there. cinematic.lock takes a character's name or id, or nothing to unlock. cinematic.game_capture takes still or envmap, then optionally low, medium, high or ultra and standard, hdr or both (the tab's choices otherwise), waits for the game to finish and names the files. cinematic.game_sequence_start takes the rate to lock the time step at, or 0 to leave it alone.

Nearly everything in the Debug Menu has a name, so it can be worked from outside the game over Live Link, with the game started with both Debug Menu and Live Link ticked. None of it needs the window open. There are three kinds of name:

• Switches, the tick boxes: characters.view_cones, nav.polys, game.dont_write_saves.
• Values, the sliders, kept within their range: game.speed, nav.radius, ai.tuning.player_throw_speed.
• Commands, for what a button does or what a tab lists, answering in plain text, a line per item: player.give with medikit,max, nav.status, inspect.pick. The command help lists every command with what it takes.

Each group above ends with a table of its names, and Names below says which group each one starts with. Most commands that act on a character act on the selected one, or on the one given as id= its unique id.

OpenCAGE works the menu this way itself: its script debugger sets and steps breakpoints through it, Select Entity Under Game Crosshair asks the World > Inspect crosshair what it's on, and Show Live States Above Nodes reads the scripts through it (see The Debug Menu Over Live Link). From the level's own scripts, a DebugMenuToggle entity sets a switch by name.

An AI assistant connected to OpenCAGE works it through runtime_utils with debug_menu and one of these as menu:

• report (the default): whether the window is open, the group and tab in front, the selected character, the groups and tabs, the commands, every value with its number, and every switch with its state.
• open and close the window.
• tab brings a tab to the front by name: the tab of that name, else the first whose name contains it, else the first group whose name does, ignoring case, so Saves, debug views and Cinematic all work.
• select selects the first character whose name, or failing that whose class, contains name, such as alien or player.
• set ticks or unticks the switch name, as value says.
• value sets the value name to number, kept within its range.
• run runs the command name with argument and gives its answer, as plain text a line at a time.

The window takes up tab and select at its next frame, so report again to see them. A command that waits for the game gives up after a couple of seconds (a few that read a lot, such as physics.census, wait longer), saying it timed out (with no level running, or the game paused, say), and its work still runs when the game gets to it. With screenshot, an assistant can look at what the Debug Menu shows: the window and everything it draws over the game are in the game's picture. runtime_utils with debugger works the script debugger. A game started without the Debug Menu refuses all of these, answering that the debug menu is off in the game. launch_options with debug_menu, debug_menu_key and dont_write_saves sets the Launch Game boxes for the next start.

Names

Every switch, value and command has a dotted name that starts with its area, and the area says which group it's in. report and help list them all.

For instance, set game.dont_write_saves on, value game.speed 0.25, run game.jump_checkpoint with 3, or run light.solo with mover:12.

• Launch Game: the Debug Menu box, Don't write saves, the keys and the settings file
• Live Link: change the scripts of the running game, follow its camera, and stop its scripts with the script debugger
• AI Assistants: let an assistant work the Debug Menu for you
• Debug Text & Markers: put your own text and markers on screen from the scripts
• Behaviour Tree Editor: the trees the Behaviour Tree, Tree Switches and Tree Log tabs show
• CAGEAnimation Editor: the animations the CAGEAnimations tab lists, and Animation Mode in the game
• Cathode Entities: the debug entities, DebugCheckpoint, DebugGraph and the rest
• Configuration Editors: the character, sense, alien and radiosity settings behind what the Debug Menu shows