Index

A

• AcceptCoopPartne / Studying our protocol
• affectors
  • about / Particle systems
• Aircraft$$launchMissile() function / Firing bullets and missiles
• Aircraft class / Aircraft, Movement patterns
• Aircraft constructor / Displaying text
• aircraftIdentifiers variable / Peers and aircraft
• AND operator / Command execution
• animated sprites
  • about / Animated sprites
• Application class
  • stack, integrating / Integrating the stack in the Application class
• application programming interface (API) / Introducing SFML
• apply() function / Picking up some goodies, Fullscreen post effects
• Artificial Intelligence (AI) / Movement patterns
• aspect ratio
  • about / Resolution and aspect ratio
• assertions
  • about / Assertions
• assignKey() function / Customizing key bindings
• attenuation factor
  • about / Attenuation factor and minimum distance
• Audacity software
  • URL / Music themes
• audio
  • about / Audio
• audio module, SFML / Introducing SFML

B

• bandwidth
  • versus latency / Latency versus bandwidth
  • vew scrolling compensation / View scrolling compensation
• bloom effect
  • about / Post effects and shaders, The bloom effect
• Boolean return values
  • about / Boolean return values
• bounding rectangle / Collision detection and response
• BroadcastMessage / Studying our protocol
• bullets
  • firing / Firing bullets and missiles
• Button$$activate() method / Use case – GUI sounds
• Button object / Use case – GUI sounds

C

• C++
  • about / A few notes on C++
• centerOrigin() function / Displaying text
• checkMissionEnd() / Understanding the ticks and updates
• checkProjectileLaunch() function / Firing bullets and missiles
• checkSceneCollision() function / Finding the collision pairs
• circle tree
  • about / View optimizations
• client
  • about / Taking a peek in the other end – the client
  • packets / Client packets
  • game actions transmitting, network modes used / Transmitting game actions via network nodes
  • pause state / The new pause state
  • settings screen / Settings
  • player class / The new Player class
• Closed event / The Game class
• CMake / Downloading and installation
• collision
  • detecting / Collision detection and response
  • pairs, finding / Finding the collision pairs
  • reacting to / Reacting to collisions
• collision() function / Finding the collision pairs
• command-based communication system
  • about / A command-based communication system
• command execution / Command execution
• CommandQueue class
  • about / Command queues
  / Commands in a nutshell
• command queues
  • about / Command queues
• commands
  • about / Introducing commands
  • overview / Commands in a nutshell
• Component$$handleEvent() function / The GUI hierarchy, the Java way
• component-based design / Alternative entity designs
• Component class / The GUI hierarchy, the Java way
• concurrency / Concurrency
• container
  • finding / Finding an appropriate container
• createProjectile() function / Firing bullets and missiles
• createState() method / Adding states to StateStack
• culling
  • about / View optimizations
• custom protocol
  • about / Custom protocols

D

• 3D space
  • sounds / Sounds in 3D space
• 3D vectors
  • position / The listener
  • up / The listener
  • direction / The listener
• data tables
  • entity attributes, storing / Storing entity attributes in data tables
• data transport
  • about / Data transport
• delta movement, mouse / Delta movement from the mouse
• delta time / Frame-independent movement
• destroy() function / Introducing hitpoints
• direction, 3D vectors / The listener
• DirectX
  • about / OpenGL and graphics cards
• double buffering / Real-time rendering
• draw
  • handling / Draw
• draw() function / Making scene nodes drawable, Updating the scene
• draw() method / Update and draw
• draw call
  • about / View optimizations
• drawCurrent() function / Making scene nodes drawable, Drawing entities

E

• EmitterNode and ParticleNode
  • splitting / Emitter nodes, Affectors
• emitter nodes
  • about / Emitter nodes
• emitters
  • about / Particle systems
• enemies
  • about / Creating enemies
  • movement patterns / Movement patterns
  • spawning / Spawning enemies
• entities
  • about / Entities
  • Aircrafts / Aircraft
  • designs, alternative / Alternative entity designs
  • drawing / Drawing entities
  • connecting, with resources / Connecting entities with resources
  • equipping / Equipping the entities
  • attributes, storing in data tables / Storing entity attributes in data tables
  • text, displaying / Displaying text
