Finite State Machines
Personal Project
The Need This Code Fulfills
Game logic can get messy when different behaviors need to change based on the situation. Without structure, code can become hard to manage, with lots of confusing conditions and bugs. A finite state machine solves this by organizing behaviors into clear states, each with its own rules, and only allowing controlled transitions between them. This makes game logic easier to read, debug, and expand, which is why it's often used for AI, UI, and player movement.
Game State Management
Game States Using Interfaces
I built a finite state machine system to handle game states. Game states are implemented as interfaces, which define a common set of methods that any game state must implement. The IGameState interface includes three main methods: EnterState, UpdateState, and ExitState. These methods allow each state to perform specific actions when it begins, such as loading resources, updates during gameplay, such as handling input or logic, and when it exits, such as cleaning up or saving data.
The use of an interface ensures that every game state follows a consistent structure, making it easier to manage transitions between different states. In this example, a LoadingState will handle scene loading asynchronously, while a GameplayState manages the actual gameplay logic. States like MainMenuState, PauseState, and GameOverState each define their unique behavior but all adhere to the same interface, promoting flexibility and maintainability in the game's state management system. This same system structure could be used for features such as AI, combat, animation, progression, or any other state driven systems.
Game State Manager
The GameStateManager class is responsible for controlling the game's flow between different states, such as the main menu, gameplay, and loading screens. It uses a stack to keep track of the current and previous game states, allowing for smooth transitions between them. The manager ensures that states change only if they are allowed, based on predefined transitions between them, such as from the main menu to the loading screen, and then to the gameplay scene. It also fires events, such as OnSceneChange, to notify other systems like UI about changes, such as when a new scene is about to be loaded. The ChangeState method is used to transition between states, while PushState and PopState allow for more complex state transitions, such as pausing the game or going back to a previous state.
Loading Screens & UI Implementation
The loading screen in this game state system is implemented using asynchronous scene loading with Unity's AsyncOperation, allowing the game to load scenes in the background while updating the loading progress. The updating of UI elements is triggered by having UI scripts subscribe to events handled by the UIManager. The advantage here is the decoupling of UI logic from the game state system using events. The LoadingState triggers an OnLoadingProgress event, which the UIManager subscribes to in order to update loading elements, like a progress bar, without the game state needing to know about the UI. This event-driven approach keeps the game logic and UI modular, allowing for easy updates and maintaining separation between them.