Google CTF Finals 2025

Google CTF Final 2025

Also known as Hackceler8 by Dudcom

Finals this year was held in Mexico City. As always, it was based on game hacking + speedrunning to get flags and beat a boss. I was playing for the team SLICES [:]. For quals it was mostly us (Squid Proxy Lovers) and Infobahn, plus a handful from our other sub-teams. Sadly, for finals we didn’t really have any remote help outside of the start of day two due to the time zone and us not planning it out well. Onsite, the team was Clovis Mint, ContronThePanda, and BraydenPikachu. Because flights got in the way, Brayden didn’t arrive until after competition day 1, and I was also there.

Game Summary

The game is a 4-person 2D Zelda-like dungeon crawler; the objective is to clear mini-bosses in four temples. Each temple is on a corner of the map. The maps are generally the same, but some rounds do change them, while items and enemies are moved around per round/patch. The way to beat the game is to defeat the final boss. To actually fight the final boss, we need to get some number of “flags” that are given to you arbitrarily from the mini-bosses. In the demo version there is 1 boss with 1 flag, and one boss has 2 flags in every temple, but this is not the case in the actual rounds - it’s entirely up to the devs.

Generally speaking, the more game-breaking bugs you found, the more flags you were awarded. There was only one mini-boss per temple. The required flags for the final boss were 4 on day one, 5 on day two, and 5 on day three. Rankings worked like this: clearing the boss equaled winning the game; time broke ties. If no one beat the boss, ranking was based on the number of flags, with time breaking ties again. An interesting aspect of the game was the tradeoff: if the final boss was too hard, you often gained more by completing all the temples as fast as possible. This happened fairly often since the final boss was generally memory exploitation, and doing that on a controller was hard.

Hardware/architecture-wise the game was built for the Sega Genesis and was running on custom hardware to allow for 4-person co-op. Most standard emulators will not be able to support testing with four people, given that 4-person play wasn’t really made for those systems. The only way to get it working that we found was to use Kega Fusion, an emulator which allows you to enable 4-person play in Sega Genesis games, and that is what the team used for testing.

Rounds Summary

Every round, Google would provide a brand-new version of the game with source code and a compiled version of the game. The base game was relatively safe. There were some bugs and issues that existed, but they weren’t the easiest to exploit. The patches generally introduced logic bugs or created situations that allowed for exploiting kinks in the game engine, like clipping. They generally had a few common patch structures that we saw over and over:

Creating Items to solve specific situations
Speed-buff issues that allowed for wall clipping
NPCs were added with exploitable input fields
Enemies were located in exploitable/finicky sections of the game

Tooling

Ok, so if we were really trying, this would be something that we made at least a few days or weeks before, but honestly everyone on our team was fairly busy, so most of the tooling was pretty much set up on site. A lot of it was built by our best friend AI, but regardless, let’s get into it:

Map Visualization

One of the most useful things you could do while playing the game was to figure out the map layout and enemy/boss locations. This helps you prioritize and figure out what you need to target in order to optimize your speedrun. On top of that the map layout also directly gave you hints on which parts of the patch would correlate with which temple. Every temple would generally speaking have a unique exploit and bug that you had to use in order to beat it.

Here is what our tooling would spit out: Map visualization tool output As you can see here, the tooling would create a simple PNG that showed the overall layout and some basic info on what each thing in a map was, such as whether they were enemies, mini-bosses, the flag value of a mini-boss, objects, and more. I want to make it clear, though, that the game was actually built on a standard map format and you could use applications like Tiled to analyze the map as well. I just found it somewhat tedious to use for a quick overview, though it still gave lots of useful information, so we did end up using both.

Tiled map editor interface While this does work, I didn’t like that it didn’t show all objects and that I had to click through things to figure out the properties.

AI generated lots of stupid, semi-useless things in terms of how you can use it, but honestly I only really did:

1
python3 map_visualizer.py ../round_3/resources/maps/water-temple/water-temple.world -o water3.png
2
Octopus: 14
3
Siren: 3
4
HeartItem: 3
5
Boots: 2
6
Sword: 2
7
Spawn: 1
8
DuckNpc: 1
9
DoorH: 1
10
Saved world visualization to: water3.png

I added the prints here to summarize the map objects pretty fast. It’s dynamically defined via the map using the game’s internal object, so I never need to update names and such.

Hack Client

Well, it’s a game hacking competition, so how could you not make a hack client? The hack client I made had several goals in mind:

show speed, let you modify speed
modify health
modify flag values
add random objects
TP/Movement hacks

This isn’t perfect, and honestly I had several things I wish I could have added, but they weren’t really the biggest priorities unless we had a proper remote team backing us up. So maybe for another year. I mostly wanted to add:

Macro system for controlled input & and easy testing of memory exploitation
Hitbox analysis

Beyond that, I don’t think there was too much else that would help. Most of the bugs and hacks were fairly obvious; the main reason I think a hack client was nice is that it allowed faster testing of specific things like the boss by just giving yourself flags and whatnot from the start.

Installing is fairly simple:

You just drop debug_client.rs into the source folder and then update:

add mod debug_client; in lib.rs
Follow this diff for game.rs:

1
19a20
2
+ use crate::debug_client::DebugClient;
3
179a181
4
+     pub debug_client: DebugClient,
5
254a257
6
+             debug_client: DebugClient::new(),
7
267a271,273
8
+         // Update debug client first to check for toggle
9
+         ctx.debug_client.update(&ctx.controller, &mut ctx.players, &mut ctx.world, &mut ctx.captured_flags, &mut ctx.defeated_minibosses, ctx.frame);
10
+
11
420a427,429
12
+
13
+         // Render debug client on top of everything
14
+         self.debug_client.render(&mut self.vdp, &self.players, &self.ui, self.captured_flags, self.defeated_minibosses);

You’re just including the debug client.
Making it public to use.
Initializing it in the game state.
Calling it with the necessary args for it to run.
Rendering it on top of the current game state.

Using it is fairly simple as well:

1
Click "X" to enter debug mode
2
left and right while in NAV mode to switch users
3
Up and Down to pick object to edit
4
Click "A" to enter edit mode
5
Up and Down to inc values for everything but items
6
Items work by you going up and down to pick the item and then right to add
7
Click "X" to Exit debug mode

Round-1 (4 Flags For Boss)

Fire-Temple

1
python3 2025/hackceler8/map_visualizer.py 2025/round_1/resources/maps/fire-temple/fire-temple.world
2
Blob: 10
3
Flameboi: 8
4
CatNpc: 1
5
HeartItem: 7
6
Goggles: 2
7
Boots: 2
8
Sword: 1
9
DoorH: 5
10
Spawn: 1
11
Switch: 2

Key Diff:

1
fn unique_item() -> Dialogue {
2
    Dialogue::new_multiple_choice(
3
        "Would you like to have my key?",
4
        &["Yes", "No"],
5
        Some(unique_item_2),
6
    )
7
}
8

9
fn unique_item_2(ctx: &mut Ctx, response: &str) {
10
    if eq(response, "No") {
11
        return;
12
    }
13

14
    if ctx.world.inventory.contains(ItemType::Key) {
15
        ctx.start_dialogue(Dialogue::new_no_response(
16
            "I already gave you my key.",
17
            None,
18
        ));
19
        return;
20
    }
21

22
    ctx.world.inventory.add(ItemType::Key);
23
    ctx.start_dialogue(Dialogue::new_no_response("Here you go!", None));
24
}
25