• Entity$$draw() function / Rendering the scene
• Entity, base class / Entities
• erase() / Cleaning everything up
• error
  • handling / Error handling
• events
  • about / Polling events
  • and real-time input / Events and real-time input – when to use which
• exceptions
  • throwing / Throwing exceptions
• executionThread() / Server thread

F

• FIFO (first in, first out) / Command queues
• file paths
  • about / File paths and working directories
• Finite State Machine (FSM) / The state stack
• fire() function / Firing bullets and missiles
• fixed time step / Fixed time steps
• fonts
  • about / Fonts
• FPS
  • about / Game loops and frames
• frames
  • about / Animated sprites
• fullscreen post effects
  • about / Fullscreen post effects

G

• game
  • developing / Developing the first game
  • class / The Game class
• Game$$handlePlayerInput() / Input over several frames
• Game class
  • integrating / Integrating the Game class
  • run method / The run() method
• game code, texture atlases
  • adapting / Adapting the game code
• GameEvent parameter / Client packets
• game logic
  • implementing / Implementing the game logic
• game loop
  • about / Game loops and frames
• GameServer$$executionThread() function / Server thread
• general-purpose communication mechanism
  • about / A general-purpose communication mechanism
• get() method / Assertions
• getAssignedKey() function / Customizing key bindings
• getBattlefieldBounds() / Spawning enemies, Out of view, out of the world
• getCategory() function / Receiver categories
• get function / Entities
• getOrigin() / SFML and transforms
• getStatus() method / Loading and playing
• getViewBounds() / Spawning enemies
• getWorldPosition() function / Use case – In-game sound effects
• GL Shading Language (GLSL) / Shaders
• GLSL
  • about / Shaders
  • URL, for tutorial / The bloom effect
• graphics
  • about / Graphics
• graphics module, SFML / Introducing SFML
• graphics processing unit (GPU) / OpenGL and graphics cards
• GUI
  • about / The GUI hierarchy, the Java way
• guide function / Adding projectiles
• guideTowards() function / Homing missiles

H

• handleEvent() function / Main menu, Pausing the game, The GUI hierarchy, the Java way, The promised key bindings
• handleEvent() method / Input
• handlePacket() function / Taking a peek in the other end – the client
• handlePlayerInput() function / Input over several frames, Getting the input state in real time
• hitpoints
  • about / Introducing hitpoints
• hot seat / Hot Seat

I

• identifier parameter / Generalizing the approach
• image
  • about / Images
• initializePickupData() function / Picking up some goodies
• InitialState / Studying our protocol
• input
  • handling / Input
• input state
  • obtaining, in real time / Getting the input state in real time
• IP
  • about / TCP
• isButtonPressed() function / Getting the input state in real time
• isDestroyed() function / Cleaning everything up
• isGuided() function / Homing missiles
• isKeyPressed() function / Getting the input state in real time
• isMarkedForRemoval() function / Cleaning everything up
• isSelectable() function / The GUI hierarchy, the Java way
• isSupported() function / Fullscreen post effects
• iterator class / An outlook on optimizations

J

• joystick events, SFML
  • sf**Event**JoystickButtonPressed / Joystick events
  • sf**Event**JoystickButtonReleased / Joystick events
  • sf**Event**JoystickMoved event / Joystick events
  • sf**Event**JoystickDisconnected / Joystick events
  • sf**Event**JoystickConnected / Joystick events

K

• key bindings
  • customizing / Customizing key bindings
  • about / The promised key bindings
• keyboard events, SFML
  • sf**Event**KeyPressed / Keyboard events
  • sf**Event**KeyReleased / Keyboard events
  • sf**Event**TextEntered / Keyboard events

L

• lambda expression / Node insertion and removal
• Landscape
  • rendering / Landscape rendering
  • SpriteNode / SpriteNode
  • texture / Landscape texture
  • texture, repeating / Texture repeating
• latency
  • about / Latency
  • versus bandwidth / Latency versus bandwidth
  • Aircraft interpolation / Aircraft interpolation
• LaunchMissile / Firing bullets and missiles
• launchMissile() function / Firing bullets and missiles
• layer / Scene layers
• listener
  • about / The listener
  • 3D vectors / The listener
  • positioning / Positioning the listener
