最新章節(jié)

• Summary
• Compiled versus scripting
• When to use C++
• Why use a scripting language?
• Just in time compilation
• Using interpreters

• Summary 更新時間：2021-07-02 23:44:17
• Compiled versus scripting
• When to use C++
• Why use a scripting language?
• Just in time compilation
• Using interpreters
• Introduction to scripting languages
• Introducing the compiler
• Moving to higher-level programming languages
• Introduction to assembly
• Learning when to use scripting in a game
• Meeting milestones
• Iteration
• Conducting a playtest
• Playtesting
• Prototyping
• Production phase
• The game development cycle
• Learning how iteration can improve your game and code design
• Problems with const
• Const member functions
• Const classes as parameters
• Const function parameters
• Learning and understand the uses of the const keyword
• Commenting
• Comments and self-documenting code
• Blank lines and spaces
• Indentation
• White space
• Avoid magic numbers
• Learning fundamental code quality techniques
• Your objectives
• Chapter overview
• Best Practices
• Summary
• Time-based movement
• Frame-based movement
• Time-based movement and animation
• LCD monitors
• Triple buffering
• VSync
• The back buffer
• Double buffering
• Refresh rate
• The horizontal and vertical blank
• What is a pixel?
• Introduction to monitor refresh rates
• Your objectives
• Chapter overview
• Understanding Graphics and Animation
• Summary
• Using the ParticleFactory
• Developing the ParticleFactory
• Creating different system types
• Transitioning to ParticleSystems
• Introduction to the Flyweight pattern
• Why memory is still an issue
• Implementing particles in Mach5
• Introductions to particles
• Your objectives
• Chapter overview
• Sharing Objects with the Flyweight Pattern
• Summary
• When to notify
• Implementing interfaces
• Overuse
• Dangling references
• Problems using the Observer pattern
• Benefits of using the Observer pattern
• Push versus Pull
• The Observers
• The Player
• The Subject and Observer
• The Observer pattern explained
• Polling
• Hardcoding requirements
• How gameplay creeps into every system
• Your objectives
• Chapter overview
• Decoupling Gameplay via the Observer Pattern
• Summary
• Using commands
• Easy UI with commands in Mach5
• Undo and redo
• Temporal decoupling
• Physically decoupling the client and the function call
• Treating a function call like an object
• The benefits of the command pattern
• Pointer to member command
• Pointers to member functions
• Two parameters and beyond
• The Command pattern explained
• Repeated code in the component
• Callback functions
• How can we control actions through buttons?
• Your objectives
• Chapter overview
• Controlling the UI via the Command Pattern
• Summary
• Issues with object pools
• Building the object pool for Mach5
• Operator overloading in C++
• Implementing a basic object pool
• The Object Pool pattern explained
• Why you should care about memory
• Your objectives
• Chapter overview
• Improving Performance with Object Pools
• Summary
• The object manager
• Archetype files
• Loading archetypes from a file
• Covariant return types
• Choosing a copy constructor
• Cloning an object
• The Gfx and collider components
• Examples of the clone method in Mach5
• It's easy to make exact copies
• No need to subclass
• We don't need to know the type
• The benefits of a virtual constructor
• The problem with constructors
• The virtual constructor
• The Prototype pattern explained
• Solution - reading from files
• Using builders with objects
• The trouble with using a factory for game objects
• Your objectives
• Creating Objects with the Prototype Pattern
• Summary
• Architecting versus over-architecting
• The Templated Factory
• Creating a component and Object Factory
• Using the Dynamic Factory
• Creating the Dynamic Factory class
• The template builder
• Creating our Stage Builders
• The Dynamic Factory
• The Static Factory
• The Factory method pattern
• The Dependency Inversion Principle
• The trouble with switch statements
• Your objective
• Chapter overview
• Decoupling Code via the Factory Method Pattern
• Summary
• Issues with FSMs
• The State pattern in action - StageManager
• The State pattern in action - the M5StateMachine class
• Expanding on the State Machine
• Issues with conditionals
• Acting on states
• An overview of enumerations
• Introduction to State Machines
• The State pattern explained
• Your objectives
• Chapter overview
• Artificial Intelligence Using the State Pattern
• Summary
• Performance concerns
• Creating and removing objects and components
• Implementing components
• Implementing the Component Object Model
• The Component Object Model explained
• The Decorator pattern explained
• The Strategy pattern explained
• The Strategy pattern and the Decorator pattern
• Avoiding the Diamond of Death
• Organizing the code by what it does not what it is
• Why inheritance hierarchies are inflexible
• The benefits of the monolithic game object
• The problem with object behavior
• The monolithic game object
• Why a monolithic game object is a bad design
• Your objectives
• Chapter overview
• Creating Flexibility with the Component Object Model
• Summary
• The Singleton in action - the Application class
• Advantages/disadvantages of using only one instance
• Templatizing Singletons
• Learning about templates
• Deleting our object correctly
• Keeping the single in Singleton
• What is a Singleton?
• Pros and cons of global variables
• Static as a file global variable
• Static keyword in class definitions
• Static keyword inside a function
• The static keyword
• An overview on class access specifiers
• Your objective
• Chapter overview
• One Instance to Rule Them All - Singletons
• Summary
• Setting up the project
• The problems with using design patterns in games
• Tools and utilities
• The graphics engine
• The ObjectManager
• The StageManager
• The app
• Mach5 core engines and systems
• The structure of the Mach5 engine
• The advantages of compartmentalizing code
• Understanding interfaces
• Polymorphism refresher
• An Introduction to interfaces
• Understanding the separation of concerns
• Separating the why and the how
• Implements
• Composition
• Aggregation
• Inheritance
• Relationships between classes
• Understanding UML class diagrams
• Why you should plan for change
• What are design patterns
• Your objective
• Chapter overview
• Introduction to Design Patterns
• Questions
• Piracy
• Errata
• Downloading the color images of this book
• Downloading the example code
• Customer support
• Reader feedback
• Conventions
• Who this book is for
• What you need for this book
• What this book covers
• Preface
• Customer Feedback
• www.PacktPub.com
• About the Reviewers
• About the Authors
• Credits
• 版權信息
• 封面

