>>715785116
I gotchu senpai
In video game programming, when the player goes through a linear sequence of events, conditions, or cases, you want a solution that is scalable, readable, and maintainable.
General Strategies
1. Finite State Machine (FSM)
Best for: Clearly distinct states (e.g. tutorials, game phases, mission steps)
Use a state enum or string identifier to represent each step.
Transition to the next state based on input or conditions.
```python
class GameState(Enum):
START = auto()
INTRO_DIALOGUE = auto()
MOVE_TUTORIAL = auto()
BATTLE_TUTORIAL = auto()
END = auto()
def update_game(state):
if state == GameState.START:
play_intro()
return GameState.INTRO_DIALOGUE
elif state == GameState.INTRO_DIALOGUE:
show_dialogue("Welcome!")
return GameState.MOVE_TUTORIAL
# ...
```
2. List or Queue of Callable Functions
Best for: Linear sequences of logic (like story events or scripted actions)
Store each case as a function, and call them one after the other.
```python
events = [show_intro, move_tutorial, battle_tutorial, end_scene]
current_event = 0
def next_event():
global current_event
events[current_event]()
current_event += 1
```
3. Script/Data-Driven Approach
Best for: Narrative/dialogue-heavy or highly linear gameplay
Define each "case" as data (JSON, YAML, etc.) and interpret it at runtime.
```json
[
{ "type": "dialogue", "text": "Welcome!" },
{ "type": "move", "target": "x:10,y:5" },
{ "type": "wait", "duration": 2 },
{ "type": "battle", "enemy": "Slime" }
]
```
This lets writers or designers update the flow without touching code.
4. Coroutines / Generators
Best for: Step-by-step sequences that might need pausing (e.g. cutscenes)
```python
def tutorial_sequence():
yield show_dialogue("Welcome!")
yield wait_for_input()
yield play_animation("jump")
```
