All Classes and Interfaces

An interface that defines one function that alerts the user of something
AlertBox is a component that creates a new window and display a users a message.
Effectively, the main class that sets up the clean architecture mountain group 105 game!
Battle is a class which contains information about the status of a combat encounter, the participating characters, and the order in which they would move, along with a number of upgrade tokens upon victory.
BattleCharacter is a class which contains the stats and other battle related information corresponding to a specific character.
A struct like class that represents a BattleCharacter
This class interacts with the Battle entity.
This class uses JavaFX and is displayed during an active battle.
This interface should be implemented by BattleMenu.
Class communicating between BattleMenuInterface view and BattleInteractor.
This interface should be implemented by BattlePresenter.
Move the player within a room.
An interface that represents a class that moves a character.
A class that interacts with TreasureChests.
Consumable is an interface that should only be implemented by items that can be use on a character
This interface is meant for all classes that create some sort of data storage system
Constants used for data persistence.
This class should be extended for aspect of the game's state that need to have storage systems created Really the only reason for this class is get rid of the duplicate code warnings (the CreateDataStorage) interface is really enough for OOP
This is a class that uses other class to create the data persistence or data storage system of this game.
A Doorway represents a single-direction connection from one room to another.
A class that represents the state of the game
This class should only be called in the "main" file.
Data for what actions player has completed, contains methods for mutating the data
A health potion is an item that can be used to heal a character by a certain amount of points.
InputInterpreter takes in keyboard inputs and distributes them to their appropriate use cases.
InputListener takes keyboard inputs and passes them on to an appropriate interpreter.
An inventory is a class that manages items
A class that serves the UI and allows users to make the desired changes to the Inventory
A user interface class that displays the state of the inventory to the user and allows them to perform actions that relate to the inventory and its items.
This class is the only class that should directly interact with the inventory
This interface defines the input structure to make calls that change the state of the inventory
A class whose purpose is to update the view with the current state of the inventory and update it based on a user's actions
This interface should be implemented by the InventoryPresenter class
The interface defines all the functions that should be called to update the ui to add or modify the information of the Inventory
An item represents something that can be used in some manner to change something about the game environment
A class containing the constants for items in the game.
This is a struct like class whose sole purpose is to represent the state of a particular item in the inventory
This class's sole responsibility is to create new items.
Our 'main' class.
LoseMenu is displayed when the player loses the game.
The main game menu.
Constants used in the map and map generation.
MapDrawer draws the map as a grid of tiles.
MapGenerator generates the map
MapGeneratorButton acts as the event handler for the actual JavaFX button that will generate a map.
Something that generates the map.
MapGeneratorInterpreter asks as a thin interface adapter whose sole purpose is to maintain clean architecture.
An interface for map generation.
A mega health potion is larger health potion that can be used to heal a character by a greater number of points.
Draw the Minimap.
The MinimapInterpreter processes room change data an interprets its implicit position.
A class that handles the interpretation of the minimaps internal state.
Possible knowledge states of a room.
Move is a class which contains the combat properties and name of a specific move used by a specific character.
Constants pertaining to the names of moves.
This is a class mean to interact and get information about moves from a "database"
This class is responsible for creating the storage system pertaining to move data
A struct like class that represents the details of a move
OpponentConstant contains constants that pertain to the names of opponents.
OpponentSet stores a potential battle on a map.
An interactor class that modifies and references GameState with methods relating to OpponentSet.
Constants pertaining to the party (the player's characters).
This class should be called once when the game is first starting.
PartyDataAccess implements the data access layer.
This class is responsibility is to create the data storage system pertain to the party (specifically) each party member's battle attributes
This interface is implemented by a class that has the ability to save party members stats and retrieve the parties data
This classes only job is to save data about the party in some sort of "database"
Class for determining what phase of the tutorial the player is on, and changing the phase
A comparator for calculating distances between Points.
A class that implement the game restart and replay function.
ReplayGeneratorButton acts as the event handler for the actual JavaFx button that will replay the game.
ReplayGenerator asks as a thin interface adapter whose sole purpose is to maintain clean architecture.
A use case that needs to be reset when the game restarts (regardless of win or loss).
Room represents a single room in the map.
RoomGetter is responsible for getting the state current room.
Get attributes about the current room.
RoomInterpreter interprets the current room in a format that is easier to draw from.
Layout the current room.
The layout of a room.
Types of tiles that can appear within a room.
RoomUpdater updates any components that need updating when the state of the current room changes.
RoomUpdaterInterface is the smallest possible interface to be used by anything that changes anything relating to the current map.
Class that implement this interface are ones that save some sort of data about the state of a game to the "database"
This classes only job is to save data about the state of the game in some sort of "database" This class is the Facade class that uses others savers to save info about the game
SceneController acts as the central coordination mechanism for the user interface.
Constants used in the persistence of character stats.
This interface is for classes that help set information in GameState when a game has first started
A user interface component that can be toggled on or off depending on its visibility.
An interface for an object that can toggle the visibility of various user interface components.
All the possible components that could theoretically be toggled.
TreasureChest is a class representing the treasure chests in the game.
A controller that converts phase number into displayed text
Returns the actual text that is displayed to the player
Constants for texts related to the tutorial
Create a window for the tutorial scenes
An item that is used upgrade a characters stat
Information about the player being placed on the map.
This class uses JavaFX and is displayed when the user wants to change the walking character sprite.
This class communicates with WalkVisInteractor, called on by WalkingMenu.
This class interacts with the WalkingCharacter entity.
Decides when to show game win screen
A menu that is shown to the player after they have reached the final room