Index
A
- A*
- implementing, in game / Implementing A* in the game
- enemy, enabling to follow path / Enabling the enemy to follow a path
- pathfinding behavior, calling / Calling the pathfinding behavior
- path, viewing / Viewing our path
- A* algorithm
- defining / The A* algorithm
- implementing / A breakdown of A*
- level, representing as nodes / Representing a level as nodes
- open list / The open and closed list
- closed list / The open and closed list
- H, G, and F costs / The H, G, and F costs
- H value / The H value
- G value / The G value
- F value / The F value
- Manhattan distance / The Manhattan distance
- parenting nodes / Parenting nodes
- pseudo-algorithm / The pseudo-algorithm
- A* pathfinding algorithm
- coding / Coding the A* pathfinding algorithm
- Tile datatype / The Tile datatype
- supporting functions, creating / Creating supporting functions
- variable declarations / Variable declarations
- H values, precalculating / Precalculating the H values
- main loop, defining / Defining the main loop
- adjacent nodes, finding / Finding the adjacent nodes
- G and F costs, calculating / Calculating the G and F costs
- superior paths, checking / Checking for superior paths
- final path, creating / Creating the final path
- algorithms
- Allegro
- URL / Alternatives
- ArgoUML
- URL / The class diagram
- art
- procedural generation, used with / How procedural generation is used with art
- generating procedurally / Procedurally generating art
- Artificial Intelligence (AI)
- about / Behavior and mechanics
- ASCII table
- A Star (A*)
- about / Behavior and mechanics
- audio
- modifying procedurally / Procedurally modifying audio
- audio component
- creating / Creating an audio component
- behavior, defining / Defining the behavior of an audio component
- adding, to player class / Adding an audio component to the player class
- using / Using the audio component
- audio manipulation
- about / Audio manipulation
- behavior and mechanics / Behavior and mechanics
- Dungeon generation / Dungeon generation
B
- base component
- creating / Creating a base component
- Boolean values
- setting randomly / Setting Boolean values randomly
- number between 0 and 1, generating / Generating a number between 0 and 1
- spawned item, selecting / Choosing if an item spawns
- breakpoints
- using / Retuning a component
- build systems
- about / Build systems
- reference link / Build systems
C
- C++ reference
- C++ templates
- about / C++ templates
- using / Using templates, Using templates
- declarations / Template declarations
- template specialization / Template specialization
- URL / Template specialization
- class diagram
- about / The class diagram
- class keyword
- about / Template declarations
- closed list / The open and closed list
- Code**Blocks IDE
- about / Code::Blocks
- pros / Code::Blocks
- cons / Code::Blocks
- collision
- about / Collision
- color
- generating, at random / Generating a color at random
- complex animations
- creating / Creating complex animations
- component-based architecture
- component-based design
- about / Component-based design
- Component functions
- about / Component functions
- component, attaching / Attaching a component
- component, returning / Retuning a component
- component system
- designing / Designing the component system
- cryptography
- about / Pseudorandom number generation
- custom package, SFML
- reference link / Downloading SFML
D
- 3D sound
- defining / 3D sound – spatialization
- audio listener / The audio listener
- minimum distance / The minimum distance
- attenuation / Attenuation
- sound position / The position of the sound
- deterministic machines
- about / Introducing randomness
- Dijkstra's algorithm
- about / Dijkstra's algorithm
- Doxygen
- URL / The class diagram
- DreamSpark
- URL / Microsoft Visual Studio
- dungeon generation
- defining / An overview of dungeon generation overview
- rooms, generating / Generating rooms
- maze, generating / Generating a maze
- rooms and mazes, connecting / Connecting rooms and mazes
- dynamic libraries
- about / Linking SFML
E
- enemy class
- generating / Procedurally generating an enemy class
- enemy sprites
- creating procedurally / Creating enemy sprites procedurally
- sprites, breaking into components / Breaking sprites into components
- draw setup / The draw setup
- sprite components, selecting / Randomly selecting sprite components
- default armor textures, loading / Loading the default armor textures
- armor tier, selecting / Choosing the armor tier
- armor textures, rendering / Rendering the armor textures
- final textures, rendering / Rendering the final textures
- default draw behavior, overriding / Overriding the default draw behavior
- debugging / Debugging and testing
- testing / Debugging and testing
- environments
- populating procedurally / Procedurally populating environments
- exercises
F
- function overloading
- defining / Function overloading
- URL / Function overloading
G
- game seed
- setting / Setting the game seed
- game template
- breaking down / Breaking down the game template
- downloading / Download templates
- game tiles
- editing / Editing the game tiles
- G and F costs
- calculating / Calculating the G and F costs, Calculating the G and F cost
- GNU Compiler Collection (GCC) / Downloading SFML
H
- heuristic
- about / The A* algorithm
I
- IDE
- selecting / Choosing an IDE, Other IDEs
- inheritance
- about / Inheritance
- input
- about / Input
- items, spawning randomly
- about / Spawning items at a random location
- spawning system, expanding / Expanding the spawning system
- enumerators, using / Using enumerators to denote an object type
- optional parameters / Optional parameters
- spawn functions / The complete spawn functions
- spawn code, updating / Updating the spawn code
- enemies, spawning randomly / Randomly spawning enemies
L
- level data
- about / Level data
- level tiles
- about / Level tiles
- loops
- repeating / Repeating loops
M
- main game loop
- reference link / Updating and drawing
- Manhattan distance
- about / The H value
- maze generation
- preparing for / Preparing before the generation of a maze
- passages, carving / Carving passages
- Microsoft Visual Studio
- about / Microsoft Visual Studio
- pros / Microsoft Visual Studio
- cons / Microsoft Visual Studio
- modified sprites
- saving / Saving modified sprites
- texture, passing into image / Passing a texture into an image
- RenderTexture class, drawing / Drawing to a RenderTexture class
- image, saving to file / Saving an image to a file
- modifiers
- modulo operator
- Mono
- about / The position of the sound
- MonoGame
- URL / Alternatives
- multiple textures
- combining / Combining multiple textures
N
- navigation meshes
- Nintendo Entertainment System (NES)
- about / Saving space
O
- object hierarchy
- about / The object hierarchy
- object slicing
- about / Pointers and object slicing
- reference link / Pointers and object slicing
- open list / The open and closed list
P
- pathfinding
- defining / An introduction to pathfinding
- URL / Creating the final path
- pathfinding algorithm
- about / What is a pathfinding algorithm?
- player random stats
- giving / Giving the player random stats
- pointers
- about / Pointers and object slicing
- polymorphism
- about / Polymorphism
- reference link / Polymorphism
- potential obstacles
- about / Potential obstacles
- keeping, within the bound of level / Keeping within the bounds of a level
- overlapping objects, avoiding / Avoiding overlapping objects
- meaningful levels, creating / Creating meaningful levels
- preset color
- selecting / Selecting a preset color at random
- procedural behavior and mechanics
- defining / Procedural behavior and mechanics
- procedural dungeon generation
- about / Procedurally generating a dungeon
- maze view, changing / Changing how we view the maze
- Game and Level class, updating / Updating the Game and Level classes
- maze, generating / Generating a maze
- rooms, adding / Adding rooms
- defining / Procedural dungeon generation
- URL / Procedural dungeon generation
- procedural generation
- versus random generation / Procedural generation versus random generation
- defining / Procedural generation
- using, in games / The use of procedural generation in games
- benefits / Benefits of procedural generation, Larger games can be created, Procedural generation can be used to lower budgets
- drawbacks / The drawbacks of procedural generation, More taxing on the hardware, It is hard to script set game events
- implementing / How we'll implement procedural generation
- environments, populating / Populating environments
- unique game objects, creating / Creating unique game objects
- used, with art / How procedural generation is used with art
- pros / The pros and cons of procedural generation
- cons / The pros and cons of procedural generation, Cons
- procedural generation usage
- space, saving / Saving space
- map generation / Map generation
- procedural items
- about / Procedural items
- Random Gem and Heart classes / Random Gem and Heart classes
- Random gold class / Random gold class
- procedural level design
- benefits / The benefits of procedural level design, Replayability
- considerations / Considerations, A lack of control
- procedurally generated art
- benefits / The benefits of procedurally generated art
- drawbacks / The drawbacks of procedurally generated art
- procedurally generated level goals
- defining / Procedurally generated level goals
- variable declaration / The variable and function declarations
- function declaration / The variable and function declarations
- random goal, generating / Generating a random goal
- active goal, checking / Checking whether a goal is complete
- goal, drawing on screen / Drawing the goal on the screen
- pure virtual functions
- about / Pure virtual functions
R
- random characters
- generating / Generating random characters
- random elements
- accessing, of collection / Accessing random elements of a collection
- random generation
- versus procedural generation / Procedural generation versus random generation
- defining / Random generation
- random item
- spawning / Spawning a random item
- random main track
- selecting / Selecting a random main track
- randomness
- defining / Introducing randomness
- pseudorandom number generation / Pseudorandom number generation
- truly random numbers, generating / Why computers can't generate truly random numbers
- random numbers, generating in C++ / Generating random numbers in C++
- random numbers, generating within range / Generating random numbers within a range
- random number distribution
- defining / Random number distribution
- Random Number Generator (RNG)
- random number of items
- spawning / Spawning a random number of items
- random numbers
- random player character
- creating / Creating a random player character
- player class, selecting / Choosing a player class
- sprites and textures / An overview of sprites and textures
- sprite, setting / Setting an appropriate sprite
- player stats, buffing / Buffing the player stats
- random character traits / Random character traits
- array, returning / Returning the player traits array
- trait sprites, setting / Setting trait sprites
- random potion class
- defining / The random potion class
- random potion, creating / Creating a random potion
- potion pickups, determining / Determining potion pickups
- random tiles, spawning
- about / Spawning random tiles
- new game tile, adding / Adding a new game tile
- random tile, selecting / Choosing a random tile
- recursive backtracker
- about / The recursive backtracker
- recursive backtracker algorithm
- about / Generating a maze
- roguelikes
- history / A brief history of rogue-like games
- about / A brief history of rogue-like games
- roguelike template setup
- about / The roguelike template setup
- project, running / Running the project
- item, adding / Adding an item
- item, updating / Updating and drawing
- item, drawing / Updating and drawing
S
- SDL2
- URL / Alternatives
- seeds
- about / Generating random numbers within a range, Seeds
- defining / Defining seeds
- using / Using seeds
- random seeds, generating during runtime / Generating random seeds during the runtime
- random numbers, generating / Controlled randomness is the key to generating random numbers
- SFML
- URL / Pseudorandom number generation, How colors work in SFML
- about / Simple and Fast Multimedia Library (SFML)
- defining / Defining SFML
- need for / Why we'll be using SFML
- learning / Learning SFML
- reference link / Learning SFML
- alternatives / Alternatives
- downloading / Downloading SFML
- download link / Downloading SFML
- linking / Linking SFML
- colors, working / How colors work in SFML
- SFML audio
- defining / An introduction to SFML audio
- sf$$Sound, versus sf$$Music / sf::Sound versus sf::Music
- sf$$Sound, versus sf$$SoundBuffer / sf::SoundBuffer
- SFML Blueprints
- reference link / Learning SFML
- SFML Essentials
- reference link / Learning SFML
- SFML Game Development
- reference link / Learning SFML
- SFML sprite modifiers
- using / Using SFML sprite modifiers
- Sfxr
- Simple and Fast Multimedia Library (SFML)
- smart pointers
- reference link / The object hierarchy
- sound effects
- adding / Adding sound effects
- editing / Editing sound effects
- sound function, playing / Playing a sound function
- audio listener / The audio listener
- fluctuation, creating in pitch / Creating a fluctuation in a pitch
- sound position
- fixed positions / Fixed positions
- moving positions / Moving positions
- spawn area
- defining / Defining the spawn area
- level bounds, calculating / Calculating the level bounds
- underlying game grid, checking / Checking the underlying game grid
- SpawnRandomTiles function
- implementing / Implementing the SpawnRandomTiles function
- SpriteComponent
- creating / Creating a SpriteComponent
- sprite behavior, encapsulating / Encapsulating sprite behavior
- adding, to player class / Adding a sprite component to the player class
- updated drawing pipeline / The updated drawing pipeline
- game code, updating / Updating the game code
- sprite components
- reference / Randomly selecting sprite components
- sprite effects
- sprites
- creating, of random color / Creating sprites of a random color
- creating, of random size / Creating sprites of a random size
- static libraries
- about / Linking SFML
- static libraries, versus dynamic libraries
- reference link / Linking SFML
- suitable game tile
- selecting / Selecting a suitable game tile
- selecting randomly / Randomly selecting a tile
- checking / Checking whether a tile is suitable
- converting, to absolute position / Converting to absolute position
- supporting functions
- creating / Creating supporting functions
- Level class / The Level class
- Enemy class / The Enemy class
T
- texture creation
- about / Texture creation
- animation / Animation
- sound / Sound
- textures
- creating, from scratch / Creating textures from scratch
- tile textures
- selecting / Choosing the tile textures
- if/else approach / The if/else approach
- Bitwise tile maps / Bitwise tile maps
- tile values, calculating / Calculating the tile values
- tile values, mapping to / Mapping the tile value to textures
- calculating / Calculating tile textures
- unique floor themes, creating / Creating unique floor themes
- entry and exit points, adding / Adding entry and exit points
- spawn location, setting / Setting a player's spawn location
- debug changes, undoing / Undoing the debug changes
- traditional inheritance-based approach
- challenges / Problems with a traditional inheritance-based approach, Circular dependencies
- convoluted inheritance structures / Convoluted inheritance structures
- circular dependencies / Circular dependencies
- transform component
- creating / Creating a transform component
- transform behavior, encapsulating / Encapsulating transform behavior
- adding, to player / Adding a transform component to the player
- using / Using the transform component
- game code, updating / Updating the game code
- typename keyword
- about / Template declarations
U
- unique and random game objects
- creating / Creating unique and random game objects
- unique art
- creating / Creating unique art
V
- vectors
- references / Enabling the enemy to follow a path
- versatility
- about / Versatility
- virtual functions
- about / Virtual functions