Movement

1. The bird's-eye view is faster than the diagonal view, for two reasons: there is less lag between levels, and filling a hole with a block takes 18 frames in bird's-eye but 26 frames in diagonal.
2. Switching players (in Going Up? floors with more than one player) costs 30 frames if you do it once, but 32 frames if you do it again immediately after another switch. Therefore you want to insert at least one non-switch move between switches when possible.

Floor numbers

RNG

define  rng_state_a     0xcf28
define  rng_state_b     0xcf29
define  rng_state_c     0xcf2a
define  rng_state_d     0xcf2b

; Returns a 1-byte random number in the a register.
rng_next:
        ld a, [rng_state_d]
        rr a
        ld [rng_state_d], a
        ld a, [rng_state_a]
        adc 0x25
        ld [rng_state_a], a
        ld b, a
        ld a, [rng_state_b]
        adc 0x33
        ld [rng_state_b], a
        adc b
        ld b, a
        ld a, [rng_state_c]
        adc 0x53
        ld [rng_state_c], a
        adc b
        ld b, a
        ld a, [rng_state_d]
        rl a
        xor b
        ld [rng_state_d], a
        ret

def rng_seed(seed):
    a = seed
    b = seed
    c = seed
    d = seed
    return (a, b, c, d)

def add_u8_with_carry(x, y, carry):
    r = x + y + carry
    carry = (r >> 8) & 1
    return r & 0xff, carry

# Returns the new (a, b, c, d) RNG state, as well as the RNG output.
def rng_next(a, b, c, d):
    carry = d & 1
    a, carry = add_u8_with_carry(a, 0x25, carry)
    s = a
    b, carry = add_u8_with_carry(b, 0x33, carry)
    s, carry = add_u8_with_carry(s, b, carry)
    c, carry = add_u8_with_carry(c, 0x53, carry)
    s, carry = add_u8_with_carry(s, c, carry)
    d = ((d & 0xfe) | carry) ^ s
    return (a, b, c, d), d

Heading Out?

Heading Out? floor schedules

define  game_mode                       0xc2b8  ; 0 = Going Up?, 1 = Heading Out?
define  heading_out_num_floors          0xc2b9
define  heading_out_num_floors_remaining        0xc2ba
define  heading_out_floor_schedule      0xc311  ; Array of 99 bytes.
define  frame_counter_copy              0xc377

generate_random_floor_schedule:
        ld      de, heading_out_floor_schedule
        ld      a, [frame_counter_copy]
        ld      [rng_state_a], a
        ld      [rng_state_b], a
        ld      [rng_state_c], a
        ld      [rng_state_d], a
        ld      c, 99           ; Generate a schedule of 99 floors.
loop:
        call    rng_next        ; a = next RNG output.
        ld      l, a
        ld      h, 0            ; hl = a extended to 16 bits.
        call    heading_out_num_floors_for_skill_level  ; b = 30 (Easy), 50 (Average), or 40 (Hard).
        ld      a, b
        call    remainder_16b   ; a = rand % num_floors
        add     30
        call    check_history
        cp      0xab            ; Is this floor number a duplicate?
        jr      Z, loop         ; Repeat floor, try again.
        ld      [de], a         ; Store the newly generated floor.
        inc     de              ; Next schedule array index.
        dec     c
        jr      nZ, loop        ; If less than 99, generate the next floor.
        ld      a, [heading_out_num_floors]
        ld      b, a
        ld      a, [game_mode]
        cp      1
        jr      Z, copy_history ; Branch is always taken; this function is only called when game_mode == 1.
        ld      a, [heading_out_num_floors_remaining]
        ld      c, a
        sub     b
        jr      C, copy_history
        ld      b, c
copy_history:
        ; Copy the last 20 floors to be played into the history buffer for the next run.
        ; memcpy(heading_out_floor_schedule - 20, heading_out_floor_schedule + heading_out_num_floors - 20, 20)
        ld      a, b            ; a = heading_out_num_floors
        ld      hl, heading_out_floor_schedule - 20
        call    add_16b         ; hl = heading_out_floor_schedule - 20 + heading_out_num_floors
        ld      b, 20
        ld      de, heading_out_floor_schedule - 20
copy_history_next:
        ldi     a, [hl]
        ld      [de], a
        inc     de
        dec     b
        jr      nZ, copy_history_next
        ret

; Checks if the value of register a is present in the 20 array elements before de.
; Sets a to 0xab if a duplicate is found. Otherwise leaves a unchanged.
check_history:
        push    de
        push    bc
        ld      b, 20
        ld      c, a
        dec     de
loop:
        ld      a, [de]
        cp      c
        jr      Z, found_dup
        dec     de
        dec     b
        jr      nZ, loop
        jr      no_dup
found_dup:
        ld      a, 0xab
        jr      return
no_dup:
        ld      a, c
return:
        pop     bc
        pop     de
        ret

Heading Out? inverted floors

31
####################
####################
####################
####################
####################
####################
######........######
######........######
......~.####......1#
######..####..######
######.a......######
######.#......######
####################
####################
####################
####################
####################
####################

31i
####################
####################
####################
####################
####################
####################
######.#......######
######.a......######
....##..####..##..1#
###...~.####.....###
######........######
######........######
####################
####################
####################
####################
####################
####################

define  current_floor           0xc2bf
define  vertical_invert         0xc2fa
define  num_floors_completed    0xc375

increment_num_floors_completed_and_roll_vertical_invert:
        ld      a, [num_floors_completed]
        inc     a
        ld      [num_floors_completed], a
        ld      e, a
        ld      d, 0
        ld      hl, heading_out_floor_schedule
        add     hl, de
        ld      a, [hl]
        ld      [current_floor], a
        xor     a
        ld      [vertical_invert], a
        call    rng_next
        and     1
        ld      [vertical_invert], a
        ret

Heading Out? solutions

Resources

• TASVideos game page
• TASVideos discussion thread
• Thread about algorithmic optimization

Movies

• 2024 [6203] GB Kwirk "Heading Out?, all floors" by Sand in 25:15.19
• 2024 [5850] GB Kwirk "Going Up?" by Nitrodon, ZenicReverie, CyberShadow, Sand, Alyosha & Deadcode in 15:15.89
• 2020 [4105] GB Kwirk "Going Up?" by Nitrodon, ZenicReverie & Alyosha in 15:46.03
• 2018 [3755] GB Kwirk "Going Up?" by Nitrodon, ZenicReverie & Alyosha in 15:40.49
• 2007 [857] GB Kwirk "Going Up?" by Nitrodon in 15:46.25

Tools

• DDD and DDD-Kwirk, algorithmic optimizer
• git clone https://www.bamsoftware.com/git/kwirk.git Sand's utilities