26
fn eq(a: &str, b: &str) -> bool {
27
    a.len() == b.len() && a.chars().zip(b.chars()).all(|(a, b)| a == b)
28
}
29

30
fn get_item(ctx: &mut Ctx, _: &str) {
31
    ctx.world.inventory.add(ItemType::Key);

This part of the game was fairly trivial; you just had a wall.

Fire Temple doors and NPC As you can see here, there are 4 doors that you need to pass. You just talk to the NPC nearby several times, and after doing so you can beat the mini-boss. This entire section was pretty trivial.

Water-Temple

1
python3 2025/hackceler8/map_visualizer.py 2025/round_1/resources/maps/water-temple/water-temple.world
2
Octopus: 16
3
Siren: 5
4
DoorV: 1
5
HeartItem: 3
6
Boots: 2
7
Key: 2
8
Sword: 1
9
Goggles: 1
10
Spawn: 1
11
DuckNpc: 1
12
DoorH: 1

Key Diff:

1
diff '--color=auto' dist/2025/hackceler8/game/src/player.rs round1/round_1/game/src/player.rs
2
153c153
3
-         if !self.is_alive() {
4
---
5
+         if self.health == 0 {

This was the part of the map that you actually needed to exploit and find a way to bypass: it was a wall of enemies, and there was no way to pass them normally. The actual hack here is the fact that when you die, you go into a dying animation but aren’t actually fully set to dead. What this allows you to do is move from room to room and then enter an invulnerable state and kill the enemies. This hack is actually doable throughout the game and makes you semi-unkillable. You can still die from touching any auto-kill objects, and if you regain any health, you leave the state. Water Temple enemy wall exploit

Sky-Temple

Sky Temple map layout

1
python3 2025/hackceler8/map_visualizer.py 2025/round_1/resources/maps/sky-temple/sky-temple.world
2
Angel: 9
3
Goggles: 1
4
HeartItem: 7
5
Archer: 5
6
SnakeNpc: 1
7
Sword: 1
8
DoorV: 5
9
ChestNpc: 5
10
MimicNpc: 7
11
Spawn: 1

Key Diff:

1
                             (Sprite::Anim::IdleDown, false)
2
                         };
3
                         npc.sprite.maybe_set_anim(anim as usize);
4
                         npc.sprite.flip_h = flip;
5
                         break;
6
                     }
7
114a130
8
             ctx.dialogue_npc_id = Some(npc_id);
9
150a167,172
10
             NpcType::ChestNpc | NpcType::MimicNpc => Hitbox {
11
                 x: 1,
12
                 y: 11,
13
                 w: 21,
14
                 h: 13,
15
             },
16
181a204,276
17
 }
18

19
 fn mimic_challenge() -> Dialogue {
20
     Dialogue::new_multiple_choice(
21
         "I swear I'm not a mimic!\nOpen me?",
22
         &["Yes", "No"],
23
         Some(mimic_challenge_open),
24
     )
25
 }
26

27
 fn mimic_challenge_opened() -> Dialogue {
28
     Dialogue::new_no_response("This chest is already open.", None)
29
 }
30

31
 fn mimic_challenge_open(ctx: &mut Ctx, response: &str) {
32
     if eq(response, "No") {
33
         return;
34
     }
35

36
     if let Some(npc_id) = ctx.dialogue_npc_id {
37
         let npc = &mut ctx.world.npcs[npc_id];
38
         if npc.npc_type == NpcType::ChestNpc {
39
             npc.sprite.set_anim(MimicSprite::Anim::Open as usize);
40
             // Switch to the "already opened" dialogue.
41
             npc.dialogue_id = 3;
42
             ctx.start_dialogue(Dialogue::new_no_response(
43
                 "Obtained *Key* !",
44
                 Some(get_item),
45
             ));
46
         } else {
47
             npc.sprite.set_anim(MimicSprite::Anim::OpenMimic as usize);
48
             ctx.start_dialogue(Dialogue::new_no_response("I LIED, BWA HA HA!", Some(lose)));
49
         }
50
     }
51
 }
52
     pub items_collected: Bitmask,
53
308a311,343
54
     pub fn shuffle_chests(&mut self, rng_state: &mut u32) {
55
         let mut filled_position = [false; 12];
56
         let mut found_chest = false;
57
         for npc in &mut self.npcs {
58
             if npc.npc_type != NpcType::ChestNpc && npc.npc_type != NpcType::MimicNpc {
59
                 continue;
60
             }
61
             found_chest = true;
62

63
             let mut pos = (Self::get_random_int(rng_state) % 10) as usize;
64
             if filled_position.iter().all(|x| *x) {
65
                 panic!("All chest slots filled");
66
             }
67
             while filled_position[pos] {
68
                 pos = (pos + 1) % 12;
69
             }
70
             filled_position[pos] = true;
71

72
             npc.set_position(128 + 1 + pos as i16 * 24, npc.y);
73
         }
74

75
         if found_chest {
76
             for _ in 0..5 {
77
                 self.inventory.remove(ItemType::Key);
78
             }
79
         }
80
     }
81

82
     fn get_random_int(rng_state: &mut u32) -> u32 {
83
         *rng_state = rng_state.wrapping_mul(1664525).wrapping_add(1013904223);
84
         *rng_state
85
     }

The addition here was the creation of a new NPC based on a seeded random value. It would generate five keys. When you pick up a key, the other mimics lose their keys. You have to keep resetting the state to reseed the mimics. You will die when you get it wrong, but you can use the earlier bug to reset the player trying the mimic, giving you effectively infinite attempts. Sky Temple mimic chests White dots are the mimics; the brown tiles are the doors. You need five keys to get past.

Forest-Temple

Forest Temple map layout

1
python3 2025/hackceler8/map_visualizer.py 2025/round_1/resources/maps/forest-temple/forest-temple.world
2
Goblin: 10
3
Boots: 2
4
RacoonNpc: 1
5
Goggles: 1
6
Orc: 10
7
HeartItem: 6
8
Spawn: 1
9
Key: 1
10
Sword: 1
11
DoorV: 3
12
Switch: 2

Key Diff:

Nothing! The bug here is a core issue in the game, or at least that’s how we solved it. If you time it correctly, you can pick up the key with 3–4 people in the room before the three doors. This is more or less an item duplication glitch by timing everything correctly. The best way we found to do this was to let one person hold the controller and pick it up for everyone at once.

Round-2 (4 Flags For Boss)

Fire-Temple

1
python3 2025/hackceler8/map_visualizer.py 2025/round_2/resources/maps/fire-temple/fire-temple.world
2
Blob: 12
3
Flameboi: 9
4
HeartItem: 7
5
Knife: 1
6
Boots: 2
7
DoorH: 3
8
Key: 1
9
Sword: 1
10
Spawn: 1
11
Goggles: 1
12
Switch: 2
13
CatNpc: 1

Key Diff:

1
fn engrave() -> Dialogue {
2
    Dialogue::new_free_text("Can you guess my secret?", Some(engrave_guess))
3
}
4

