Aaaand your player just spawned in a wall ;D
Seriously though, making a non-junk procedural game is not that simple, definitely worth a dedicated book. This is the table of content of this book if you want an idea about it:
Table of Contents:
Procedural Content Generation for C++ Game Development
Credits
About the Author
Acknowledgment
About the Reviewer
www.PacktPub.com
Support files, eBooks, discount offers, and more
Why subscribe?
Free access for Packt account holders
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Extra Exercises
Reader feedback
Customer support
Downloading the example code
Downloading the color images of this book
Errata
Piracy
Questions
1. An Introduction to Procedural Generation
Procedural generation versus random generation
Procedural generation
Random generation
Introducing randomness
Pseudorandom number generation
Why computers can’t generate truly random numbers
Generating random numbers in C++
Generating random numbers within a range
Seeds
Defining seeds
Using seeds
Generating random seeds during the runtime
Controlled randomness is the key to generating random numbers
The use of procedural generation in games
Saving space
Map generation
Texture creation
Animation
Sound
Benefits of procedural generation
Larger games can be created
Procedural generation can be used to lower budgets
An increase in gameplay variety
An increase in replayability
The drawbacks of procedural generation
More taxing on the hardware
Worlds can feel repetitive
You sacrifice quality control
You may generate an unplayable world
It is hard to script set game events
A brief history of rogue-like games
How we’ll implement procedural generation
Populating environments
Creating unique game objects
Creating unique art
Audio manipulation
Behavior and mechanics
Dungeon generation
Component-based design
The complete game
Exercises
Summary
2. Project Setup and Breakdown
Choosing an IDE
Microsoft Visual Studio
Code::Blocks
Other IDEs
Build systems
Breaking down the game template
Download templates
The class diagram
The object hierarchy
Level data
Collision
Input
Simple and Fast Multimedia Library (SFML)
Defining SFML
Why we’ll be using SFML
Learning SFML
Alternatives
Polymorphism
Inheritance
Virtual functions
Pure virtual functions
Pointers and object slicing
The roguelike template setup
Downloading SFML
Linking SFML
Running the project
Adding an item
Updating and drawing
Exercises
Summary
3. Using RNG with C++ Data Types
Setting the game seed
Setting Boolean values randomly
Generating a number between 0 and 1
Choosing if an item spawns
Random number distribution
Giving the player random stats
Accessing random elements of a collection
Spawning a random item
Generating random characters
Repeating loops
Spawning a random number of items
Exercises
Summary
4. Procedurally Populating Game Environments
Potential obstacles
Keeping within the bounds of a level
Avoiding overlapping objects
Creating meaningful levels
Level tiles
Defining the spawn area
Calculating the level bounds
Checking the underlying game grid
Selecting a suitable game tile
Randomly selecting a tile
Checking whether a tile is suitable
Converting to absolute position
Spawning items at a random location
Expanding the spawning system
Using enumerators to denote an object type
Optional parameters
The complete spawn functions
Updating the spawn code
Randomly spawning enemies
Spawning random tiles
Adding a new game tile
Choosing a random tile
Implementing the SpawnRandomTiles function
Exercises
Summary
5. Creating Unique and Randomized Game Objects
Creating a random player character
Choosing a player class
An overview of sprites and textures
Setting an appropriate sprite
Buffing the player stats
Random character traits
Returning the player traits array
Setting trait sprites
Procedurally generating an enemy class
Procedural items
Random Gem and Heart classes
Random gold class
The random potion class
Creating a random potion
Determining potion pickups
Exercises
Summary
6. Procedurally Generating Art
How procedural generation is used with art
Using sprite effects and modifiers
Combining multiple textures
Creating textures from scratch
Creating complex animations
The benefits of procedurally generated art
Versatility
Cheap to produce
It requires little storage
The drawbacks of procedurally generated art
Lack of control
Repeatability
Performance heavy
Using SFML sprite modifiers
How colors work in SFML
Creating sprites of a random color
Selecting a preset color at random
Generating a color at random
Creating sprites of a random size
Saving modified sprites
Passing a texture into an image
Drawing to a RenderTexture class
Saving an image to a file
Creating enemy sprites procedurally
Breaking sprites into components
The draw setup
Randomly selecting sprite components
Loading the default armor textures
Choosing the armor tier
Rendering the armor textures
Rendering the final textures
Overriding the default draw behavior
Debugging and testing
Editing the game tiles
Exercises
Summary
7. Procedurally Modifying Audio
An introduction to SFML audio
sf::Sound versus sf::Music
sf::SoundBuffer
Selecting a random main track
Adding sound effects
Editing sound effects
Playing a sound function
The audio listener
Creating a fluctuation in a pitch
3D sound – spatialization
The audio listener
The minimum distance
Attenuation
The position of the sound
Fixed positions
Moving positions
Exercises
Summary
8. Procedural Behavior and Mechanics
An introduction to pathfinding
What is a pathfinding algorithm?
Dijkstra’s algorithm
The A* algorithm
A breakdown of A*
Representing a level as nodes
The open and closed list
The H, G, and F costs
The H value
The G value
The F value
The Manhattan distance
Parenting nodes
The pseudo-algorithm
Coding the A* pathfinding algorithm
The Tile datatype
Creating supporting functions
The Level class
The Enemy class
Variable declarations
Precalculating the H values
Defining the main loop
Finding the adjacent nodes
Calculating the G and F costs
Calculating the G and F cost
Checking for superior paths
Creating the final path
Implementing A* in the game
Enabling the enemy to follow a path
Calling the pathfinding behavior
Viewing our path
Procedurally generated level goals
The variable and function declarations
Generating a random goal
Checking whether a goal is complete
Drawing the goal on the screen
Exercises
Summary
9. Procedural Dungeon Generation
The benefits of procedural level design
Replayability
A reduction in development time
Larger game worlds
Considerations
A lack of control
Required computing power
Suitability
An overview of dungeon generation overview
Generating rooms
Generating a maze
Connecting rooms and mazes
The recursive backtracker
Procedurally generating a dungeon
Changing how we view the maze
Updating the Game and Level classes
Generating a maze
Preparing before the generation of a maze
Carving passages
Adding rooms
Choosing the tile textures
The if/else approach
Bitwise tile maps
Calculating the tile values
Mapping the tile value to textures
Calculating tile textures
Creating unique floor themes
Adding entry and exit points
Setting a player’s spawn location
Undoing the debug changes
Exercises
Summary
10. Component-Based Architecture
Understanding component-based architecture
Problems with a traditional inheritance-based approach
Convoluted inheritance structures
Circular dependencies
Benefits of component-based architecture
Avoiding complex inheritance structures
Code is broken into highly reusable chunks
Highly maintainable and scalable
The disadvantages of component-based architecture
Code can become too fragmented
Unnecessary overhead
Complex to use
An overview
Designing the component system
C++ templates
Using templates
Template declarations
Using templates
Template specialization
Function overloading
Creating a base component
Component functions
Attaching a component
Retuning a component
Creating a transform component
Encapsulating transform behavior
Adding a transform component to the player
Using the transform component
Updating the game code
Creating a SpriteComponent
Encapsulating sprite behavior
Adding a sprite component to the player class
The updated drawing pipeline
Updating the game code
Creating an audio component
Defining the behavior of an audio component
Adding an audio component to the player class
Using the audio component
Exercises
Summary
11. Epilogue
Project breakdown
Procedurally populating environments
Creating unique and random game objects
Procedurally generating art
Procedurally modifying audio
Procedural behavior and mechanics