In Beat Sequence, players solve room puzzles by changing the order of events before the music plays them. Each action lands on a beat and changes the room: raise a bridge, release a latch or lock it. The goal is to find an order that leaves the exit open on the final beat, then perform the sequence in time. Reordering changes the puzzle state, not the song tempo.
Make event order part of the puzzle

Start with a short sequence of three events and one visible exit condition. Let players rearrange the tiles before playback, then preview how each beat changes the room. Keep the beat spacing fixed so the puzzle is about order rather than tempo. A safe reset should return both the event row and room state to the same starting point.
| Event | Room change | Puzzle use |
|---|---|---|
| Raise | Lifts the bridge | Creates a crossing path |
| Release | Opens the latch | Clears a gate condition |
| Lock | Holds the latch closed | Preserves the raised bridge |
Show the current event order and the state after each beat. This helps players reason about sequences before they commit to a performance. Missed inputs should affect the performance result, not silently rearrange the planned events.
Separate planning from performance
Players first solve the state puzzle by arranging event tiles. Once the final state opens the exit, they perform those events to the beat. If an input is missed, show the timing error and allow a retry without changing the sequence. This keeps two skills distinct: discovering a valid order and executing it accurately.

Keep visual room changes synchronized with the beat markers. Use short, distinct sounds for each event and make the final exit condition visible. Avoid adding tempo changes in the first puzzle; they would make it harder to tell whether a failed attempt came from event order or timing.
Replay the event-order iteration
The deterministic local state replay compares two three-event sequences. `Raise -> Lock -> Release` lifts the bridge but leaves the latch open, so it fails the exit condition. Rearranging the last two events to `Raise -> Release -> Lock` leaves the bridge raised and the latch closed, opening the route. Both orders use the same beat times. This checks order and final state, not timing feel or audio synchronization.
| Sequence | Final bridge | Final latch | Exit |
|---|---|---|---|
| Raise -> Lock -> Release | Raised | Open | Closed |
| Raise -> Release -> Lock | Raised | Locked | Open |

In a playable build, test input latency, beat feedback and whether players understand the room state after a missed note. Keep audio and animation aligned and tune the timing window after observing retries. The local replay does not test performance feel.
Start with one room and three events
Ask an AI game maker for a small rhythm puzzle with a bridge, latch, exit and three reorderable event tiles. Let players plan the order, preview the room changes, then perform the sequence on a fixed beat grid. Add longer patterns or changing tempo after the basic order puzzle is easy to understand.
Create Beat Sequence, a rhythm-puzzle prototype where players rearrange beat-synced events to solve a room. Add three events: Raise, Release and Lock. Raise lifts a bridge, Release opens a latch, and Lock closes it. The exit opens only when the bridge is raised and the latch is locked after the final beat. Let players preview and reorder events before playback. Keep beat spacing fixed, show each state change and allow a safe retry after missed inputs without changing the planned order.
Start a rhythm-game prototype in SEELE
Frequently asked questions
How can event order solve a rhythm-game puzzle?
Make each beat trigger a visible room change, then ask players to arrange the events so the final state meets the goal. The puzzle comes from the order of actions, while rhythm performance determines whether the planned sequence is executed accurately.
Should changing the event order also change the music tempo?
Keep tempo fixed in the first puzzle so players can isolate the order rule. If tempo changes too, a failed attempt may be hard to diagnose. Add tempo variation later, after the event sequence and beat feedback are already easy to follow.
What should I test in an event-reordering rhythm prototype?
Replay fixed sequences and verify every beat transition and final room state. Then test missed inputs, retries, animation timing and audio latency in a playable build. A local state replay verifies order logic, not whether the timing window feels fair.


