Play Testing and Packaging

Play test in every Play In Editor mode, then package, cook and Quick Launch your Unreal Engine project from your AI assistant, on UE 5.6, 5.7 and 5.8.

CodeFizz Editor Agent can drive the toolbar's Play menu and the Platforms menu. Your AI assistant can play test your game in every Play mode, with any net mode and number of players, then package it, cook it, or launch it on a device. Each command runs the editor's own code, so you get what clicking the menu gives you: the same packaging notification with its Cancel button, and the same lines in the Output Log.

It needs plugin 2.4.0 and cfa 3.5.0 or later, and it works on Unreal Engine 5.6, 5.7 and 5.8. The editor must be open with your project.

The short version

1. Play with a listen server and one client, each in its own window:

bash

cfa play_in_editor --mode new_window --net-mode listen_server --num-players 2

2. Check that a Shipping package for Windows will work:

bash

cfa validate_packaging --platform Windows --configuration Shipping

3. Package it, then watch the job:

bash

cfa package_project --platform Windows --configuration Shipping --archive-directory D:/Builds
cfa get_build_status

Play in the editor

play_in_editor runs the toolbar's own Play commands. With no flags it repeats the last mode, like the green Play button. --mode picks one of the six modes of the Play menu:

--mode

viewport     Selected Viewport
new_window   New Editor Window
vr           VR Preview (needs a headset)
mobile       Standalone Game Mobile
standalone   Standalone Game
simulate     Simulate

The green Play button, the last mode again:

bash

cfa play_in_editor

Play in the level viewport and start at the Player Start:

bash

cfa play_in_editor --mode viewport --spawn-at player_start

A listen server and two clients:

bash

cfa play_in_editor --mode new_window --net-mode listen_server --num-players 3

Simulate:

bash

cfa play_in_editor --mode simulate

--spawn-at, --net-mode and --num-players set the same values as the Play menu's own controls. Like those controls, they are saved in Editor Preferences and stay for the next Play. The reply lists every change in settings_changed with its old and new value, so you can put your own values back.

With listen_server, the first player is the server and has a window. With client, the editor adds a dedicated server with no window, and every player is a client. You can have 1 to 10 players on UE 5.8, and up to 64 on 5.6 and 5.7. The command waits until play has started and every client has joined, then returns the session:

get_play_session output (shortened)

{
  "state": "playing",
  "worlds": [
    {
      "instance": 0,
      "net_mode": "listen_server",
      "players": 2,
      "map": "/Game/ThirdPerson/Lvl_ThirdPerson",
      "shown_in": "MyGame Preview [NetMode: Server 0]  (64-bit/PC D3D SM6)"
    },
    {
      "instance": 1,
      "net_mode": "client",
      "players": 1,
      "map": "/Game/ThirdPerson/Lvl_ThirdPerson",
      "shown_in": "MyGame Preview [NetMode: Client 1]  (64-bit/PC D3D SM6)"
    }
  ]
}

shown_in is level_viewport or the title of the window. Give that title to cfa take_screenshot --window to take a picture of one window.

Standalone Game runs as a separate process

Standalone Game, Standalone Game Mobile, and several players with Run Under One Process off start a new game process that loads your project from disk. So it refuses while assets are unsaved (add --save-dirty=true to save them first), and it refuses a level that was never saved. While a Standalone Game runs, a new play_in_editor is refused, because starting play would close it.

Control a running game

See every world with its net mode, players, map and window:

bash

cfa get_play_session

Pause, step one frame, then resume:

bash

cfa control_play_session --action pause
cfa control_play_session --action advance_frame
cfa control_play_session --action resume

Leave the player and fly freely (F8), then take the player back:

bash

cfa control_play_session --action eject
cfa control_play_session --action possess

Stop play. This also closes Standalone Game windows:

bash

cfa stop_play_in_editor

Eject and possess work only for a session in the level viewport, as in the editor. The command waits for the switch, so the reply already shows the new state. Every other Play setting, such as Run Under One Process, the window size or the server port, is in cfa get_project_settings --class-name LevelEditorPlaySettings.

