book

Procedural Content Generation for C++ Game Development

Name: Procedural Content Generation for C++ Game Development
Author: Dale Green
ISBN: 9781785886713

by Dale Green

January 2016

Intermediate to advanced

304 pages

6h 17m

English

Packt Publishing

Read now

Unlock full access

Procedural Content Generation for C++ Game Development
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 moreWhy 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 codeDownloading the color images of this bookErrataPiracyQuestions
1. An Introduction to Procedural Generation
Procedural generation versus random generationProcedural generationRandom generation
Introducing randomness
Pseudorandom number generationWhy computers can't generate truly random numbersGenerating random numbers in C++Generating random numbers within a range
Seeds
Defining seedsUsing seedsGenerating random seeds during the runtimeControlled randomness is the key to generating random numbers
The use of procedural generation in games
Saving spaceMap generation
Texture creation
AnimationSound
Benefits of procedural generation
Larger games can be createdProcedural generation can be used to lower budgetsAn increase in gameplay varietyAn increase in replayability
The drawbacks of procedural generation
More taxing on the hardwareWorlds can feel repetitiveYou sacrifice quality controlYou may generate an unplayable worldIt is hard to script set game events
A brief history of rogue-like games
How we'll implement procedural generation
Populating environmentsCreating unique game objects
Creating unique art
Audio manipulation
Behavior and mechanicsDungeon generation
Component-based design
The complete game
Exercises
Summary
2. Project Setup and Breakdown
Choosing an IDEMicrosoft Visual StudioCode::BlocksOther IDEsBuild systems
Breaking down the game template
Download templatesThe class diagramThe object hierarchyLevel dataCollisionInput
Simple and Fast Multimedia Library (SFML)
Defining SFMLWhy we'll be using SFMLLearning SFMLAlternatives
Polymorphism
InheritanceVirtual functionsPure virtual functionsPointers and object slicing
The roguelike template setup
Downloading SFMLLinking SFMLRunning the projectAdding an itemUpdating 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 1Choosing 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 obstaclesKeeping within the bounds of a levelAvoiding overlapping objectsCreating meaningful levels
Level tiles
Defining the spawn area
Calculating the level boundsChecking the underlying game grid
Selecting a suitable game tile
Randomly selecting a tileChecking whether a tile is suitableConverting to absolute position
Spawning items at a random location
Expanding the spawning systemUsing enumerators to denote an object typeOptional parametersThe complete spawn functionsUpdating the spawn codeRandomly spawning enemies
Spawning random tiles
Adding a new game tileChoosing a random tileImplementing the SpawnRandomTiles function
Exercises
Summary
5. Creating Unique and Randomized Game Objects
Creating a random player characterChoosing a player classAn overview of sprites and texturesSetting an appropriate spriteBuffing the player statsRandom character traitsReturning the player traits arraySetting trait sprites
Procedurally generating an enemy class
Procedural items
Random Gem and Heart classesRandom gold class
The random potion class
Creating a random potionDetermining potion pickups
Exercises
Summary
6. Procedurally Generating Art
How procedural generation is used with artUsing sprite effects and modifiersCombining multiple texturesCreating textures from scratchCreating complex animations
The benefits of procedurally generated art
VersatilityCheap to produceIt requires little storage
The drawbacks of procedurally generated art
Lack of controlRepeatabilityPerformance heavy
Using SFML sprite modifiers
How colors work in SFMLCreating sprites of a random colorSelecting a preset color at randomGenerating a color at randomCreating sprites of a random size
Saving modified sprites
Passing a texture into an imageDrawing to a RenderTexture classSaving an image to a file
Creating enemy sprites procedurally
Breaking sprites into componentsThe draw setupRandomly selecting sprite componentsLoading the default armor texturesChoosing the armor tierRendering the armor texturesRendering the final texturesOverriding the default draw behaviorDebugging and testing
Editing the game tiles
Exercises
Summary
7. Procedurally Modifying Audio
An introduction to SFML audiosf::Sound versus sf::Musicsf::SoundBuffer
Selecting a random main track
Adding sound effects
Editing sound effects
Playing a sound function
The audio listenerCreating a fluctuation in a pitch
3D sound – spatialization
The audio listenerThe minimum distanceAttenuationThe position of the soundFixed positionsMoving positions
Exercises
Summary
8. Procedural Behavior and Mechanics
An introduction to pathfindingWhat is a pathfinding algorithm?Dijkstra's algorithmThe A* algorithm
A breakdown of A*
Representing a level as nodesThe open and closed listThe H, G, and F costsThe H valueThe G valueThe F valueThe Manhattan distanceParenting nodesThe pseudo-algorithm
Coding the A* pathfinding algorithm
The Tile datatypeCreating supporting functionsThe Level classThe Enemy classVariable declarationsPrecalculating the H valuesDefining the main loopFinding the adjacent nodesCalculating the G and F costsCalculating the G and F costChecking for superior pathsCreating the final path
Implementing A* in the game
Enabling the enemy to follow a pathCalling the pathfinding behaviorViewing our path
Procedurally generated level goals
The variable and function declarationsGenerating a random goalChecking whether a goal is completeDrawing the goal on the screen
Exercises
Summary
9. Procedural Dungeon Generation
The benefits of procedural level designReplayabilityA reduction in development timeLarger game worlds
Considerations
A lack of controlRequired computing powerSuitability
An overview of dungeon generation overview
Generating roomsGenerating a mazeConnecting rooms and mazes
The recursive backtracker
Procedurally generating a dungeon
Changing how we view the mazeUpdating the Game and Level classesGenerating a mazePreparing before the generation of a mazeCarving passagesAdding rooms
Choosing the tile textures
The if/else approachBitwise tile mapsCalculating the tile valuesMapping the tile value to texturesCalculating tile texturesCreating unique floor themesAdding entry and exit pointsSetting a player's spawn locationUndoing the debug changes
Exercises
Summary
10. Component-Based Architecture
Understanding component-based architectureProblems with a traditional inheritance-based approachConvoluted inheritance structuresCircular dependenciesBenefits of component-based architectureAvoiding complex inheritance structuresCode is broken into highly reusable chunksHighly maintainable and scalableThe disadvantages of component-based architectureCode can become too fragmentedUnnecessary overheadComplex to useAn overview
Designing the component system
C++ templates
Using templatesTemplate declarationsUsing templatesTemplate specialization
Function overloading
Creating a base component
Component functions
Attaching a componentRetuning a component
Creating a transform component
Encapsulating transform behaviorAdding a transform component to the playerUsing the transform componentUpdating the game code
Creating a SpriteComponent
Encapsulating sprite behaviorAdding a sprite component to the player classThe updated drawing pipelineUpdating the game code
Creating an audio component
Defining the behavior of an audio componentAdding an audio component to the player classUsing the audio component
Exercises
Summary
11. Epilogue
Project breakdownProcedurally populating environmentsCreating unique and random game objectsProcedurally generating artProcedurally modifying audioProcedural behavior and mechanicsProcedural dungeon generationComponent-based architecture
The pros and cons of procedural generation
ProsCons
Summary
Index

Content preview from Procedural Content Generation for C++ Game Development

Summary

In this chapter, we looked at how to make game objects unique and random, giving them random properties, sprites, and variations. With this approach, the range of possible items that a game can generate is almost endless. When we have multiple classes that differ only slightly, we can design ambiguous classes that are highly flexible and greatly increase variety.

In the next chapter, we're going to step up our procedural efforts. We'll move away from the simple setting of member variables randomly, and we'll experiment with the creation of procedural art and graphics. We'll create textures procedurally for enemies, and alter the level sprites to give a unique feel to each floor of the dungeon.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Procedural Content Generation for Unity Game Development

Publisher Resources

ISBN: 9781785886713

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Procedural Content Generation for C++ Game Development

by Dale Green

Summary

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.