• load() function / A special case – sf::Shader
• load() method / Generalizing the approach
• loadFromFile() call / A special case – sf::Shader
• loadFromStream() / Resources in SFML
• LoadingState$$update() / Task implementation
• LoadingState class / The loading screen – sample
• Local Area Network (LAN)
  • about / Playing multiplayer games
• low-level rendering
  • about / Low-level rendering

M

• main() function / The Game class, The run() method
• main loop
  • about / Game loops and frames
• menu
  • updating / Updating the menu
• mFilenames variable / Music themes
• minimum distance
  • about / Attenuation factor and minimum distance
• missiles
  • firing / Firing bullets and missiles
• MissionSuccess / Studying our protocol
• mLoadingText function / Progress bar
• modulo operator / Movement patterns
• mOptionIndex integer variable / Main menu
• mouse
  • delta movement / Delta movement from the mouse
• mouse events, SFML
  • sf**Event**MouseEntered / Mouse events
  • sf**Event**MouseLeft / Mouse events
• move() function / Input over several frames
• movement / Vector algebra
• movement patterns
  • about / Movement patterns
• mSelectedChild variable / The GUI hierarchy, the Java way
• multiplayer games
  • playing / Playing multiplayer games
  • structure, creating / Creating the structure for multiplayer
• music
  • about / Music
• MusicPlayer$$play() method / Loading and playing
• music themes
  • about / Music themes
  • playing / Loading and playing
  • loading / Loading and playing

N

• network, architecture
  • about / Network architectures
  • peer-to-peer / Peer-to-peer
  • client-server architecture / Client-server architecture
  • authoritative servers / Authoritative servers
• network module, SFML / Introducing SFML
• network port
  • about / TCP
• new operator / The GUI hierarchy, the Java way
• notifyGameAction() method / Transmitting game actions via network nodes
• nullptr / Scene nodes

O

• Open Audio Library (OpenAL)
  • about / Sounds in 3D space
• openFromFile() method / Compatibility with sf::Music
• OpenGL
  • about / OpenGL and graphics cards
  • URL / Shaders
• open type fonts (OTF) / Fonts
• overload function / Getting the input state in real time

P

• packet
  • about / Data transport
• packets / Incoming packets
• ParallelTask. LoadingState / The loading screen – sample
• ParallelTask class / The loading screen – sample
• ParallelTask object / ParallelTask
• particle nodes
  • about / Particle nodes
• particles
  • about / Particle systems, Particles and particle types
  • rendering, on screen / Particle nodes
  • embedding / Embedding particles in the world
• particle system
  • about / Particle systems
• particle types
  • about / Particles and particle types
• pause() method / Loading and playing
• pause state / The new pause state
• PauseState class / Pausing the game
• PauseState constructor / Use case – In-game themes
• PauseState destructor / Use case – In-game themes
• play() function / Playing spatial sounds
• Player**isRealtimeAction() function / Customizing key bindings
• Player class
  • about / Why a player is not an entity
• PlayerConnect / Studying our protocol
• PlayerEven / Studying our protocol
• PlayerEvent parameter / Client packets
• player input
  • handling / Handling player input
• PlayerRealtimeChange / Studying our protocol
• PlayerRealtimeChange parameter / Client packets
• playLocalSound() method / Use case – In-game sound effects
• pollEvent() function / Polling events
• pop operations
  • delayed / Delayed pop/push operations
• popState() function / Delayed pop/push operations
• position, 3D vectors / The listener
• PositionUpdate parameter / Client packets
• PostEffect**applyShader() function / Fullscreen post effects
• post rendering
  • about / Post effects and shaders
• prepareTextures() function / The bloom effect
• primitive type
  • about / Vertex arrays
• processEvents() function / The Game class
• processEvents() method / Fixed time steps
• projectiles
  • adding / Adding projectiles
• push operations
  • delayed / Delayed pop/push operations
• pushState() function / Delayed pop/push operations

Q

• quad tree
  • about / View optimizations
• Quadtrees / An outlook on optimizations
• quit parameter / Client packets

R

• RAII
  • about / An automated approach
• real-time rendering
  • about / Real-time rendering
• receiver categories / Receiver categories
• relative position / Relative coordinates
• removeStoppedSounds() method / Removing sounds
• render() function / The Game class, Adapting the code
• render() method / The Game class, Fixed time steps
• render target
  • about / Understanding render targets