Check before you package

A package can take an hour, so check first. validate_packaging reads the same settings the package will use. It returns a verdict (pass, pass with warnings or fail) and a list of what to fix.

The platforms you can package for, with their SDK state and build targets:

bash

cfa list_platforms --supported-only=true

Will a Shipping package for Windows work?

bash

cfa validate_packaging --platform Windows --configuration Shipping

validate_packaging output (shortened)

{
  "verdict": "pass",
  "errors": 0,
  "warnings": 0,
  "platform": "Windows",
  "configuration": "Shipping",
  "target": "MyGame (Game)",
  "findings": [
    { "code": "sdk", "severity": "info", "message": "SDK installed.", "target": "Windows" }
  ]
}

If the engine install does not have the files for a platform, packaging for it is refused, as the editor refuses it, and the check reports a fail.

Package or cook

package_project builds the same BuildCookRun command as Platforms > Package Project. It uses the same settings: Project Settings > Packaging, plus the platform, target and configuration you give. It saves unsaved assets first, as the menu does.

See the exact command first

Nothing starts. The reply shows the full command line that the package will run.

bash

cfa package_project --platform Windows --configuration Shipping --dry-run=true

Start the package

The command returns at once with a job_id. The editor shows its "Packaging project for Windows..." notification with a Cancel button, and every line goes to the Output Log.

bash

cfa package_project --platform Windows --configuration Shipping --archive-directory D:/Builds

Find the game

The build lands in a platform folder inside the archive folder, for example D:/Builds/Windows/.

Cook the content only:

bash

cfa cook_content --platform Windows

Read the Packaging settings the package uses:

bash

cfa get_project_settings --class-name ProjectPackagingSettings

Change one of them, for example For Distribution:

bash

cfa set_project_settings --class-name ProjectPackagingSettings --property-name ForDistribution --property-value true

The configurations are project (the one in the Packaging settings), DebugGame, Development, Test and Shipping. With For Distribution on, the package is always Shipping.

Projects with no C++ code

A project with no C++ code packages with the engine's own game target. Some engine installs list no such target. Then Package Project leaves out the configuration, as the editor does, and the build is Development. The reply warns you when you asked for another configuration.

Watch the job, or cancel it

The stage, the errors and the newest lines of the log:

bash

cfa get_build_status

Only the errors, up to 50 lines:

bash

cfa get_build_status --severity error --max-lines 50

Stop the job:

bash

cfa cancel_build

get_build_status output (shortened)

{
  "job_id": 1,
  "kind": "package",
  "platform": "Windows",
  "state": "succeeded",
  "stage": "Archive",
  "stages_done": ["Cook", "Stage", "Package", "Archive"],
  "errors": 0,
  "warnings": 5,
  "verdict": "pass_with_warnings",
  "output_directory": "D:/Builds",
  "log_file": "C:/MyGame/Saved/CodeFizzEditorAgent/Builds/package_1_20261020-074039.log",
  "lines": [
    "BUILD SUCCESSFUL",
    "AutomationTool exiting with ExitCode=0 (Success)"
  ]
}

The stages are build, cook, stage, package and archive, and the whole log is in log_file. One job runs at a time, because every packaging run in the editor shares one queue. A second start is refused and names the job that runs. A job stays queued while the editor's own SDK check holds that queue.

Quick Launch on a device

Quick Launch builds, cooks, deploys and runs the current level on a device, with the editor's own launcher and notifications. You watch and cancel it with the same two commands as a package.

Find the device:

bash

cfa list_devices

Launch the current level on it:

bash

cfa quick_launch --device Windows@MYPC

A launch that runs the game stays running until the game exits. To close the game, find its process and end it. The process name is your project name, or UnrealGame for a project with no C++ code.

Find the game process, then end it:

bash

cfa list_device_processes --device Windows@MYPC --filter MyGame
cfa control_device --device Windows@MYPC --action terminate_process --process-id <pid> --confirm=true