5
fn engrave_guess(ctx: &mut Ctx, response: &str) {
6
    if eq(response, SECRET) {
7
        ctx.start_dialogue(Dialogue::new_no_response(
8
            "That's correct! Here's your reward.\n\nObtained *Key* !",
9
            Some(get_item),
10
        ));
11
    } else {
12
        ctx.start_dialogue(Dialogue::new_free_text(
13
            "That's not it.\n:C\n\
14
             As consolation I can engrave your name onto the map.\nWhat's your name?",
15
            Some(engrave_name),
16
        ));
17
    }
18
}
19

20
fn engrave_name(ctx: &mut Ctx, response: &str) {
21
    let mut tiles: Vec<TileFlags, 64> = Vec::new();
22
    text_to_tiles(ctx, &mut tiles, response);
23
    text_to_tiles(ctx, &mut tiles, SECRET);
24
    ctx.vdp
25
        .set_plane_tiles(Plane::A, 45 * 64 + 10, &tiles[0..response.len()]);
26

27
    let img = &ctx.ui.inventory_text_img;
28
    ctx.vdp
29
        .set_tiles(img.start_tile, tileset::TILESETS[img.tiles_idx]);
30
    let cur = ctx.world.plane_window.current_scroll();
31
    ctx.vdp.set_h_scroll(0, &[-(cur.0 as i16), 0]);
32
    ctx.vdp
33
        .set_v_scroll(0, &[cur.1 as i16, image::SCREEN_V_SCROLL]);
34

35
    ctx.start_dialogue(Dialogue::new_no_response(
36
        "What a lovely name!\nI engraved it for your viewing pleasure.",
37
        None,
38
    ));
39
}
40

41
fn text_to_tiles(ctx: &Ctx, tiles: &mut Vec<TileFlags, 64>, text: &str) {
42
    let img = &ctx.ui.inventory_text_img;
43
    for chr in text.as_bytes().iter() {
44
        let tile = TileFlags::for_tile(
45
            img.start_tile + ui::CHAR_TILES_INDEXES[*chr as usize] as u16,
46
            img.palette,
47
        );
48
        info!("Converting {} -> {}", chr, tile.tile_index());
49
        tiles
50
            .push(tile)
51
            .unwrap_or_else(|_| panic!("tile vec too small"));
52
    }
53
}
54

55
fn eq(a: &str, b: &str) -> bool {
56
    a.len() == b.len() && a.chars().zip(b.chars()).all(|(a, b)| a == b)
57
}
58

59
fn get_item(ctx: &mut Ctx, _: &str) {
60
    ctx.world.inventory.add(ItemType::Key);
61
}
62

The challenge here is straightforward: we have a door without a key, and we need to get one. If you go through the diff above, you realize that the Engraver NPC in the Fire Temple can give you a key if you guess his “Secret” correctly. Obviously we don’t know it. So how do we pull it off? You can corrupt the game state and leak the key by inputting an empty field when he asks for a name to engrave. Here is the result:

After this it’s literally just using the key and beating the mini-bosses that are located after the door.

Water-Temple

1
python3 2025/hackceler8/map_visualizer.py 2025/round_2/resources/maps/water-temple/water-temple.world
2
Octopus: 9
3
Siren: 4
4
HeartItem: 3
5
Boots: 2
6
Key: 2
7
DoorH: 3
8
Knife: 1
9
Goggles: 1
10
Spawn: 1
11
DuckNpc: 1

Key Diff:

1
        self.portal
2
            .save_to_persistent_storage(&[0x1234, 0x5678, 0x9ABC, 0xDEF0])
3
        if matches!(self.world.world_type, WorldType::BossTemple)
4
            || self.players.iter().all(|p| !p.is_active())
5
        {
6
            return;
7
        }
8

9
        let storage = &mut [0u16; 11];
10
        // Save current world and map.
11
        storage[0] = world_type_to_u16(self.world.world_type);
12
        storage[1] = self.world.current_position.0 as u16;
13
        storage[2] = self.world.current_position.1 as u16;
14
        // Save player positions on the map.
15
        for i in 0..4 {
16
            if self.players[i].is_active() {
17
                storage[3 + i * 2] = (self.players[i].x + 128) as u16;
18
                storage[4 + i * 2] = (self.players[i].y + 128) as u16;
19
            } else {
20
                // Magic value to indicate inactive players.
21
                storage[3 + i * 2] = 0xffff;
22
                storage[4 + i * 2] = 0xffff;
23
            }
24
        }
25
        self.portal.save_to_persistent_storage(storage)
26
     }
27