• render texture
  • about / Understanding render targets
• render window
  • about / Understanding render targets
• RequestCoopPartner parameter / Client packets
• requestStackClear() / Delayed pop/push operations
• requestStackPop() / Delayed pop/push operations
• requestStackPush() / Delayed pop/push operations
• resolution
  • about / Resolution and aspect ratio
• ResourceHolder / Generalizing the approach
• ResourceHolder$$load() function / A special case – sf::Shader
• ResourceHolder class template / A special case – sf::Shader
• resource parameter / Generalizing the approach
• resources
  • defining / Defining resources
  • in SFML / Resources in SFML
  • acquiring / Acquiring, releasing, and accessing resources
  • releasing / Acquiring, releasing, and accessing resources
  • accessing / Acquiring, releasing, and accessing resources
• rotation / SFML and transforms
• round-trip time / Latency
• run() function / The Game class, Game loops and frames

S

• -s postfix / Downloading and installation
• sample, loading screen
  • about / The loading screen – sample
  • progress bar / Progress bar
  • ParallelTask / ParallelTask
  • thread / Thread
  • concurrency / Concurrency
  • task, implementing / Task implementation
• scale / SFML and transforms
• scene
  • rendering / Rendering the scene
  • origin, aligning / Aligning the origin
  • layers / Scene layers
  • updating / Updating the scene
• scene graph
  • about / Scene graphs
• SceneNode
  • TopicnSceneNodeisDestroyed() function / Cleaning everything up
• SceneNode**onCommand() function / Command execution
• SceneNode class / One step back – absolute transforms, Receiver categories
• scene nodes
  • about / Scene graphs, Scene nodes
  • inserting / Node insertion and removal
  • removing / Node insertion and removal
  • making drawable / Making scene nodes drawable
• selectNext() function / The GUI hierarchy, the Java way
• selectPrevious() function / The GUI hierarchy, the Java way
• Separating Axis Theorem / Collision detection and response
• server
  • about / Working with the Server
  • thread / Server thread
  • loop / Server loop
  • peers and artifacts / Peers and aircraft
  • hot seat / Hot Seat
  • new clients, accepting / Accepting new clients
  • disconnections, handling / Handling disconnections
  • packets, incoming / Incoming packets
  • protocol / Studying our protocol
  • ticks and updates / Understanding the ticks and updates
  • synchronization, issues / Synchronization issues
• server packet
  • BroadcastMessage / Studying our protocol
  • SpawnSelf / Studying our protocol
  • InitialState / Studying our protocol
  • PlayerEven / Studying our protocol
  • PlayerRealtimeChange / Studying our protocol
  • PlayerConnect / Studying our protocol
  • PlayerDisconnect / Studying our protocol
  • AcceptCoopPartne / Studying our protocol
  • SpawnEnemy / Studying our protocol
  • SpawnPickup / Studying our protocol
  • UpdateClientState / Studying our protocol
  • MissionSuccess / Studying our protocol
• setAttenuation() method / Attenuation factor and minimum distance
• setBuffer() method / Loading, inserting, and playing
• setCompletion() method / Progress bar
• setDirection() method / The listener
• set function / Entities
• setMinDistance() method / Attenuation factor and minimum distance
• setOrigin() / SFML and transforms
• setPosition() method / The listener
• SettingsState class / The promised key bindings
• setVelocity() method / Entities
• sf$$Event$$Closed event / A minimal example
• sf$$Event object / Input over several frames
• sf$$Font class / Fonts
• sf$$Music class / Music, Loading and playing
  • compatibility with / Compatibility with sf::Music