• 封面
• 版權信息
• Credits
• About the Authors
• About the Reviewers
• www.PacktPub.com
• Customer Feedback
• Preface
• What this book covers
• What you need for this book
• Who this book is for
• Conventions
• Reader feedback
• Customer support
• Downloading the example code
• Downloading the color images of this book
• Errata
• Piracy
• Questions
• Introduction to Design Patterns
• Chapter overview
• Your objective
• What are design patterns
• Why you should plan for change
• Understanding UML class diagrams
• Relationships between classes
• Inheritance
• Aggregation
• Composition
• Implements
• Separating the why and the how
• Understanding the separation of concerns
• An Introduction to interfaces
• Polymorphism refresher
• Understanding interfaces
• The advantages of compartmentalizing code
• The structure of the Mach5 engine
• Mach5 core engines and systems
• The app
• The StageManager
• The ObjectManager
• The graphics engine
• Tools and utilities
• The problems with using design patterns in games
• Setting up the project
• Summary
• One Instance to Rule Them All - Singletons
• Chapter overview
• Your objective
• An overview on class access specifiers
• The static keyword
• Static keyword inside a function
• Static keyword in class definitions
• Static as a file global variable
• Pros and cons of global variables
• What is a Singleton?
• Keeping the single in Singleton
• Deleting our object correctly
• Learning about templates
• Templatizing Singletons
• Advantages/disadvantages of using only one instance
• The Singleton in action - the Application class
• Summary
• Creating Flexibility with the Component Object Model
• Chapter overview
• Your objectives
• Why a monolithic game object is a bad design
• The monolithic game object
• The problem with object behavior
• The benefits of the monolithic game object
• Why inheritance hierarchies are inflexible
• Organizing the code by what it does not what it is
• Avoiding the Diamond of Death
• The Strategy pattern and the Decorator pattern
• The Strategy pattern explained
• The Decorator pattern explained
• The Component Object Model explained
• Implementing the Component Object Model
• Implementing components
• Creating and removing objects and components
• Performance concerns
• Summary
• Artificial Intelligence Using the State Pattern
• Chapter overview
• Your objectives
• The State pattern explained
• Introduction to State Machines
• An overview of enumerations
• Acting on states
• Issues with conditionals
• Expanding on the State Machine
• The State pattern in action - the M5StateMachine class
• The State pattern in action - StageManager
• Issues with FSMs
• Summary
• Decoupling Code via the Factory Method Pattern
• Chapter overview
• Your objective
• The trouble with switch statements
• The Dependency Inversion Principle
• The Factory method pattern
• The Static Factory
• The Dynamic Factory
• Creating our Stage Builders
• The template builder
• Creating the Dynamic Factory class
• Using the Dynamic Factory
• Creating a component and Object Factory
• The Templated Factory
• Architecting versus over-architecting
• Summary
• Creating Objects with the Prototype Pattern
• Your objectives
• The trouble with using a factory for game objects
• Using builders with objects
• Solution - reading from files
• The Prototype pattern explained
• The virtual constructor
• The problem with constructors
• The benefits of a virtual constructor
• We don't need to know the type
• No need to subclass
• It's easy to make exact copies
• Examples of the clone method in Mach5
• The Gfx and collider components
• Cloning an object
• Choosing a copy constructor
• Covariant return types
• Loading archetypes from a file
• Archetype files
• The object manager
• Summary
• Improving Performance with Object Pools
• Chapter overview
• Your objectives
• Why you should care about memory
• The Object Pool pattern explained
• Implementing a basic object pool
• Operator overloading in C++
• Building the object pool for Mach5
• Issues with object pools
• Summary
• Controlling the UI via the Command Pattern
• Chapter overview
• Your objectives
• How can we control actions through buttons?
• Callback functions
• Repeated code in the component
• The Command pattern explained
• Two parameters and beyond
• Pointers to member functions
• Pointer to member command
• The benefits of the command pattern
• Treating a function call like an object
• Physically decoupling the client and the function call
• Temporal decoupling
• Undo and redo
• Easy UI with commands in Mach5
• Using commands
• Summary
• Decoupling Gameplay via the Observer Pattern
• Chapter overview
• Your objectives
• How gameplay creeps into every system
• Hardcoding requirements
• Polling
• The Observer pattern explained
• The Subject and Observer
• The Player
• The Observers
• Push versus Pull
• Benefits of using the Observer pattern
• Problems using the Observer pattern
• Dangling references
• Overuse
• Implementing interfaces
• When to notify
• Summary
• Sharing Objects with the Flyweight Pattern
• Chapter overview
• Your objectives
• Introductions to particles
• Implementing particles in Mach5
• Why memory is still an issue
• Introduction to the Flyweight pattern
• Transitioning to ParticleSystems
• Creating different system types
• Developing the ParticleFactory
• Using the ParticleFactory
• Summary
• Understanding Graphics and Animation
• Chapter overview
• Your objectives
• Introduction to monitor refresh rates
• What is a pixel?
• The horizontal and vertical blank
• Refresh rate
• Double buffering
• The back buffer
• VSync
• Triple buffering
• LCD monitors
• Time-based movement and animation
• Frame-based movement
• Time-based movement
• Summary
• Best Practices
• Chapter overview
• Your objectives
• Learning fundamental code quality techniques
• Avoid magic numbers
• White space
• Indentation
• Blank lines and spaces
• Comments and self-documenting code
• Commenting
• Learning and understand the uses of the const keyword
• Const function parameters
• Const classes as parameters
• Const member functions
• Problems with const
• Learning how iteration can improve your game and code design
• The game development cycle
• Production phase
• Prototyping
• Playtesting
• Conducting a playtest
• Iteration
• Meeting milestones
• Learning when to use scripting in a game
• Introduction to assembly
• Moving to higher-level programming languages
• Introducing the compiler
• Introduction to scripting languages
• Using interpreters
• Just in time compilation
• Why use a scripting language?
• When to use C++
• Compiled versus scripting
• Summary 更新時間：2021-07-02 23:44:17