GPC feedback: drawing on the Cronus Zen OLED and using controller LEDs and rumble

#Why does feedback matter in a script?

A script with a toggle and no indicator is a guessing game. Did the press register? Is the mode on? The Zen gives you three channels that cost nothing in game terms: the OLED on the device, the LEDs on the controller, and rumble. Used sparingly they make a script feel finished. Used carelessly they slow the script down or leave the controller blinking after the feature has ended.

#The OLED: what you have to work with

The display is 128 × 64 monochrome pixels, X from 0 to 127 and Y from 0 to 63. The built-ins:

Fonts are OLED_FONT_SMALL, OLED_FONT_MEDIUM and OLED_FONT_LARGE.

#The pattern: draw only when dirty

The official example is the one to copy:

const string READY_TEXT = "READY";
int oled_dirty = TRUE;

main {
    if(event_press(PS5_TRIANGLE)) oled_dirty = TRUE;

    if(oled_dirty) {
        cls_oled(OLED_BLACK);
        rect_oled(4, 4, 120, 56, FALSE, OLED_WHITE);
        print(36, 23, OLED_FONT_MEDIUM, OLED_WHITE, addr(READY_TEXT));
        oled_dirty = FALSE;
    }
}

oled_dirty starts true so the screen is drawn once at load. Anything that changes what should be shown sets it true again. The draw block runs only on those cycles. The official reference is explicit: repeated full-screen work in every VM cycle can make the script unresponsive.

#Showing a value that changes

For numbers, use the character buffer. putc_oled places ASCII codes at buffer positions 1 to 18, and puts_oled draws the buffer. A common helper converts a two-digit value:

int strength = 25;
int oled_dirty = TRUE;

main {
    if(event_press(PS5_UP)) {
        strength = strength + 1;
        if(strength > 99) strength = 99;
        oled_dirty = TRUE;
    }
    if(oled_dirty) {
        cls_oled(OLED_BLACK);
        putc_oled(1, 48 + strength / 10);
        putc_oled(2, 48 + strength % 10);
        puts_oled(52, 24, OLED_FONT_LARGE, 2, OLED_WHITE);
        oled_dirty = FALSE;
    }
}

48 is the ASCII code for 0, so 48 + digit gives the character. This is exactly the kind of code that belongs behind a dirty flag: it is cheap once and expensive every cycle.

#Controller LEDs

The controller's player LEDs are addressable as LED_1 onward. States are 0..3: off, on, fast blink, slow blink.

init {
    set_led(LED_1, 1);          // on
}

main {
    if(event_press(PS5_CROSS)) {
        set_ledx(LED_1, 3);     // blink three times, then stop
    }
    if(event_press(PS5_CIRCLE)) {
        reset_leds();           // give control back to the console
    }
}

set_ledx runs a finite blink sequence; get_ledx() tells you whether one is still active, and a blink count of zero leaves the LED on. get_led(LED_n) reads the current state. The important habit is reset_leds() when your feature turns off. A script that leaves an LED blinking forever is the most common feedback bug.

#DualShock 4 light bar

On a DualShock 4 you have a full RGB light bar. Channel values are 0..255.

main {
    if(get_ival(PS4_L2)) {
        set_ps4_lbar(255, 0, 0);    // red while L2 held
    }
}

get_ps4_lbar(PS4_GREEN) and the other channel selectors read what the console is sending, useful when a game uses the light bar for health or team colour and you want to restore it. Firmware 2.3.2 made light bar and rumble behaviour consistent between USB and Bluetooth, so this works the same either way on current firmware.

#Rumble as confirmation

A short rumble on a toggle is unmistakable and needs no glance at the screen. Strengths are 0..100.

combo Confirm {
    set_rumble(RUMBLE_A, 60);
    wait(120);
    reset_rumble();
}

main {
    if(event_press(PS5_OPTIONS)) combo_run(Confirm);
}

reset_rumble() clears your override and returns control to the console; block_rumble() in init suppresses console rumble entirely if a script needs a quiet controller. The official page's advice is to reset explicitly on feature exit so a manual output cannot remain active. Combos are covered in combos and wait timing.

#A feedback checklist

1. One owner per output. Decide which part of the script draws the OLED, sets LEDs and fires rumble. The official architecture guide calls this the feedback ownership pattern.
2. Dirty flags for the OLED. Always.
3. Reset on exit. reset_leds() and reset_rumble() when a mode turns off.
4. Short and rare rumble. It is confirmation, not decoration.
5. Readable text. Two or three lines in medium or large font beat a dense small-font panel.
6. Test with a GamePack in another slot to see how Collective Minds' own packs present state; they set the house style.

#Where this fits

Feedback is the last of the four building blocks. Input reading is in get_val and stick values, timing in combos and wait, and memory in SPVAR persistence. Put them together and you have the structure of every GamePack on the device.