• sf$$Mutex and sf$$Lock / Concurrency
• sf$$Mutex object / Task implementation
• sf$$RenderWindow$$display() function / Real-time rendering
• sf$$RenderWindow$$draw() method / The Game class
• sf$$RenderWindow$$setVerticalSyncEnabled() methd / Other techniques related to frame rates
• sf$$Shader class / A special case – sf::Shader
• sf$$sleep() function / Other techniques related to frame rates
• sf$$SocketSelector class / Socket selectors
• sf$$Sound constructor / Loading, inserting, and playing
• sf$$Sound object / Sound buffers
• sf$$Sprite class / Textures, SpriteNode
• sf$$TcpListener$$accept() function / Accepting new clients
• sf$$TcpSocket$$receive() function / Incoming packets
• sf$$Texture$$loadFromFile() method / Error handling
• sf$$Texture$$loadFromX() function / Images
• sf$$Texture$$setRepeated(bool) function / Texture repeating
• sf$$Texture class / Displaying sprites on the screen
• sf$$Thread$$launch() / Thread
• sf$$UdpSocket$$bind() function / UDP
• sf**Event**Closed event / Window events
• sf**Event**GainedFocus event / Window events, Playing nice with your application neighborhood
• sf**Event**JoystickButtonEvent data structure / Joystick events
• sf**Event**JoystickButtonPressed event / Joystick events
• sf**Event**JoystickButtonReleased event / Joystick events
• sf**Event**JoystickConnected event / Joystick events
• sf**Event**JoystickConnectEvent data type / Joystick events
• sf**Event**JoystickDisconnected event / Joystick events
• sf**Event**JoystickMoved event / Joystick events
• sf**Event**JoystickMoveEvent data structure / Joystick events
• sf**Event**KeyEvent data structure / Keyboard events
• sf**Event**KeyEvent data type / Keyboard events
• sf**Event**KeyPressed event / Keyboard events
• sf**Event**KeyReleased event / Keyboard events
• sf**Event**LostFocus event / Window events, Playing nice with your application neighborhood
• sf**Event**MouseButtonEvent structure / Mouse events
• sf**Event**MouseButtonPressed type / Mouse events
• sf**Event**MouseButtonReleased type / Mouse events
• sf**Event**MouseEntered event / Mouse events
• sf**Event**MouseLeft event / Mouse events
• sf**Event**MouseMoved data type / Mouse events
• sf**Event**Resized event / Window events
• sf**Event**SizeEvent data type / Window events
• sf**Event**TextEntered event / Keyboard events
• sf**Event**TextEvent data structure / Keyboard events
• sf**Event**type member variable / Polling events
• sf**Event variable / Polling events
• sf**Joystick class / Getting the input state in real time
• sf**Keyboard class / Getting the input state in real time
• sf**Mouse class / Getting the input state in real time, Delta movement from the mouse
• sf**MouseMoveEvent data structure / Mouse events
• sf**RenderWindow class / Polling events
• sf**Shape class / Low-level rendering
• sf**Sprite class / Defining texture atlases, Low-level rendering
• sf**Text class / Low-level rendering
• sf**Window**pollEvent() function / Polling events
• sf**Window class / Polling events
• SFML
  • about / Introducing SFML, Polling events
  • system module / Introducing SFML
  • window module / Introducing SFML
  • graphics module / Introducing SFML
  • audio module / Introducing SFML
  • network module / Introducing SFML
  • URL / Introducing SFML
  • pre-built libraries, downloading / Downloading and installation
  • minimal example / A minimal example
  • events / Input over several frames
  • API documentation, URL / Summary
  • and transforms / SFML and transforms
  • window events / Window events
  • joystick events / Joystick events
  • keyboard events / Keyboard events
  • mouse events / Mouse events
  • input state, obtaining in real time / Getting the input state in real time
• SFML resources
  • about / Resources in SFML
  • textures / Textures
  • images / Images
  • fonts / Fonts
  • shaders / Shaders
  • sound buffers / Sound buffers
  • music / Music
• shader
  • about / Shaders
• shaders
  • about / Shaders
• sockets
  • about / Interacting with sockets
  • selectors / Socket selectors
• SoundBufferHolder$$load() function / Loading, inserting, and playing
• sound buffers
  • about / Sound buffers
• SoundEffect$$ID enumerator / Loading, inserting, and playing
• sound effects
  • about / Sound effects
  • class, implementing / Sound effects
  • loading / Loading, inserting, and playing
  • playing / Loading, inserting, and playing
  • inserting / Loading, inserting, and playing
  • removing / Removing sounds
  • GUI sounds, use case / Use case – GUI sounds
• SoundNode$$playSound() function / Use case – In-game sound effects
• SoundPlayer object / Use case – GUI sounds
• spatializing
  • about / Sounds in 3D space
• spatial sounds
  • playing / Playing spatial sounds
