GPC Combos and Macros: Timing, Structure, Worked Example

A GPC combo is a named block of timed, simulated inputs, press this, hold it 50 milliseconds, release, press that, which the Cronus Zen plays back on its own clock while your main loop keeps running. Combos are how GPC expresses everything with duration: macros, skill-move sequences, drop shots, double taps. This tutorial explains the timing model precisely, then builds a complete one-button macro step by step, a fighting-game-style quarter-circle-forward plus attack, including the trigger, an abort button, and a reusable sub-combo.

You should already be comfortable with the basics from the first script tutorial; the syntax reference has the full combo function table.

How GPC combos actually run

The one rule that explains all combo behavior: each wait(ms) holds everything the statements since the previous wait have set, for that many milliseconds. A combo is not a list of instantaneous actions, it is a list of windows, each defined by the set_val lines above a wait and lasting for that wait's duration.

Take this combo:

// Timing-model illustration (complete script).
main {
    if (event_press(PS4_L1)) {
        combo_run(Windows);
    }
}

combo Windows {
    set_val(PS4_CROSS, 100);    // window 1
    wait(80);
    set_val(PS4_CROSS, 0);      // window 2
    set_val(PS4_CIRCLE, 100);
    wait(120);
}

What the console receives, window by window:

Three more facts complete the model. A running combo continues on its own timeline even if the condition that started it is long gone. Controls the combo does not mention are untouched, you keep moving and aiming while it plays. And wait() accepts 1 to 32767 milliseconds, so a single window can span half a minute if needed.

Step 1: Sketch the sequence before you code it

Our worked example: in many fighting games, a special move is quarter-circle-forward plus an attack button, stick down, roll to down-forward, then forward, then punch. Before writing GPC, write the human action as a timed table:

This sketch step is not optional busywork, every combo bug is easier to find when there is a table stating what should be happening in each window. Remember GPC's axis polarity: on the Y axis, +100 is fully down; on the X axis, +100 is fully right (we will treat right as "forward", real fighting games need a facing check that inputs alone cannot see, which is a fundamental GPC limitation worth knowing early).

Step 2: Write the combo block

Translate the table directly, one window per phase:

// Step 2: the sequence itself, on a test trigger (complete script).

define STEP_MS = 45;    // per-window stick time
define HIT_MS  = 60;    // attack button hold

main {
    if (event_press(PS4_L1)) {
        combo_run(QuarterCircle);
    }
}

combo QuarterCircle {
    set_val(PS4_LY, 100);        // window 1: stick down
    wait(STEP_MS);

    set_val(PS4_LY, 100);        // window 2: down-forward , 
    set_val(PS4_LX, 100);        // both axes held together
    wait(STEP_MS);

    set_val(PS4_LX, 100);        // window 3: forward only
    wait(STEP_MS);

    set_val(PS4_SQUARE, 100);    // window 4: attack
    wait(HIT_MS);
}

Note that window 2 restates PS4_LY, set values do not carry across wait() boundaries; every window declares its own contents. Forgetting this is the most common combo bug: the stick snaps back to your physical position for a window and the game reads a broken motion.

Step 3: Choose the trigger condition

How a combo is triggered matters as much as its contents:

• event_press for run-once. True only on the pass where the button becomes pressed, one press, one macro. This is what we want here.
• get_val for run-while-held. Since combo_run() does nothing while the combo is already running, a held condition makes the combo loop back-to-back, right for rapid fire, wrong for a special move.
• Add a guard when re-entry would hurt. event_press(PS4_L1) && !combo_running(QuarterCircle) refuses a second press until the first sequence finishes. With event_press this is belt-and-suspenders, but it documents intent and protects you if the trigger later changes.

Step 4: Interrupts and sub-combos

Two refinements turn a demo into a usable macro.

An abort button. A 200 ms sequence is an eternity if it starts by accident. combo_stop() halts a combo instantly and returns all controls to your hands:

// Inside main, alongside the trigger:
if (event_press(PS4_CIRCLE)) {
    combo_stop(QuarterCircle);   // panic button: abort mid-sequence
}

Reuse with call(). Valid only inside combos, call(Other) suspends the current combo, plays Other to completion, then resumes. If several macros end with the same attack, extract it once:

combo Attack {
    set_val(PS4_SQUARE, 100);    // shared finisher
    wait(60);
}

Any combo can then end with call(Attack); instead of duplicating those lines, one place to retune the hit timing for every macro that uses it.

The finished macro

Everything assembled, commented, and tunable from the top:

// ============================================================
// qcf_macro.gpc, quarter-circle-forward + attack on one button.
// Press L1 to play the sequence. Press Circle to abort it.
// Assumes the character faces right; retune STEP_MS per game.
// ============================================================

define STEP_MS = 45;    // stick time per window
define HIT_MS  = 60;    // attack button hold

main {
    // Run-once trigger with a re-entry guard.
    if (event_press(PS4_L1) && !combo_running(QuarterCircle)) {
        combo_run(QuarterCircle);
    }

    // Abort at any point in the sequence.
    if (event_press(PS4_CIRCLE)) {
        combo_stop(QuarterCircle);
    }
}

combo QuarterCircle {
    set_val(PS4_LY, 100);        // down
    wait(STEP_MS);

    set_val(PS4_LY, 100);        // down-forward (restate LY)
    set_val(PS4_LX, 100);
    wait(STEP_MS);

    set_val(PS4_LX, 100);        // forward
    wait(STEP_MS);

    call(Attack);                // shared finisher, then done
}

combo Attack {
    set_val(PS4_SQUARE, 100);    // attack press
    wait(HIT_MS);
}

Flash it, test it against a training-mode dummy, and expect to tune. Combo timings are tuned against a specific game build; games buffer inputs differently, and a patch can change the windows without notice. There is no universal set of numbers, which is why every timing above is a define at the top of the file.

Common combo mistakes

For deeper background on why overrides behave this way, read the inputs and events explainer, combos are just set_val on a timer, and the same pipeline rules apply.

FAQ