| hoa_audio::GameAudio | A singleton class for managing and interfacing with audio data |
| hoa_audio::MusicDescriptor | |
| hoa_audio::private_audio::MusicData | An internal class used to manage music data information |
| hoa_audio::private_audio::SoundData | An internal class used to manage sound data information |
| hoa_audio::SoundDescriptor | Manages sound data loaded from memory |
| hoa_battle::AscendingYSort | |
| hoa_battle::BattleMode | Manages all objects, events, and scenes that occur in a battle |
| hoa_battle::private_battle::ActionWindow | Represents the battle window where the player selects actions to execute |
| hoa_battle::private_battle::BattleActor | This is an interface class for all the battle actors (eg. the player and the monsters) |
| hoa_battle::private_battle::BattleActorEffect | Temporary enum used to determine which phase of the time meter a character/enemy is in. Represents postive and negative afflictions that affect actors in battle |
| hoa_battle::private_battle::BattleCharacterActor | Represents the player-controlled character in the battle |
| hoa_battle::private_battle::BattleEnemyActor | Represents the entity for an enemy in the battle |
| hoa_battle::private_battle::FinishWindow | The window displayed once a battle has either been won or lost |
| hoa_battle::private_battle::ScriptEvent | Representation of a single, scripted action to be executed in battle |
| hoa_boot::BootMenu | The BootMenu-class will help in creation of the boot-menu. All of the boot-menu functions are given via function pointers to the class |
| hoa_boot::BootMode | Handles everything that needs to be done on the game's boot screen |
| hoa_boot::CreditsScreen | Provides for everything that is needed for displaying the game credits |
| hoa_boot::WelcomeScreen | Provides for everything that is needed for displaying the game welcome message |
| hoa_editor::AnimatedTileData | |
| hoa_editor::Editor | |
| hoa_editor::EditorScrollView | |
| hoa_editor::Grid | |
| hoa_editor::MusicDialog | |
| hoa_editor::NewMapDialog | |
| hoa_editor::Tileset | Manages individual tiles in a tileset and everything related with them, such as walkability, animations, and so on |
| hoa_global::GameGlobal | Retains all the state information about the player's active game |
| hoa_global::GlobalActor | Represents an actor that can participate in battles |
| hoa_global::GlobalArmor | Represents all four types of armor found in the game |
| hoa_global::GlobalAttackPoint | Represents the "attack points" present on an actor |
| hoa_global::GlobalCharacter | Represents playable game characters |
| hoa_global::GlobalCharacterGrowth | A container class for tracking the growth of a character |
| hoa_global::GlobalElementalEffect | Represents an elemental effect on an actor or other object |
| hoa_global::GlobalEnemy | Represents those enemies that fight in battles |
| hoa_global::GlobalEventGroup | A container that manages the occurences of several related game events |
| hoa_global::GlobalItem | Represents items found and used throughout the game |
| hoa_global::GlobalKeyItem | Represents key items found in the game |
| hoa_global::GlobalObject | An abstract parent class for representing a game object |
| hoa_global::GlobalParty | Represents a party of actors |
| hoa_global::GlobalShard | Represents a shard item |
| hoa_global::GlobalSkill | A class for representing skills used in the game |
| hoa_global::GlobalStatusEffect | Represents a status effect on an actor or other object |
| hoa_global::GlobalTarget | Represents a target for an item, action, or skill |
| hoa_global::GlobalWeapon | Representing weapon that may be equipped by characters or enemies |
| hoa_input::GameInput | Processes and manages all user input events |
| hoa_input::private_input::JoystickState | Retains information about the user-defined joystick settings |
| hoa_input::private_input::KeyState | Retains information about the user-defined key settings |
| hoa_map::MapMode | Handles the game execution while the player is exploring maps |
| hoa_map::MapTile | Represents a single tile on the map |
| hoa_map::private_map::ActionAnimate | Action that displays specific sprite frames for a certain period of time |
| hoa_map::private_map::ActionPathMove | Action involving movement between a source and destination tile |
| hoa_map::private_map::ActionRandomMove | Action for declaring random movement of sprites |
| hoa_map::private_map::DialogueManager | A display for managing and displaying dialogue on maps |
| hoa_map::private_map::EnemySprite | A mobile map object that induces a battle to occur if the player touches it |
| hoa_map::private_map::EnemyZone | Class that represents an area where enemies spawn and roam in |
| hoa_map::private_map::MapDialogue | Retains and manages dialogues between characters on a map |
| hoa_map::private_map::MapFrame | Retains information about how the next map frame should be drawn |
| hoa_map::private_map::MapObject | Abstract class that represents objects on a map |
| hoa_map::private_map::MapObject_Ptr_Less | This is a predicate used to sort MapObjects in correct draw order |
| hoa_map::private_map::MapSprite | A mobile map object with which the player can interact with |
| hoa_map::private_map::MapZone | A class that represents a special zone on a map |
| hoa_map::private_map::PathNode | A container class for node information in pathfinding |
| hoa_map::private_map::PhysicalObject | Represents visible objects on the map that have no motion |
| hoa_map::private_map::SpriteAction | An abstract class for sprite actions |
| hoa_map::private_map::VirtualSprite | An invisible and possible mobile sprite on a map |
| hoa_map::private_map::ZoneSection | Class that represents a rectangular area on a map |
| hoa_menu::MenuMode | Handles game executing while in the main in-game menu |
| hoa_menu::private_menu::CharacterWindow | Represents an individual character window |
| hoa_menu::private_menu::EquipWindow | Represents the Equipment window, allowing the player to change equipment |
| hoa_menu::private_menu::FormationWindow | |
| hoa_menu::private_menu::InventoryWindow | Represents a window used to select a character to perform an action on.Represents the inventory window to browse the party's inventory |
| hoa_menu::private_menu::SkillsWindow | Represents the Skills window, displaying all the skills for the character |
| hoa_menu::private_menu::StatusWindow | Represents the Status window, displaying all the information about the character |
| hoa_mode_manager::GameMode | An abstract class that all game mode classes inherit from |
| hoa_mode_manager::GameModeManager | Manages and maintains all of the living game mode objects |
| hoa_pause::PauseMode | A mode pushed onto the game mode stack when the user pauses the game |
| hoa_quit::QuitMode | A mode pushed onto the game mode stack to confirm a user's quit command |
| hoa_scene::SceneMode | Handles everything that needs to be done when full-screen artwork is displayed |
| hoa_script::GameScript | Singleton class that manages all open script files |
| hoa_script::ModifyScriptDescriptor | Represents a Lua file opened with read, execute, and modify permissions |
| hoa_script::ReadScriptDescriptor | Represents a Lua file opened with read and execute permissions |
| hoa_script::ScriptDescriptor | An abstract class for representing open script files |
| hoa_script::WriteScriptDescriptor | Provides a simplistic interface for writing data to a new Lua file |
| hoa_shop::private_shop::ConfirmWindow | Displays the object's icon, name, and a sale confirmation message |
| hoa_shop::private_shop::ObjectInfoWindow | Displays detailed information about a selected object |
| hoa_shop::private_shop::ObjectListWindow | A window containing a list of objects and their price |
| hoa_shop::private_shop::ObjectSellListWindow | A window containing a list of current inventory and selling price |
| hoa_shop::private_shop::ShopActionWindow | Represents the top window in shop mode which contains the main shop actions |
| hoa_shop::ShopMode | Handles the game execution while the player is shopping |
| hoa_socket::Socket | TCP socket |
| hoa_system::GameSystem | Engine class that manages system information and functions |
| hoa_system::SystemTimer | A class which allows the user to easily control timed events |
| hoa_utils::Singleton< T > | Used for transforming a standard class into a singleton class |
| hoa_utils::ustring | Implements unicode strings with uint16 as the character type |
| hoa_video::AnimatedImage | Represents an animated image with both frames and timing information |
| hoa_video::Color | Representation of a single RGBA color |
| hoa_video::CoordSys | Determines the drawing coordinates |
| hoa_video::FontGlyph | A structure to hold properties about a particular font glyph |
| hoa_video::FontProperties | A structure which holds properties about fonts |
| hoa_video::GameVideo | Manages all the video operations and serves as the API to the video engine |
| hoa_video::ImageDescriptor | The abstract base class for StillImage and AnimatedImage |
| hoa_video::Interpolator | Class that lets you set up various kinds of interpolations. The basic way to use it is to set the interpolation method using SetMethod(), then call Start() with the values you want to interpolate between and the time to do it in |
| hoa_video::MenuWindow | Represents GUI menu windows and handles their operation |
| hoa_video::OptionBox | Represents rows and columns of options that the player may select |
| hoa_video::ParticleEffect | Particle effect, basically one coherent "effect" like an explosion, or snow falling from the sky. Consists of one or more ParticleSystems. An example of using multiple systems to create one effect would be a campfire where you have fire + smoke + glowing embers |
| hoa_video::ParticleEffectDef | Particle effect definition, just consists of each of its subsystems' definitions. This is basically just a struct, except it has a function to load the structure from a particle file (.lua/.hoa) |
| hoa_video::ParticleEmitter | |
| hoa_video::private_video::AnimationFrame | Represents a single frame in an animated image |
| hoa_video::private_video::Context | Retains the current graphics context |
| hoa_video::private_video::EffectParameters | When we change a property of an effect, it affects all of the systems contained within that effect. So, this structure contains any relevant parameters that particle systems need to know about |
| hoa_video::private_video::FixedImageNode | Used by the fixed-size texture manager to keep track of which blocks are owned by which images |
| hoa_video::private_video::FixedTexMemMgr | Used to manage textures which are designated for fixed image sizes |
| hoa_video::private_video::GUIControl | GUIControl is a type of GUI element, specifically for controls. This is for functions that controls have, but menu windows don't have, such as the SetOwner() function |
| hoa_video::private_video::GUIElement | An abstract base class for all GUI elements (windows + controls). This class contains basic functions such as Draw(), Update(), etc |
| hoa_video::private_video::GUISupervisor | A helper class to the video engine to manage all of the GUI functionality |
| hoa_video::private_video::Image | Represents a single image that is loaded and stored in a texture sheet. All the existing images will be stored in a map at the video engine. That way they can be shared among objects |
| hoa_video::private_video::ImageElement | Represents a single image within an ImageDescriptor object. Compound images are formed of multiple ImageElements |
| hoa_video::private_video::ImageLoadInfo | A container to store information about an image being loaded. This class is used to pass information between image loader code and OpenGL texture creation. It can also be used sometimes as a temporary holder for pixel data |
| hoa_video::private_video::MenuSkin | A container class for a menu skin, consisting of border images and an interior |
| hoa_video::private_video::MultiImageInfo | Temporal struct for holding a multiimage information |
| hoa_video::private_video::Option | Represents one particular option in a list and all its elements |
| hoa_video::private_video::OptionCellBounds | Holds the bound coordinates for a particular "cell" in an option box |
| hoa_video::private_video::OptionElement | A class which encapsulates the various contents of an option |
| hoa_video::private_video::Particle | This is the structure we use to represent a particle |
| hoa_video::private_video::ParticleKeyframe | Keyframes, consist of a _time, plus various properties. These are used to specify how the properties of a particle vary over time. For example, in most systems, we'll want particles to fade out over their lifetime, so this could be done by creating 2 keyframes, where the alpha component of the 2nd keyframe's _color is zero |
| hoa_video::private_video::ParticleManager | ParticleManager, used internally by video engine to store/update/draw all particle effects |
| hoa_video::private_video::ParticleSystem | |
| hoa_video::private_video::ParticleSystemDef | |
| hoa_video::private_video::ParticleTexCoord | This is used in texture coordinate array for DrawArrays() Unless animated particles are used, this can be generated just once |
| hoa_video::private_video::ParticleVertex | This is used in the vertex array for DrawArrays(). Every time the particle system is rendered, we need to iterate through all the particles in the system, and use the position, size, and rotation to generate 4 ParticleVertex's. This is pretty expensive, but unfortunately it's necessary since the positions change every frame |
| hoa_video::private_video::ScreenFader | Used to monitor progress for a fading screen |
| hoa_video::private_video::ShakeForce | Every time ShakeScreen() is called, a new ShakeForce is created to represent the force of that particular shake |
| hoa_video::private_video::TexMemMgr | Base class for texture memory managers |
| hoa_video::private_video::TexSheet | An actual OpenGL texture which can be used for storing multiple smaller images in it |
| hoa_video::private_video::VariableImageNode | This is how we keep track of which images are used/freed in the variable texture mem manager |
| hoa_video::private_video::VariableTexMemMgr | Used to manage a texture sheet where the size of the images it will contain are unknown |
| hoa_video::RenderedLine | A structure holding a single rendered line |
| hoa_video::RenderedString | A structure which a rendered string |
| hoa_video::ScreenRect | A structure used for storing rectangles with pixel coordinates This class is used in storing the current scissoring rectangles, viewport rectangles, etc. It is based on standard screen coordinates, where (0,0) is the top-left and the unit is 1 pixel (hence int32 coordinates instead of floats) |
| hoa_video::StillImage | Represents a single or compound still image StillImages may be simple images or compound images. Compound images are created when you stitch together multiple smaller images to create a single large image (e.g. with TilesToObject() function). It's fine to think of compound images as just a single image |
| hoa_video::TextBox | Class for representing an invisible box for rendering text to. Although the video engine has an easy-to-use DrawText() function, for any non-trivial text display, the TextBox class must be used. This class provides a few things which aren't handled by DrawText(), namely word wrapping, and "gradual display", such as drawing one character at a time or fading each line of text in individually |
| Q3MainWindow | |
| Q3ScrollView | |
| QDialog | |
| QGLWidget | |
