8. Developing the State Machine
by Terry Norton
Learning C# by Developing Games with Unity 3D Beginner's Guide
- Learning C# by Developing Games with Unity 3D Beginner's Guide
- Table of Contents
- Learning C# by Developing Games with Unity 3D Beginner's Guide
- Credits
- About the Author
- About the Reviewers
- www.PacktPub.com
- Preface
- 1. Discovering Your Hidden Scripting Skills
- Prerequisite knowledge for using this book
- Dealing with scriptphobia
- Choosing to use C# instead of UnityScript
- Maneuvering around Unity's documentation
- Time for action – opening the Reference Manual documentation for the transform Component
- Time for action – opening the scripting reference documentation for the transform component
- Working with C# script files
- Time for action – create a C# script file
- Time for action – opening LearningScript in MonoDevelop
- Summary
- 2. Introducing the Building Blocks for Unity Scripts
- Using the term method instead of function
- Understanding what a variable does in a script
- Time for action – creating a variable and seeing how it works
- Time for action – changing the number 9 to a different number
- Using a method in a script
- Time for action – learning how a method works
- Introducing the class
- By using a little Unity magic, a script becomes a Component
- Components communicating using the Dot Syntax
- Summary
- 3. Getting into the Details of Variables
- Writing C# statements properly
- Understanding Component properties in Unity's Inspector
- Displaying public variables in the Inspector panel
- Time for action – making a variable private
- Naming your variables properly
- Declaring a variable and its type
- Time for action – assigning values while declaring the variable
- Summary
- 4. Getting into the Details of Methods
- Ending a method definition using curly braces
- Using methods in a script
- Naming methods properly
- Defining a method properly
- Time for action – adding code between the parentheses
- Calling a method
- Returning a value from a method
- Time for action – returning a value from AddTwoNumbers()
- Using Unity's Update and Start methods
- Summary
- 5. Making Decisions in Code
- Testing conditions with an if statement
- Time for action – create a couple of if statements
- Time for action – create if statements with more than one condition to check
- Using an if-else statement to execute alternate code
- Time for action – add "else" to the if statement
- Making decisions based on user input
- Storing data in an array, a List, or a Dictionary
- Time for action – create a List of pony names
- Time for action – create a dictionary of pony names and keys
- Time for action – adding ponies using a Collection Initializer
- Looping though lists to make decisions
- Time for action – using foreach loops to retrieve data
- Time for action – selecting a pony from a List using a for loop
- Time for action – finding data and breakout of the while loop
- Summary
- 6. Using Dot Syntax for Object Communication
- Using Dot Syntax is like addressing a letter
- Working with objects is a class act
- Using Dot Syntax in a script
- Time for action – accessing a variable in the current Component
- Time for action – communicating with another Component on the Main Camera
- Time for action – creating two GameObjects and a new script
- Accessing GameObjects using drag-and-drop versus writing code
- Time for action – trying drag-and-drop to assign a GameObject
- Summary
- 7. Creating the Gameplay is Just a Part of the Game
- Applying your new coding skills to a State Machine
- Understanding the concepts of a State Machine
- Following the State Machine logic flow
- Creating Components objects and C# objects
- Time for action – creating a script and a class
- Time for action – instantiating the BeginState class
- Introducing the C# interface
- Time for action – implementing an interface
- Summary
- 8. Developing the State Machine
- Creating four State classes
- Time for action – modifying BeginState and add three more States
- Setting up the StateManager controller
- Time for action – modify StateManager
- Time for action – modifying PlayState to add another State
- Time for action – adding OnGUI to StateManager
- Changing the active State and controlling the Scene
- Time for action – adding GameObjects and a button to the Scene
- Time for action – adding code to pause the game Scene
- Time for action – creating a timer in BeginState
- Changing Scenes
- Time for action – setting up another Scene
- Time for action – adding the Awake method to StateManager
- Time for action – adding the code to change the Scenes
- Summary
- 9. Start Building a Game and Get the Basic Structure Running
- Easing into Unity's scripting documentation
- Setup the State Machine and add a Player GameObject
- Time for action – setting up nine States and three Scenes
- Time for action - adding a Player GameObject
- Time for action – creating a GameData script
- Controlling the Player GameObject
- Time for action – rotating Player in SetupState
- Time for action – changing the color using GUI buttons
- Time for action – setting the Lives for Player
- Summary
- 10. Moving Around, Collisions, and Keeping Score
- Visualizing the completed game
- Switching to the first play State and playable scene
- Adding cameras for different viewing options
- Time for action – setting up two additional cameras in the scene
- Time for actioning – attach the LookAtPlayer camera script
- Time for action – attaching the FollowingPlayer camera script
- Moving the Player using Rigidbody physics
- Time for action – adding a Rigidbody to the Player
- Keeping score during the game
- Time for action – creating a good and bad prefab
- Shooting projectiles at the orbs
- Time for action – creating the EnergyPulse prefab
- Summary
- 11. Summarizing Your New Coding Skills
- A. Initial State Machine files
- B. Completed code files for Chapters 9 and 10
- BeginState
- SetupState
- PlayStateScene1_1: (1 of 2 available States in Scene1)
- PlayStateScene1_2: (2 of 2 available States in Scene1)
- WonStateScene1
- LostStateScene1
- PlayStateScene2
- WonStateScene2
- LostStateScene2
- StateManager
- PlayerControl
- GameData
- LookAtPlayer
- FollowingPlayer
- EnergyPulsePower
- IStateBase
- C. Pop Quiz Answers
- Chapter 1, Discovering Your Hidden Scripting Skills
- Chapter 2, Introducing the Building Blocks for Unity Scripts
- Chapter 3, Getting into the Details of Variables
- Chapter 4, Getting into the Details of Methods
- Chapter 5, Making Decisions in Code
- Chapter 6, Using Dot Syntax for Object Communication
- Chapter 7, Creating the Gameplay is Just a Part of the Game
- Chapter 8, Developing the State Machine
- Chapter 9, Start Building a Game and Get the Basic Structure Running
- Chapter 10, Moving Around, Collisions, and Keeping Score
- Index
It's time to code the State Machine so we can test its operation. We need to write the code for four initial States, the StateManager, and use the IStateBase interface. We will first have the State Machine work with three States and then show how easy it is to add in the fourth State.
Your Unity project may need more than four States. After you see how easy it is to add a State and how clean, simple, and organized it makes your code, your imagination may run wild on how you could make use of these States.
The whole purpose of Object Oriented Programming (OOP) is to create objects, (little packages of data) and action code (methods). In Unity, these objects are used for controlling actions in your Unity project, and they communicate with each other as well. A State Machine is simply a design choice for these objects that allows you to better organize and maintain your code.
The topics covered for the State Machine are as follows:
- Creating State classes
- The StateManager controller
- The active State and Unity's Scene
- Changing the Scenes
Well then, let's get stated...
As we create each State, you'll notice that each one is identical in structure. Again, this structure, this class interface, is guaranteed to be identical because implementing IStateBase makes it a requirement that certain methods are included in each State.
When we modify the StateManager, you'll see that it guarantees each State will implement the IStateBase interface as a requirement for being a part of the State Machine.
We already have BeginState started from the previous chapter, but it needs some modification to be functional in the State Machine. So let's modify BeginState first, and then create the other three States: PlayState, WonState, and LostState.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.