Project Launcher profiles

A profile is a saved launch: the project, build target, platform, configuration, content scheme, cook, archive, devices, start map and extra command line. Only the fields you give change, and the reply reads every field back from the saved profile.

Create a profile

This one makes a Shipping build for Windows and keeps a copy in D:/Builds.

bash

cfa create_launch_profile --name "Win Shipping" --platform Windows --configuration Shipping --content-scheme pak_files --deploy=false --archive=true --archive-directory D:/Builds

Check it

The verdict says what to fix before you launch.

bash

cfa validate_launch_profile --profile "Win Shipping"

Run it

It returns a job id. Watch it with get_build_status and stop it with cancel_build.

bash

cfa run_launch_profile --profile "Win Shipping"

List, rename and delete profiles:

bash

cfa list_launch_profiles
cfa set_launch_profile --profile "Win Shipping" --new-name "Win Shipping Archive"
cfa delete_launch_profile --profile "Win Shipping Archive"

Open the Project Launcher window itself:

bash

cfa open_tab --tab-id ProjectLauncher

The engine keeps a copy of the build only when the profile does not deploy, so use --archive=true with --deploy=false. If not, the check warns that the archive is skipped. The start map is saved by name, and a name that several maps share gives a warning. Profiles are saved per engine install, not per project, so the list can show profiles of your other projects.

Devices

Every device with its status:

bash

cfa list_devices

The processes that run on a device:

bash

cfa list_device_processes --device Windows@MYPC --filter Unreal

Claim, release or share a device:

bash

cfa control_device --device Windows@MYPC --action release

Open the Device Manager window itself:

bash

cfa open_tab --tab-id DeviceManager

This computer is a device too

The editor claims this computer as a device when it starts. On it, power_off and reboot turn off or restart this computer, so they need --confirm=true. Ending a process also needs --confirm=true, and the editor's own process is always refused.

Or just ask your AI assistant

You do not have to type any of this. The skill that ships with the CLI teaches your assistant the same steps. You can ask in plain words:

things you can ask

Play the level with a listen server and two clients, take a screenshot of each window, then stop.
Check that a Shipping build for Windows will package, tell me what to fix, then package it to D:/Builds.
Cook the content for Windows and list every error.
Make a Project Launcher profile that keeps a Shipping build in D:/Builds, check it, and run it.

If your assistant does not know these commands yet, update its skill with cfa skill install. See The AI Skill.

Common errors

Play did not start (state is idle)

Read why with cfa read_message_log --log-name PIE.

Standalone Game or Quick Launch refuses because assets are unsaved

Add --save-dirty=true, or save first with cfa save_all. A level that was never saved needs cfa save_level_as.

A job is already running

Only one job runs at a time. Wait for it with cfa get_build_status, or stop it with cfa cancel_build.

The engine install lacks the files for a platform

Add that platform to your engine install, or package for another platform. cfa list_platforms marks such a platform with installed_files_missing.

Command summary

Play, see the session, control it, stop it:

bash

cfa play_in_editor --mode <mode>
cfa get_play_session
cfa control_play_session --action <action>
cfa stop_play_in_editor

Check, package, cook:

bash

cfa list_platforms
cfa validate_packaging --platform <name>
cfa package_project --platform <name>
cfa cook_content --platform <name>

Watch or stop any job:

bash

cfa get_build_status
cfa cancel_build

Launch the current level on a device:

bash

cfa quick_launch --device <id>

Project Launcher profiles:

bash

cfa list_launch_profiles
cfa create_launch_profile --name "<name>"
cfa validate_launch_profile --profile "<name>"
cfa run_launch_profile --profile "<name>"

Devices:

bash

cfa list_devices
cfa list_device_processes --device <id>
cfa control_device --device <id> --action <action>

Every flag of the packaging and device commands is in the Packaging and Devices reference. The Play commands are on the Level Actors reference page.

Loading…

PreviousImage Generation (OpenRouter)NextBuild a Blueprint with AI