• spawnEnemies() function / Understanding the ticks and updates
• SpawnEnemy / Studying our protocol
• SpawnPickup / Studying our protocol
• spawnPickups() function / Understanding the ticks and updates
• SpawnSelf / Studying our protocol
• SpriteNode / SpriteNode
• sprites
  • displaying, on screen / Displaying sprites on the screen
• sprite sheet
  • about / Defining texture atlases
• stack
  • integrating, in Application class / Integrating the stack in the Application class
• state
  • defining / Defining a state
  • context / The state context
  • navigating between / Navigating between states
  • game state, creating / Creating the game state
  • title screen / The title screen
  • main menu / Main menu
  • game, pausing / Pausing the game
• State$$Context class / Use case – In-game themes
• State$$Context structure / Use case – GUI sounds
• state stack
  • about / The state stack
  • states, adding to / Adding states to StateStack
  • input, handling / Input
  • update, handling / Update
  • draw, handling / Draw
• StateStack$$registerState() / Adding states to StateStack
• StateStack class / The state stack, Adding states to StateStack
  • states, adding to / Adding states to StateStack
• std$$array function / Composing our world
• std$$bind() call / Use case – In-game sound effects
• std$$function / Adding states to StateStack
• std$$function class / The GUI hierarchy, the Java way
• std$$list$$remove_if() method / Removing sounds
• std$$make_shared() function / The GUI hierarchy, the Java way
• std**bind() function / Introducing commands
• std**function class / Introducing commands
• stop() method / Loading and playing
• strongly typed enumerations
  • about / Finding an appropriate container
• system module, SFML / Introducing SFML

T

• TCP
  • about / TCP
  • features / TCP
• Texel
  • about / Texture mapping
• texture atlas
  • about / Defining texture atlases
  • defining / Defining texture atlases
  • game code, adapting / Adapting the game code
• TextureHolder class / Connecting entities with resources
• texture mapping
  • about / Texture mapping
• texture rectangle
  • about / Defining texture atlases
• textures
  • about / Textures
  • accessing / Accessing the textures
• thread / Thread
• tick rate / Server loop
• tile set
  • about / Defining texture atlases
• timedOut variable / Peers and aircraft
• timeout / Handling disconnections
• TimePerFrame / Fixed time steps
• time step / Frame-independent movement
• title screen / The title screen
• toString() function / Displaying text
• transform / SFML and transforms
• transforms
  • about / One step back – absolute transforms
• translation / SFML and transforms
• true type fonts (TTF) / Fonts
• typedef / Vector algebra
• type inference / Accessing the textures

U

• UDP
  • about / UDP
• unique pointers / Finding an appropriate container
• unitVector() function / Homing missiles
• up, 3D vectors / The listener
• update
  • handling / Update
• update() function / The Game class, Input over several frames, Frame-independent movement, Pausing the game, Firing bullets and missiles, Cleaning everything up, Taking a peek in the other end – the client
• update() method / Fixed time steps, Update and draw
• UpdateClientState / Studying our protocol
• updateCurrent() function / Homing missiles
• updateLabels() function / The promised key bindings
• updateLogic() function / Server loop
• use case
  • in-game themes / Use case – In-game themes
  • in-game sound effects / Use case – In-game sound effects
• user tabs
  • interacting, with other applications / Playing nice with your application neighborhood

V

• V-Sync / Other techniques related to frame rates
• vector algebra
  • about / Vector algebra
• vectors
  • about / Vector algebra
• vertex
  • about / Texture mapping
• vertex array
  • about / Vertex arrays
• video memory
  • about / OpenGL and graphics cards
• view
  • about / The view
  • Viewport / Viewport
  • optimizing / View optimizations
  • scrolling / View scrolling
  • zooming / Zoom and rotation
  • rotating / Zoom and rotation
• Viewport / Viewport
• visual effects
  • about / Particle systems

W

• waitEvent() function / Polling events
• window class / Making scene nodes drawable
• window events, SFML
  • sf**Event**Closed / Window events
  • sf**Event**Resized / Window events
  • sf**Event**LostFocus / Window events
  • sf**Event**GainedFocus / Window events
• window module, SFML / Introducing SFML
• world
  • composing / Composing our world
  • initialization / World initialization
  • textures, loading / Loading the textures
  • scene, building / Building the scene
  • draw() method / Update and draw
  • update() method / Update and draw
• World$$update() function / The final update
• World class / Spawning enemies