Game Development Patterns with Godot 4

Cover
Copyright
Contributors
Table of Contents
Preface
Part 1: Object-Oriented Design Principles
Chapter 1: Understanding Object-Oriented Design
	Technical requirements
	Learning the basics of OOP
	Complying with the principles of OOP
	Designing games with OOP
	Turning your design into an object in Godot Engine
	Summary
Chapter 2: Learning the Four Fundamental Pillars
	Technical requirements
	Simplifying complex systems with abstraction
	Scoping properties and methods with encapsulation
	Extending an object’s behaviors with inheritance
	Maintaining compatibility with polymorphism
	Summary
Chapter 3: Creating SOLID Design Solutions
	Unbloating objects with the SRP
	Maintaining and extending objects with the OCP
	Ensuring compatibility with the LSP
	Creating components with the ISP
	Making high-level abstractions with the DIP
	Summary
Chapter 4: Favoring Composition Over Inheritance
	Technical requirements
	Understanding the composition approach
	Creating complex scenes by composing with nodes
		Turning a behavior into a component
	Making games by composing with scenes
		Creating the LootBumpingPig
	Summary
Part 2: Basic Design Patterns
Chapter 5: Maintaining Global States with the Singleton Pattern
	Technical requirements
	Understanding the Singleton pattern
	Spotting use cases of singletons in games
		Maintaining players’ data throughout the game states
		Playing background music without interruptions
		Using third-party APIs and plugins
		Accessing the engine’s built-in features
	Implementing the Singleton pattern in Godot
		Understanding the designer’s request
		Creating the score system
		Implementing the multi-door teleporting system
	Summary
Chapter 6: Decoupling Objects with the Observer Pattern
	Technical requirements
	Understanding the Observer pattern
	Spotting use cases for the Observer pattern
	Implementing the Observer pattern in Godot
		Integrating the player’s health interface
	Summary
Chapter 7: Spawning Game Objects with the Factory Pattern
	Technical requirements
	Understanding the Factory pattern
	Spotting use cases for the Factory pattern
	Implementing the Factory pattern in Godot
		Creating the Node2DFactory class
		Using Node2DFactory in our game
	Summary
Chapter 8: Changing Object Behavior with the State Pattern
	Technical requirements
	Understanding the State pattern
	Spotting use cases of the State pattern in games
	Implementing the State pattern in Godot
		Understanding the designer’s requirements
		Implementing an FSM with animations
		Handling state-specific behaviors with the State pattern
	Summary
Chapter 9: Designing Actors with the Command Pattern
	Technical requirements
	Understanding the Command pattern
	Spotting use cases for the Command pattern
		Using commands such as undo/redo in level editors
		Queuing commands in real-time strategy games
		Creating strategic encounters in role-player games
		Making template behaviors in RPGs
		Backtracking actions in tactical RPG battles
	Implementing the Command pattern in Godot
		Evaluating the game designer’s changes
		Creating the BumpingPig commands
		Using commands with buttons
		Implementing the concrete commands
		Mapping the commands to buttons
		Designing the Bumping Pig brain
	Summary
Part 3: Advanced Design Patterns
Chapter 10: Implementing AI with the Strategy Pattern
	Technical requirements
	Understanding the Strategy pattern
	Spotting use cases for the Strategy pattern
	Implementing the Strategy pattern in Godot
		Creating the InteractionStrategy family
		Using the target object to provide a strategy
		Cleaning up the Brain class with strategy executions
		Implementing interaction strategies
	Summary
Chapter 11: Creating a Power-Up System with the Decorator Pattern
	Technical requirements
	Understanding the Decorator pattern
	Spotting use cases for the Decorator pattern
	Implementing the Decorator pattern in Godot Engine
		Turning properties into the Stats class
		Creating our StatsDecorator class
		Wrapping Stats with the power-ups Singleton
		Using Diamond objects to add power-ups
	Summary
Chapter 12: Cross-Fading Transitions with the Service Locator Pattern
	Technical requirements
	Understanding the Service Locator pattern
	Spotting use cases for the Service Locator pattern
	Implementing the Service Locator pattern in Godot Engine
		Creating the BackgroundMusic Service Locator
		Using the BackgroundMusic Service Locator
	Summary
Chapter 13: Improving Game Feel with the Event Queue Pattern
	Technical requirements
	Understanding the Event Queue pattern
	Spotting use cases for the Event Queue pattern
	Implementing the Event Queue pattern in Godot
		Storing input events with an input buffer
		Buffering and processing jumps
	Summary
Index
Other Books You May Enjoy