28
    fn load_persistent_state(portal: &TargetPortal) {
29
        let mut save_buf = [0; 4];
30
    /// Returns (starting_world, (map_x, map_y), [Option<player.start_x, player.start_y>]).
31
    fn load_persistent_state(
32
        portal: &TargetPortal,
33
    ) -> (WorldType, (i16, i16), [Option<(i16, i16)>; 4]) {
34
        let mut save_buf = [0; 11];
35
         portal.load_from_persistent_storage(&mut save_buf);
36
        info!("Loaded data from storage: {:?}", save_buf);
37

38
        let starting_world = u16_to_world_type(save_buf[0]).unwrap_or(WorldType::Overworld);
39
        if matches!(starting_world, WorldType::Overworld) {
40
            // Return default values as the state might not be initialized yet.
41
            return (starting_world, (1, 1), [Some((280, 177)), None, None, None]);
42
        }
43

44
        let map_x = save_buf[1] as i16;
45
        let map_y = save_buf[2] as i16;
46

47
        let mut player_pos = [None; 4];
48
        for i in 0..4 {
49
            if save_buf[3 + i * 2] != 0xffff {
50
                player_pos[i] = Some((
51
                    (save_buf[3 + i * 2] - 128) as i16,
52
                    (save_buf[4 + i * 2] - 128) as i16,
53
                ));
54
            }
55
        }
56

57
        (starting_world, (map_x, map_y), player_pos)
58
     }
59

60
     /// Check if the server is paused and block + display a loading text until it gets unpaused.
61
@@ -553,6 +604,29 @@ fn wait_for_server_init(vdp: &mut TargetVdp, portal: &mut TargetPortal) {
62
     State::clear_screen(vdp, &[Plane::A, Plane::B]);
63
 }
64

65
fn world_type_to_u16(world_type: WorldType) -> u16 {
66
    match world_type {
67
        WorldType::Overworld => 0,
68
        WorldType::FireTemple => 1,
69
        WorldType::WaterTemple => 2,
70
        WorldType::ForestTemple => 3,
71
        WorldType::SkyTemple => 4,
72
        WorldType::BossTemple => 5,
73
    }
74
}
75

76
fn u16_to_world_type(val: u16) -> Option<WorldType> {
77
    match val {
78
        0 => Some(WorldType::Overworld),
79
        1 => Some(WorldType::FireTemple),
80
        2 => Some(WorldType::WaterTemple),
81
        3 => Some(WorldType::ForestTemple),
82
        4 => Some(WorldType::SkyTemple),
83
        5 => Some(WorldType::BossTemple),
84
        _ => None,
85
    }
86
}
87

This code adds save states. You can reset the world using the hard reset button on the device; instead of going back to the very start, you revert the entire current “world”/temple. With this you can essentially double the number of keys you have access to in order to beat the Water Temple: go to the very top room. Water Temple key duplication exploit Here, you open the door. Have one person stand in front of the door and one behind. Wait 10 seconds for the current game state to save, then restart the system. One player will be able to access the key at the top of the room while the bottom key regenerates, allowing you to open the mini-boss room, which requires two keys.

Sky-Temple

Round 2 Sky Temple map

1
python3 2025/hackceler8/map_visualizer.py 2025/round_2/resources/maps/sky-temple/sky-temple.world
2
Angel: 7
3
Knife: 1
4
Key: 1
5
HeartItem: 7
6
Archer: 7
7
SnakeNpc: 1
8
Sword: 1
9
DoorV: 1
10
Spawn: 1
11
DoorH: 1

Key Diff:

1
            ItemType::Knife => {
2
                player.strength *= 2;
3
            }
4
             ItemType::Boots => {
5
                 player.speed += crate::player::SPEED_SCALE_FACTOR;
6
             }
7
@@ -147,9 +156,12 @@ impl InventoryItem {
8
     /// Remove the item's effects from a player it was previously applied to.
9
     pub fn remove_effect(&self, player: &mut Player) {
10
         match self.item_type {
11
            ItemType::Knife => {
12
                player.strength /= 2;
13
            }
14

15
--- a/game/src/projectile.rs
16
+++ b/game/src/projectile.rs
17
@@ -97,6 +97,16 @@ impl Projectile {
18
                         break;
19
                     }
20
                 }
21
                for enemy in &mut ctx.world.enemies {
22
                    if !enemy.is_alive() || enemy.id == projectile.shooter_id {
23
                        continue;
24
                    }
25
                    if projectile.hitbox().collides(&enemy.hitbox()) {
26
                        enemy.on_hit(push_dir, projectile.damage);
27
                        projectile.status = Status::Dead;
28
                        break;
29
                    }
30
                }

The exploit for this temple set a precedent going forward regarding multiplicative vs. additive bugs. The whole idea here is that your knife will 2x your damage and then 1/2 your damage, i.e. acting as a multiplicative increase in your weapon’s damage. In comparison, the sword is a +1/-1 toggle. What you can do here is equip the knife, then equip the sword so you are at (1*2)+1, and then remove the knife so you go from 3 to 1.5. Then you remove the sword and you go to 0 because the game rounds down. This then lets you abuse the second part of the patch shown above, which is that projectiles are now able to hit enemies. This allows you to move the archer in the same room to face the boss. Since you do no damage, you can keep hitting the enemy until he is facing or angled toward the boss. Sky Temple archer positioning So here the enemy would be facing the boss.

Forest-Temple

Round 2 Forest Temple map Ignore the invisible keys, that’s for later.

1
    python3 2025/hackceler8/map_visualizer.py 2025/round_2/resources/maps/forest-temple/forest-temple.world
2
    Goblin: 7
3
    Boots: 2
4
    RacoonNpc: 1
5
    Knife: 1
6
    Orc: 7
7
    HeartItem: 6
8
    Spawn: 1
9
    Key: 2
10
    Sword: 1
11
    DoorV: 1
12
    Switch: 1

Key Diff:

1
 /// NPCs are friendly entities on the map that the player can talk to.
2
 pub struct Npc {
3
     pub x: i16,
4
@@ -88,6 +99,7 @@ impl Npc {
5
                     {
6
                         continue;
7
                     }
8
+                    ctx.dialogue_player = p;
9
                     dialogue_id = Some(npc.dialogue_id);
10
                     // Face the player.
11
                     let center = hitbox.center();
12
@@ -181,6 +193,137 @@ fn bark_bark() -> Dialogue {
13
     Dialogue::new_no_response("BARK BARK!", None)
14
 }
15

16
+fn fashion_advice() -> Dialogue {
17
+    Dialogue::new_multiple_choice(
18
+        "Would you like to hear my expert opinion on which item you should wear?",
19
+        &["Yes", "No"],
20
+        Some(fashion_advice_2),
21
+    )
22
+}
23
+
24
+fn fashion_advice_2(ctx: &mut Ctx, response: &str) {
25
+    if eq(response, "No") {
26
+        return;
27
+    }
28
+
29
+    let fashion_id = get_random_wearable_id(ctx);
30
+    if fashion_id.is_none() {
31
+        ctx.start_dialogue(Dialogue::new_no_response(
32
+            "It doesn't look like you have anything to wear.",
33
+            None,
34
+        ));
35
+        return;
36
+    }
37
+    let fashion_id = fashion_id.unwrap();
38
+
39
+    // Unequip previous items and equip the fashionable one. Looking sharp!
40
+    for i in &mut ctx.world.inventory.items {
41
+        if i.worn_by == Some(ctx.dialogue_player) {
42
+            i.remove_effect(&mut ctx.players[ctx.dialogue_player]);
43
+            i.worn_by = None;
44
+        }
45
+    }
46
+    let fashion_item = &mut ctx.world.inventory.items[fashion_id];
47
+    fashion_item.apply_effect(&mut ctx.players[ctx.dialogue_player]);
48
+    fashion_item.worn_by = Some(ctx.dialogue_player);
49
+
50
+    let mut text: String<64> = String::new();
51
+    let _ = write!(
52
+        text,
53
+        "<{}> definitely looks best on you!",
54
+        fashion_item.display_name()
55
+    );
56
+    ctx.start_dialogue(Dialogue::new_no_response(&text, None))
57
+}
58
+
59
+fn get_random_wearable_id(ctx: &mut Ctx) -> Option<usize> {
60
+    let wearable_count = ctx
61
+        .world
62
+        .inventory
63
+        .items
64
+        .iter()
65
+        .filter(|i| InventoryItem::is_wearable(i.item_type))
66
+        .count();
67
+    if wearable_count == 0 {
68
+        return None;
69
+    }
70
+
71
+    let pos = ctx.portal.get_random_int() as usize % wearable_count;
72
+    let mut i = 0;
73
+    for item in &mut ctx.world.inventory.items {
74
+        if InventoryItem::is_wearable(item.item_type) {
75
+            if i == pos {
76
+                return Some(i);
77
+            }
78
+            i += 1;
79
+        }
80
+    }
81
+
82
+    None
83
+}

So the idea here is that we have an NPC that is able to equip and de-equip items from our character, and there is a physical wall stopping our character from moving to the next section where the boss is. In other words, we are going to need to perform some kind of wall clip in order to get to the mini-boss, and given the fact that we have an NPC who can add or remove items, we know that this is going to be a speed-related exploit. To put it simply, the way this actually works is pretty simple: we can use two characters to talk to the NPC and continually swap who actually has the “boots,” but when the NPC removes the boots from character A and moves them to character B, we don’t actually lose the speed buff since we don’t perform a proper de-equip, allowing you to infinitely stack the speed buff. This allows you to then directly clip through walls if you have enough speed, or glitch into the side of a wall in a transitional state and move through the walls until you reach the boss.

Round-3 (4 Flags For Boss)

Fire-Temple

1
python3 2025/hackceler8/map_visualizer.py 2025/round_3/resources/maps/fire-temple/fire-temple.world
2
Blob: 9
3
Flameboi: 9
4
CatNpc: 1
5
HeartItem: 7
6
Goggles: 2
7
Boots: 2
8
DoorH: 2
9
Key: 1
10
Sword: 1
11
Spawn: 1
12
Switch: 2

Key Diff:

The boss he had 31337 in health the only thing you had to to beat the boss is keep hitting him till you got him to a transition room and he will die. Boss apparently ends up dying on transition states.

Sky-Temple

1
python3 2025/hackceler8/map_visualizer.py 2025/round_3/resources/maps/sky-temple/sky-temple.world
2
Angel: 12
3
Boots: 1
4
HeartItem: 7
5
Archer: 6
6
SnakeNpc: 1
7
Sword: 1
8
Cloak: 1
9
DoorV: 1
10
Switch: 8
11
Spawn: 1

Key Diff:

1
diff -r hackceler8/game/src/enemy/mod.rs round_3/game/src/enemy/mod.rs
2
550c563
3
-             if !player.is_active() {
4
---
5
+             if !player.is_active() || player.is_cloaked {
6
diff -r hackceler8/game/src/inventory.rs round_3/game/src/inventory.rs
7
24c24,29
8
- const WEARABLE_ITEMS: &[ItemType] = &[ItemType::Boots, ItemType::Goggles, ItemType::Sword];
9
---
10
+ const WEARABLE_ITEMS: &[ItemType] = &[
11
+     ItemType::Boots,
12
+     ItemType::Goggles,
13
+     ItemType::Sword,
14
+     ItemType::Cloak,
15
+ ];
16
125a131
17
+             ItemType::Cloak => "Cloak",
18
142a149,151
19
+             ItemType::Cloak => {
20
+                 player.is_cloaked = true;
21
+             }
22
165a175,177
23
+             ItemType::Cloak => {
24
+                 player.is_cloaked = false;
25
+             }
26
229c241
27
-                     if players[player_id].is_alive() && input.just_pressed(Button::B) {
28
---
29
+                     if input.just_pressed(Button::B) {

How this works is fairly simple: you are given the cloak object here, which enables one of your characters to basically become invisible and remove enemy aggro. As such, you are going to want to get both the boots and cloak in the map and give them to one person. The first problem you are going to see is that to even get to the boss room you are going to need to spawn 4 players, which is then followed by a room with 3 very fast, high-damage, invulnerable enemies. The trick is to use the character with the boots and cloak to rush middle, and then decloak to retake enemy aggro. You can use pause buffering in order to make this easier. From there the basic idea is to keep one character at the top of the cross and keep cloaking and decloaking while sprinting with the bottom characters to get to the next room. After you reach the boss room it’s more or less the same idea; you can kill the minions, but you need to use the pressure plates/switches to actually kill the boss. Do the same thing where you mess around with boss aggro using the cloak.

Forest-Temple

1
    python3 hackceler8/map_visualizer.py round_3/resources/maps/water-temple/water-temple.world
2
    Octopus: 14
3
    Siren: 3
4
    HeartItem: 3
5
    Boots: 2
6
    Sword: 2
7
    Spawn: 1
8
    DuckNpc: 1
9
    DoorH: 1

Key Diff:

1
229c241
2

3
- if players[player_id].is_alive() && input.just_pressed(Button::B) {
4

5
---
6

7
+ if input.just_pressed(Button::B) {

The change is fairly simple and the exploit is also preaty easy to understand. When a player is now dying they can still change the menu and equip items. What this allows you as the player to do is die and and then equip the googles just in time to wall clip into the boss room. From there you just kill the boss, timing and character placement are required to pull this off.

Round-4 (4 Flags For Boss)

Fire-Temple

``` python3 hackceler8/map_visualizer.py round_4/resources/maps/fire-temple/fire-temple.world Blob: 8 CatNpc: 1 Key: 2 HeartItem: 6 Staff: 1 Flameboi: 11 DoorH: 2 Sword: 1 Spawn: 1 Goggles: 1 Switch: 2 ```

Key Diff:

1
diff -r hackceler8/game/src/inventory.rs round_4/game/src/inventory.rs
2
24c24,30
3
- const WEARABLE_ITEMS: &[ItemType] = &[ItemType::Boots, ItemType::Goggles, ItemType::Sword];
4
---
5
+ const WEARABLE_ITEMS: &[ItemType] = &[
6
+     ItemType::Boots,
7
+     ItemType::Goggles,
8
+     ItemType::Sword,
9
+     ItemType::Staff,
10
+     ItemType::Pencil,
11
+ ];
12
85a92,99
13
+     // Checks if there's at least one of the specified item type
14
+     // equipped by the specified player.
15
+     pub fn contains_equipped(&self, item_type: ItemType, player_id: usize) -> bool {
16
+         self.items
17
+             .iter()
18
+             .any(|i| i.item_type == item_type && i.worn_by == Some(player_id))
19
+     }
20
+
21
93a108,117
22
+
23
+     /// Remove the staff from the inventory and unequip it from players.
24
+     pub fn remove_staff(&mut self, players: &mut [Player]) {
25
+         for i in &mut self.items {
26
+             if i.item_type == ItemType::Staff {
27
+                 i.unequip(players);
28
+             }
29
+         }
30
+         self.items.retain(|i| i.item_type != ItemType::Staff);
31
+     }

The exploit/bug here is how the actual staff ends up working. It’s a single-use item that is supposed to disappear when it gets used. The real issue that exists in the code here, though, is the fact that it doesn’t actually leave your inventory until the staff animation ends. What this allows you to do is chain it to be reused by multiple players. This can then be used to help break through the ranged enemy wall of flame blobs. I will note that you don’t necessarily need to use this bug since, if you have all 4 characters and time it well, you can simply brute-force your way to the solve here by just having players behave as tanks.

Water-Temple

``` python3 hackceler8/map_visualizer.py round_4/resources/maps/water-temple/water-temple.world Octopus: 8 Siren: 5 DoorV: 1 HeartItem: 3 Boots: 2 Key: 2 Staff: 1 Goggles: 1 Spawn: 1 DuckNpc: 1 DoorH: 1 ```

Key Diff:

1
diff -r hackceler8/game/src/inventory.rs round_4/game/src/inventory.rs
2
24c24,30
3
- const WEARABLE_ITEMS: &[ItemType] = &[ItemType::Boots, ItemType::Goggles, ItemType::Sword];
4
---
5
+ const WEARABLE_ITEMS: &[ItemType] = &[
6
+     ItemType::Boots,
7
+     ItemType::Goggles,
8
+     ItemType::Sword,
9
+     ItemType::Staff,
10
+     ItemType::Pencil,
11
+ ];
12
85a92,99
13
+     // Checks if there's at least one of the specified item type
14
+     // equipped by the specified player.
15
+     pub fn contains_equipped(&self, item_type: ItemType, player_id: usize) -> bool {
16
+         self.items
17
+             .iter()
18
+             .any(|i| i.item_type == item_type && i.worn_by == Some(player_id))
19
+     }
20
+
21
93a108,117
22
+
23
+     /// Remove the staff from the inventory and unequip it from players.
24
+     pub fn remove_staff(&mut self, players: &mut [Player]) {
25
+         for i in &mut self.items {
26
+             if i.item_type == ItemType::Staff {
27
+                 i.unequip(players);
28
+             }
29
+         }
30
+         self.items.retain(|i| i.item_type != ItemType::Staff);
31
+     }

The idea here is you use the staff to kill the siren that is on the middle, since the staff can be used twice since it doesn’t leave your inventory till its animation ends you can take 2. This allows you to kill the siren fairly easily by having player 1 shot the staff then give it to player 2 and they then shot the staff all fairly trivial.

Sky-Temple

1
python3 hackceler8/map_visualizer.py round_4/resources/maps/sky-temple/sky-temple.world
2
Angel: 8
3
Goggles: 1
4
Key: 1
5
HeartItem: 7
6
Archer: 6
7
SnakeNpc: 1
8
Sword: 1
9
DoorV: 1
10
Spawn: 1

Key Diff:

1
diff -r hackceler8/game/src/projectile.rs round_4/game/src/projectile.rs
2
22d21
3
- use crate::map;
4
27a27,28
5
+ /// Special shooter ID that indicates this was fired by a player.
6
+ pub const PLAYER_SHOOTER_ID: u16 = 1337;
7
90,91c91,116
8
-                 for player in &mut ctx.players {
9
-                     if !player.is_active() {
10
---
11
+                 if projectile.shooter_id == PLAYER_SHOOTER_ID {
12
+                     // Shot by player, damages enemies
13
+                     for enemy in &mut ctx.world.enemies {
14
+                         if !enemy.is_alive() {
15
+                             continue;
16
+                         }
17
+                         if projectile.hitbox().collides(&enemy.hitbox()) {
18
+                             enemy.on_hit(push_dir, projectile.damage);
19
+                             projectile.status = Status::Dead;
20
+                             break;
21
+                         }
22
+                     }
23
+                 } else {
24
+                     for player in &mut ctx.players {
25
+                         if !player.is_active() {
26
+                             continue;
27
+                         }
28
+                         if projectile.hitbox().collides(&player.hitbox()) {
29
+                             player.on_hit(push_dir, projectile.damage);
30
+                             projectile.status = Status::Dead;
31
+                             break;
32
+                         }
33
+                     }
34
+                 }
35
+                 for enemy in &mut ctx.world.enemies {
36
+                     if !enemy.is_alive() || enemy.id == projectile.shooter_id {
37
94,95c119,120
38
-                     if projectile.hitbox().collides(&player.hitbox()) {
39
-                         player.on_hit(push_dir, projectile.damage);
40
---
41
+                     if projectile.hitbox().collides(&enemy.hitbox()) {
42
+                         enemy.on_hit(push_dir, projectile.damage);
43
104c129,132
44
-                         || map::off_screen(projectile.x, projectile.y)
45
---
46
+                         || projectile.x - 100
47
+                         || projectile.x + 460
48
+                         || projectile.y - 100
49
+                         || projectile.y + 370

This map was pretty simple - basically, you can clip the arrow from the enemy on the left here. If you time it correctly, the arrow will move from the first map to the second one. I don’t fully remember what the timing requirements were, but there was a pretty straightforward trick that you can figure out after trying it for a few minutes. Sky Temple arrow clipping exploit

Forest-Temple

1
python3 hackceler8/map_visualizer.py round_4/resources/maps/forest-temple/forest-temple.world
2
Goblin: 9
3
Boots: 1
4
RacoonNpc: 1
5
Goggles: 1
6
Orc: 9
7
HeartItem: 6
8
Spawn: 1
9
Key: 2
10
Sword: 1
11
DoorH: 1
12
DoorV: 1
13
Switch: 2
14
Staff: 1

Key Diff:

1
diff -r hackceler8/game/src/enemy/mod.rs round_4/game/src/enemy/mod.rs
2
50a51,55
3
+ // Slowdown happens every 1s for 1s.
4
+ pub const SLOWDOWN_FREQUENCY: u16 = 50;
5
+ // Players are slow down to 1/4 of normal speed
6
+ pub const SLOWDOWN_RATE: i16 = 4;
7
+
8
73a79,80
9
+     pub slows_down: bool,
10
+     pub shoots_down: bool,
11
110a118,119
12
+     slows_down: bool,
13
+     shoots_down: bool,
14
124a134
15
+     SlowingDown,
16
172a183,184
17
+             slows_down: properties.slows_down,
18
+             shoots_down: properties.shoots_down,
19
270c282,284
20
-                     if enemy.stats.shoots && ctx.frame % shooter::SHOOT_FREQUENCY == 0 {
21
---
22
+                     if enemy.stats.shoots
23
+                         && (enemy.shoots_down || ctx.frame % shooter::SHOOT_FREQUENCY == 0)
24
+                     {
25
281a296,306
26
+
27
+                     if enemy.slows_down && ctx.frame % SLOWDOWN_FREQUENCY == 0 {
28
+                         for p in 0..ctx.players.len() {
29
+                             let player = &mut ctx.players[p];
30
+                             if !player.is_active() {
31
+                                 continue;
32
+                             }
33
+                             player.speed /= SLOWDOWN_RATE;
34
+                         }
35
+                         enemy.status = Status::SlowingDown;
36
+                     }
37
290a316,320
38
+                     let (dx, dy) = if enemy.shoots_down {
39
+                         (0, 100)
40
+                     } else {
41
+                         (player.x - enemy.x, player.y - enemy.y)
42
+                     };
43
295,296c325,326
44
-                         player.x - enemy.x,
45
-                         player.y - enemy.y,
46
---
47
+                         dx,
48
+                         dy,
49
315a346,357
50
+             }
51
+             Status::SlowingDown =+ {
52
+                 if ctx.frame % SLOWDOWN_FREQUENCY == 0 {
53
+                     for p in 0..ctx.players.len() {
54
+                         let player = &mut ctx.players[p];
55
+                         if !player.is_active() {
56
+                             continue;
57
+                         }
58
+                         player.speed *= SLOWDOWN_RATE;
59
+                     }
60
+                     enemy.status = Status::Idle;
61
+                 }

The way this bug works is rather simple: we have certain enemies that actually slow down the character by 4x, but after a second it will result in speed of 4x. What you can actually do is fairly simple - instead of just doing nothing, you equip the boots during the slowdown. This allows you to increase your speed by +1, so when the 4x hits, the equation changes from (x * 0.25) * 4 to ((x * 0.25) + 1) * 4. If you keep using this exploit, you can get your speed high enough that you are able to clip through the wall and get to the boss room. Note that it’s important to make sure you save an account for spawning into the boss room just in case you clip into a weird section of the map.

Round-5 (4 Flags For Boss)

Fire-Temple

1
python3 hackceler8/map_visualizer.py round_5/resources/maps/fire-temple/fire-temple.world
2
Blob: 10
3
Flameboi: 8
4
CatNpc: 1
5
HeartItem: 6
6
Goggles: 2
7
DoorH: 2
8
Key: 1
9
Sword: 1
10
Spawn: 1
11
Switch: 6

Key Diff:

1
 diff -r hackceler8/game/src/switch.rs round_5/game/src/switch.rs
2
17a18
3
+ use crate::enemy::EnemyProperties;
4
19a21
5
+ use crate::res::enemies::EnemyType;
6
21a24,25
7
+ use crate::walk::*;
8
+ use crate::Enemy;
9
26a31
10
+     spawn_enemies,  // 2
11
159a165,212
12
+     }
13
+ }
14
+
15
+ const SPAWNED_ENEMY_WALK_DATA: &[WalkData] = &[
16
+     WalkData {
17
+         cmd: Cmd::Right,
18
+         dur: 200,
19
+     },
20
+     WalkData {
21
+         cmd: Cmd::Left,
22
+         dur: 200,
23
+     },
24
+ ];
25
+ const SPAWNED_ENEMY_PROPS: &EnemyProperties = &EnemyProperties {
26
+     walk_data: SPAWNED_ENEMY_WALK_DATA,
27
+     speed: None,
28
+     health: None,
29
+     strength: Some(0),
30
+     invulnerable: false,
31
+     flags: None,
32
+ };
33
+ fn spawn_enemies(ctx: &mut Ctx) {
34
+     if !ctx.players[0].is_active() || ctx.world.enemies.len() >= 28 {
35
+         return;
36
+     }
37
+
38
+     for (dx, dy) in [(16, -8), (16, 8)] {
39
+         let player_center = ctx.players[0].hitbox().center();
40
+         let enemy = Enemy::new(
41
+             EnemyType::Flameboi,
42
+             player_center.0 + dx - 128,
43
+             player_center.1 + dy - 128,
44
+             /*id=*/ 1337,
45
+             &SPAWNED_ENEMY_PROPS,
46
+             &mut ctx.res_state,
47
+             &mut ctx.vdp,
48
+         );
49
+         ctx.world
50
+             .enemies
51
+             .push(enemy)
52
+             .unwrap_or_else(|_| panic!("too many enemies"));
53
+     }
54
+
55
+     for switch_id in 0..ctx.world.switches.len() {
56
+         let switch = &mut ctx.world.switches[switch_id];
57
+         switch.move_relative(0, if switch.y % 16 == 0 { -17 } else { 17 });
58
+         ctx.world.switches_completed.clear(switch.id);

If you have all 4 characters stand on the switches it will create enemies that do like 0 damage, you can then us them to go into the boss room. The large number of enemies will greatly slow down the enemy slimes that are moving in a pattern till you finally reach the boss. It is possible to solve this without any help/slowing down the enemies as well but they definitely help. Note that the enemies spawn on your first player so make sure they are right next to the boss room to make it easier. The enemies will struggle to properly go to the next area you want to wait till they are half way to the next section so you wait till you can move to the next zone.

Water-Temple

Water Temple maze solution 1 Water Temple maze solution 2 Water Temple maze solution 3 There is a maze, you build the maze, solve the maze, follow the path !

Sky-Temple

1
python3 hackceler8/map_visualizer.py round_5/resources/maps/sky-temple/sky-temple.world
2
Goggles: 1
3
Key: 1
4
HeartItem: 6
5
Archer: 5
6
Angel: 4
7
SnakeNpc: 1
8
Sword: 1
9
DoorV: 1
10
Spawn: 1
11
DoorH: 1

Key Diff:

1
diff -r hackceler8/game/src/game.rs round_5/game/src/game.rs
2
500,502c508,530
3
-     fn save_persistent_state(&mut self) {
4
-         self.portal
5
-             .save_to_persistent_storage(&[0x1234, 0x5678, 0x9ABC, 0xDEF0])
6
---
7
+     pub fn save_persistent_state(&mut self) {
8
+         const SAVE_BUF_LEN: usize = crate::inventory::MAX_ITEMS + 1;
9
+         let mut save_buf = [0; SAVE_BUF_LEN];
10
+
11
+         let inventory_len = self.world.inventory.items.len();
12
+         if !matches!(self.world.world_type, WorldType::Overworld)
13
+             && !matches!(self.world.world_type, WorldType::ForestTemple)
14
+         {
15
+             let items_to_save = self
16
+                 .world
17
+                 .inventory
18
+                 .items
19
+                 .iter()
20
+                 .skip(inventory_len.saturating_sub(crate::inventory::MAX_ITEMS));
21

22
+             for (i, item) in items_to_save.enumerate() {
23
+                 let item_type_bits = item_type_to_u16(item.item_type);
24
+                 let amount_bits = item.amount & 0x1FFF;
25
+                 save_buf[i] = (item_type_bits << 13) | amount_bits;
26
+             }
27
+         }
28
+         save_buf[crate::inventory::MAX_ITEMS] = world_type_to_u16(self.world.world_type);
29
+         self.portal.save_to_persistent_storage(&save_buf);
30
505,506c533,537
31
-     fn load_persistent_state(portal: &TargetPortal) {
32
-         let mut save_buf = [0; 4];
33
---
34
+     fn load_persistent_state(
35
+         portal: &TargetPortal,
36
+     ) -> (WorldType, [u16; crate::inventory::MAX_ITEMS]) {
37
+         const SAVE_BUF_LEN: usize = crate::inventory::MAX_ITEMS + 1;
38
+         let mut save_buf = [0; SAVE_BUF_LEN];
39
508a540,547
40

41
+         u16_to_world_type(save_buf[crate::inventory::MAX_ITEMS])
42
+             .map(|world_type| {
43
+                 let inventory_data: [u16; crate::inventory::MAX_ITEMS] =
44
+                     save_buf[..crate::inventory::MAX_ITEMS].try_into().unwrap();
45
+                 (world_type, inventory_data)
46
+             })
47
+             .unwrap_or((WorldType::Overworld, [0; crate::inventory::MAX_ITEMS]))
48
510a550,564
49
+     fn load_inventory_data(&mut self, inventory_data: &[u16; crate::inventory::MAX_ITEMS]) {
50
+         for &item_data in inventory_data {
51
+             if item_data == 0 {
52
+                 continue;
53
+             }
54
+             let item_type_bits = item_data >> 13;
55
+             let amount = item_data & 0x1FFF;
56
+             if let Some(item_type) = u16_to_item_type(item_type_bits) {
57
+                 for _ in 0..amount {
58
+                     self.world.inventory.add(item_type);
59
+                 }
60
+             }
61
+         }
62
+     }
63
+
64
553a608,653
65
+ }
66
+
67
+ fn item_type_to_u16(item_type: ItemType) -> u16 {
68
+     match item_type {
69
+         ItemType::Boots => 0,
70
+         ItemType::Goggles => 1,
71
+         ItemType::HeartItem => 2,
72
+         ItemType::Key => 3,
73
+         ItemType::Sword => 4,
74
+         ItemType::InvisibleKey => 5,
75
+     }
76
+ }
77
+
78
+ fn u16_to_item_type(val: u16) -> Option<ItemType> {
79
+     match val {
80
+         0 => Some(ItemType::Boots),
81
+         1 => Some(ItemType::Goggles),
82
+         2 => Some(ItemType::HeartItem),
83
+         3 => Some(ItemType::Key),
84
+         4 => Some(ItemType::Sword),
85
+         5 => Some(ItemType::InvisibleKey),
86
+         _ => None,
87
+     }
88
+ }
89
+
90
+ fn world_type_to_u16(world_type: WorldType) -> u16 {
91
+     match world_type {
92
+         WorldType::Overworld => 0,
93
+         WorldType::FireTemple => 1,
94
+         WorldType::WaterTemple => 2,
95
+         WorldType::ForestTemple => 3,
96
+         WorldType::SkyTemple => 4,
97
+         WorldType::BossTemple => 5,
98
+     }
99
+ }
100
+
101
+ fn u16_to_world_type(val: u16) -> Option<WorldType> {
102
+     match val {
103
+         0 => Some(WorldType::Overworld),
104
+         1 => Some(WorldType::FireTemple),
105
+         2 => Some(WorldType::WaterTemple),
106
+         3 => Some(WorldType::ForestTemple),
107
+         4 => Some(WorldType::SkyTemple),
108
+         5 => Some(WorldType::BossTemple),
109
+         _ => None,
110
+     }

The patch here ends up adding a custom state saving system which will keep your world state whenever you hard rest the game using the physical restart button. It will keep the items in your inventory while also restarting the world which will result in the ability to open the first door, restart then open the second door.

Forest-Temple

1
python3 hackceler8/map_visualizer.py round_5/resources/maps/forest-temple/forest-temple.world
2
Goblin: 9
3
Boots: 3
4
RacoonNpc: 1
5
Goggles: 2
6
Orc: 9
7
HeartItem: 6
8
Spawn: 1
9
Sword: 1
10
DoorV: 2
11
Switch: 2

Key Diff:

1
diff -r hackceler8/game/src/inventory.rs round_5/game/src/inventory.rs
2
22c22
3
- const MAX_ITEMS: usize = 16;
4
---
5
+ pub const MAX_ITEMS: usize = 16;
6
126a127
7
+             ItemType::InvisibleKey => "Key",
8

9
diff -r hackceler8/game/src/player.rs round_5/game/src/player.rs
10
315a316,327
11
+                                 break;
12
+                             }
13
+                         }
14
+                     }
15
+                     if input.just_pressed(Button::B) && inventory.contains(ItemType::InvisibleKey) {
16
+                         // Open a nearby door.
17
+                         let interaction_hitbox = player.hitbox().expand(5);
18
+                         for door in doors.iter_mut() {
19
+                             if !door.open && interaction_hitbox.collides(&door.hitbox()) {
20
+                                 door.open();
21
+                                 doors_opened.set(door.id);
22
+                                 inventory.remove(ItemType::InvisibleKey);

The patch here ends up adding invisible keys, they are dynamically loaded by the actual rust code base so they aren’t going to be in the actual Tile Map, as such I needed to hard code the location values not the my python generation script. The location isn’t really hidden or obfuscated in any manner, they are both right next to other objects. The weird part about this round though is you need to be holding nothing when you try and pick up the keys. For some reason when you pick up any other item it would make the keys impossible to pick up, but besides that it was fairly easy.

Blog / Non-Technical

That was a lot of technical nonsense. Overall, I really liked the game and had quite a bit of fun playing it and doing all of this. I would absolutely do it again, and hopefully can next year. But beyond that, let me explain how the actual onsite went and all the random things we did.

Day 1

The first day was supposed to be the day before the actual competition started, when everyone on our team would get there and hopefully we’d do some level of prep. In reality, it turned out to be just 3 of us because one of our players, cough cough Braydenfreakchu, ended up getting totally screwed by flights, and we didn’t actually see him until the end of the next day, after all the technical stuff for the first round happened.

Anyway, setting that aside, I had lots of really good food from the get-go. The basic structure of the entire day was just me landing -> eating lunch -> doing some work + getting my room + waiting for teammates -> going to dinner -> more work. Honestly, it was a pretty chill day, but you still get to see the food we ate.

Day 2

I slept pretty early and woke up around 3—4 AM, then started practicing and getting decent at the game. I had looked at it a bit before, but most of my progress came during the competition itself. I tried to find some bugs and issues in the codebase --- and found some funny ones that I didn’t think would ever trigger. One of them was a bug where you could crash the game if you were too close to the projectiles, causing one of the internal values to become 0 and trigger a Rust panic. Surprisingly, we actually managed to trigger it once by accident. Anyway, the hotel provided breakfast --- it was a really nice buffet, to be honest.

After eating, we walked down to the venue, which was only about five minutes away from the hotel --- pretty convenient. The actual building had this cool orange Hispanic tone; I believe it was a wedding or event space, so it looked really nice. Inside, the entire venue felt like a gaming competition --- smoke machines, LED lights, electronic music, gaming chairs, and of course, energy drinks!

The first day had a total of three rounds, running from about 9:30 AM to 4 PM. Each round lasted an hour and a half, with breaks in between. During that time, we were trying to find someone to fill in for our missing fifth teammate. Even if they didn’t help with the technical parts of the competition, it would’ve been nice to just have a physical section player in order to be able to do all the challenges properly. Sadly, that didn’t happen.

The first round went alright, but we ended up being unable to get one of the wall-clip challenges and finished near the bottom of the leaderboard. Speed-wise we were doing alright, but it was still a total struggle. I think from here onward every other team just started to get the game more and more, and speed really started to make a difference.

Anyway, after a short coffee break, we did round two, which went pretty badly, honestly. We missed a lot of the bugs to start off with. That being said, our teammate ended up falling in his chair and had some sort of divine intervention, which apparently resulted in him figuring out the answers (Clovis moment).

From there we had the final round, which went alright. There was a section that required 4 people, which we somehow managed to do by using a lot of frame buffering/pausing. The round was alright, but we still didn’t do great. We spent the rest of the day just working after ending up meeting back up with Brayden. I spent a good chunk of the night making the hack client, as well as playing through the rounds for that day with Brayden as practice. Clovis and Contron were doing their own thing, and we also managed to order like 50 tacos for around 20 bucks, easily one of the best purchases of the trip.

Here are some cool photos from the venue: Competition venue breakfast Breakfast Competition venue floor The actual floor Competition venue exterior The outside 300x400 Our team logo

Team logo

Single best part of the competition Team logo The actual workstation

Day 3

This weekend we had two rounds. From there, we basically woke up and did the same thing as before, same breakfast and all. The round lineup was SLICES (us), the THC merger, FMC, and Kalmarunion. During the first round, we ended up missing the spot for the next round by just about 30 seconds, which was pretty heartbreaking, but it is what it is. After that, three of us stayed to do the next round, which we managed to fully beat, but it was too little, too late. Overall, though, I had a lot of fun at the competition, and I think we can do well next year.

Now it was time for travel photos. After the rounds ended, it was around midday. Luckily for us, Google booked the hotels in an excellent spot; there were tons of monuments, art museums, and just an overall really nice area. Brayden and I decided to start side-questing around Mexico City, so here are some travel photos:

Team member Corgo

ITS CORGO!!! (For those of you who don’t know Corgo, he is our pwn/web goat and has the dog avatar.)

Day 4

Brayden and I went on a side quest again and went on a hot air balloon tour early in the morning, and then went to the finals venue:

Kalmarunion victory celebration Photo right after Kalmarunion won!

Final Remarks

Had a great time. My teammates are all amazing, and it was great to spend time with them. Hopefully we can win next year.