Physics in Unity rely on three main components. The \u201cRigidbody\u201d, which gives control of the object over to the physics system and allows forces such as collisions and gravity to apply; the \u201cCollider\u201d: a procedural or mesh volume that determines the physical \u201cshape\u201d of an object for collision detection; and the Physic Material which defines the physical properties of objects and determines how they should react during collisions.<\/p>\n\n\n\n
In Unity, most meshes (including all primitive objects) come with a Collider component already defined. This allows objects that are controlled by the physics systems to react and respond to the rest of our world, without having to subject them to the arduous calculations that would be required if they were moveable objects, each subject to forces and gravity.<\/p>\n\n\n\n
In our case, we only need to apply physics to one object here, our ball. We do this by adding a Rigidbody component<\/strong>, available by selecting Add Component > Physics > Rigidbody<\/strong>. As soon as we add this, we can run our game and if our ball is located outside of our plane, we see it fall away very slowly. (Or at least, it feels slow. The speed here is accurate as Unity\u2019s default gravity accelerates at 9.8 m\/s2<\/sup> just like real life. The \u201cslow\u201d here comes from our expectations of size \u2013 remember that our ball is 3 units in diameter, meaning it is ~10 feet high \u2013 but we expect it to be small like a ping pong ball and so our visual perception is that it is falling slowly).<\/p>\n\n\n\n Now, reposition the ball to the origin point (0,0,0) and run the game again. Hmm\u2026 it just sits there. And of course it does \u2013 we haven\u2019t done anything to make it move. Previously, we had to tell the ball to move in every frame. This time, we are going to give the ball one big push and let physics do the rest. Time to start a new script, but this time I placed it on an empty game object I created (GameObject > Create Empty).<\/strong> I named the object \u201cGameManager\u201d and called this script EasyPong<\/strong>, but you can name it whatever you want.<\/p>\n\n\n In this script, we declare a public GameObject variable so that we can make the assignment of the ball object to our script through the Inspector. Then we declare a private Rigidbody<\/strong> variable which will get the ball\u2019s Rigidbody component using the appropriately named GetComponent<Rigidbody> ( )<\/strong>. <\/p>\n\n\n\n At the end of our Start( ) <\/strong>function we call the AddForce( ) <\/strong>command to give our ball\u2019s rigidbody a push. Our variables for \u201cforce\u201d and \u201cdirection\u201d are also made public, so that we can adjust the force of that push in our Inspector. You might soon notice that your force requires a significantly high value in order to set the ball in motion. This is because there are different “force modes” that describe the manner which the force is being applied to the object. There are important distinctions to these, so it is important to understand when you might want to choose a particular option.<\/p>\n\n\n\n ForceMode <\/strong>is an enumeration of the options for applying a force to an object. Some use the object mass, while others treat all objects equally (like the accelerative force of gravity). The default option for AddForce <\/strong>is ForceMode.Force<\/strong>, where mass matters, and the force is applied over time, meaning that a single call of AddForce only sends a fraction of the value based upon the short time of frame. For our purposes, it is best to use an Instant force like ForceMode.Impulse<\/strong> or ForceMode.VelocityChange<\/strong>. <\/p>\n\n\n\n ForceMode Options<\/strong><\/p>\n\n\n\n From the Unity Scripting API<\/p>\nForce<\/a> We declare that like this: When we hit play, the ball starts moving. It collides with the paddle, then sort of sits there. If you watch this through the side view (I recommend selecting the ball object so that you can use the collision sphere widget to see how it is moving) you\u2019ll notice it is rolling over to the paddle, then gaining some friction and rolling slightly up the side of the paddle before falling down and coming to rest.<\/p>\n\n\n\n Obviously this is not the behavior we want, so we need to make a few changes. First, we should restrict the motion of our ball to the XZ plane to make sure we don\u2019t fly off the board. Do this by setting the Constraints<\/strong> in the Rigidbody controller of the ball. While you are there, restrict all rotation as well.<\/p>\n\n\n\n Next, we need to control how our object interacts with others. We do this by creating a Physic Material <\/strong>(in Assets > Create > Physic Material<\/strong>). Friction is what made the ball move, so we want to get rid of both Dynamic Friction<\/strong> (the friction that slows objects in motion) and the Static Friction<\/strong> (the friction that prevents objects from moving in the first place). Set both of these values to 0<\/strong>. Next, set our \u201cBounciness\u201d to 1<\/strong>, and our \u201cFriction Combine\u201d to Minimum<\/strong> and our \u201cBounce Combine\u201d to Maximum<\/strong>. The \u201cCombines\u201d are used to determine how to calculate these forces when multiple materials are present. \u201cMinimum\u201d uses the smaller value of the two, \u201cMaximum\u201d uses the larger. \u201cAverage\u201d and \u201cMultiply\u201d apply a combination of both. Apply this Physic Material to the ball by dragging it into the Material<\/strong> slot in the Sphere Collider<\/strong>.<\/p>\n\n\n\n Now when we hit play, our ball slides smoothly from paddle to paddle. Changing our direction lets us try a few more scenarios. Looking good! Now all we need to do is move the paddles<\/p>\n\n\n\n For our paddle object, we create a Prefab<\/strong> object by dragging one of our paddles into the Assets<\/strong> folder. This converts it into a saved object that we can Instantiate as a clone in our scene. We can make changes to the instances of a prefab that exist in our scene, or we can make edits to the original Prefab object that will propagate to the instances in our scene, unless the instance in the scene has modified that property or component. Modifications to the scene instances are called Overrides<\/strong>, and you can use the Inspector to visualize the difference between instance and source, and you can revert the instance or push your change back to the prefab if you choose to do so.<\/p>\n\n\n\n Prefabs are especially useful when we want to create instances of objects, and in this case we will use it to create two paddles that respond to input, rather than creating a master script to handle all inputs. This script we create will perform the same task, using the Update( ) <\/strong>method to test to see whether a particular set of buttons is being pressed, and then move the object accordingly.<\/p>\n\n\n\n First, I define two public strings, to hold the key codes for the keyboard buttons I intend to use for \u201cup\u201d and \u201cdown\u201d motion.<\/p>\n\n\n Next I define two private variables \u2013 one to regulate the speed of the paddles, and the other to create an offset value to restrict movement beyond a certain amount.<\/p>\n\n\n Then I edit the Update( )<\/strong> method to include the following code:<\/p>\n\n\n Walking through this line by line, first we get the position of the paddle by creating a Vector3 <\/strong> called currentPosition<\/strong> and assign it a value of \u201ctransform.position\u201d which is shorthand for \u201cthis.transform.position\u201d. This returns the current XYZ coordinates of the object.<\/p>\n\n\n\n Next, we test to see if the \u201cupButton\u201d and \u201cdownButton\u201d keys are pressed.\u00a0 We test both, using separate if statements, to make sure that we capture situations where both up and down are pressed at the same time.\u00a0 (If they are, their movements will cancel each other out and the paddle will remain still.)\u00a0 \u00a0 If we determine one of the buttons to be pressed, we either increase or decrease the \u201cz\u201d value of the position by an increment of\u00a0(<\/strong>speed * Time.deltaTime).\u00a0 \u00a0<\/strong>If you are curious why we do not just multiply by speed, it is because this script works like our ball and paddle movement in the previous week – we are manually moving every frame and framerates are not steady, so “deltaTime” converts our “speed” value into a distance that would be traveled at that speed.\u00a0 <\/p>\n\n\n\n Closing this out, we have this line: <\/p>\n\n\n Here we introduce the Mathf<\/strong> library (a library of math functions for floating point numbers) and the Clamp<\/strong> method, which allows us to set a minimum and maximum value and see if our value falls within that range, and if not returns one of those values instead. Now the paddle position will be constrained to move no farther than \u201coffset\u201d number of units from the 0 position.<\/p>\n\n\n\n Finally, we set\u00a0transform.position\u00a0<\/strong>to be equal to currentPosition. Note that we have to pass this value back \u2013 transform.position is not an object that can be held onto as a reference, it is a one-time get or set. Additionally, this can only be received or passed as a Vector3<\/strong> type, because that is what it is. We cannot set the individual parts of the struct<\/strong>, so trying to set “transform.position.x ” directly will return an error. For our script we must get it, adjust it, and then set it to our updated Vector3. <\/p>\n\n\n\n Now in your paddles, assign the left paddles buttons to \u201cw\u201d and \u201cs\u201d, and the right paddle to \u201cup\u201d and \u201cdown\u201d (which translate to the up and down arrows on the keypad), and we should be good to go.<\/p>\n\n\n\n It\u2019s fun to watch our ball bounce around, but we should add some sound to really make this pop.\u00a0 I\u2019ve uploaded\u00a0a few sounds to use for this demo<\/a>, feel free to use those or a noise of your own creation.\u00a0 Just remember, the sound should be quick, and the noise should start at the very beginning of the file, otherwise you\u2019ll have a brief period of dead air and it will appear as though the sound is delayed.\u00a0 Import your sound using\u00a0Assets > Import New Asset\u2026<\/strong>, or simply drag the files into the Assets folder.<\/p>\n\n\n\n Since the only thing in our current design that should make a noise is when the ball collides with something, I\u2019ve decided to assign all noise making duties to the ball itself. <\/p>\n\n\n\n In order to make sounds, an object must have the AudioSource Component<\/strong> attached to it, so I add one to the \u201cball\u201d object. When you add this component, you will notice an empty AudioClip<\/strong> property which is the audio file to be played \u2013 leave this empty, as we will fill it later using our script.You will also notice that, by default, Play On Awake<\/strong> is checked. De-select this option, as we will control when we want things to play.<\/p>\n\n\n\n We want our clip to play whenever the ball hits the paddle, so we need to figure out when that event occurs. To do this, we will test every collision that the ball experiences. <\/p>\n\n\n\n Whenever a collision occurs, the game generates a Collision Event<\/strong>. We can set our scripts to listen for these events and use them to perform actions, in this case playing our sound. Add a new script to the Ball object (I called mine BallScript<\/strong>. Add the following code for the variable declaration and Start ( )<\/strong> function:<\/p>\n\n\n Just like we created a Rigidbody typed variable, here we create an AudioSource<\/strong> type variable and assign it using GetComponent<AudioSource> ( )<\/strong>. Notice, however, that before we used a reference to a separate game object (\u201cballobject\u201d) as our source, and here we simply use \u201cthis\u201d. This<\/strong> gives us access to the object which it is running through. It is self-referential, so no extra association steps required.<\/p>\n\n\n\n Our next step is to identify when a collision occurs, then look to see if we have hit the right type<\/em> of collision.<\/p>\n\n\n OnCollisionEnter ( )<\/strong> runs when a collision event occurs involving this object \u2013 meaning that this object\u2019s collider has initiated contact with another object\u2019s collider. It is only called one time per collision. When the objects separate \/ stop touching, there is an OnCollisionExit ( )<\/strong> message that will be called. If objects remain in contact, OnCollisionStay ( )<\/strong> messages will issue once per frame.<\/p>\n\n\n\n Our collision event has a parameter that is of the type Collision<\/strong>, which here we assign to a variable \u201ccollision\u201d. This Collision object contains data about the collision, such as the point of contact, the object that was hit, and the relative velocity of the two objects. Here we test the Tag<\/strong> of the other object against a known value, and if it returns as true, we tell the audioSource to run the Play( ) <\/strong>command. <\/p>\n\n\n\n Unity projects have a few pre-existing tags that you can use, but I recommend creating your own.<\/p>\n\n\n\n Select your paddle prefab, and in the inspector look for the Tag<\/strong> dropdown near the top. In there, select Add New Tag\u2026<\/strong> and add a new named tag. Call this one \u201cWall\u201d. Now select your paddle again and from the dropdown give it the tag Wall<\/strong>. Now play your game and you should get a satisfying \u201cbonk\u201d noise when your ball hits a wall. Let’s look a little closer at the Audio Source component:<\/p>\n\n\n\n As the name suggests, this component makes our object the “source” of a bit of audio, by having it emit a sound. The sound that will be emitted is defined using the Audio Resource<\/strong> setting, which gives us access to the AudioSource.clip<\/strong> property. Once a clip has been set, we can use AudioSource.Play( )<\/strong> to play the sound, and AudioSource.Stop( )<\/strong> to stop it.<\/p>\n\n\n\n But the AudioSource is only one half of the equation. We also need to have an AudioListener<\/strong> <\/a>in our scene, to act as our “ears”. By default, the AudioListener is added as component on the Main Camera.<\/p>\n\n\n\n The reason this configuration makes sense is that your Main Camera is usually your best representation of where you as the observer are in relation to the world of the game itself. The Spatial<\/strong> slider in your AudioSource component allows you to set the sound to be:<\/p>\n\n\n\n One important note about an AudioSource – it can only play one clip at a time. If you have multiple clips that need to play simultaneously, you need multiple AudioSources, which means multiple objects.<\/p>\n\n\n\n In a future class, I will show you methods for creating a more sophisticated Sound Manager, but for now, we are going to make our different sounds by switching the clip on our ball’s AudioSource.<\/p>\n\n\n\n In our BallScript.cs script, we declare the following public AudioClip<\/strong> variables. This will create three audio clip slots in our script component in the Inspector, which we will fill with sounds from our Assets folder.<\/p>\n\n\n Next, we create a script to play the Paddle sound (as opposed to the default Wall sound)<\/p>\n\n\n Here we first issue a Stop( )<\/strong> command, in case something else is already playing. Next we set the clip<\/strong> for this AudioSource to be the sound we wish it to make, in this case the paddle sound. Finally, we issue the Play( )<\/strong> command which will cause the sound to start playback at the beginning.<\/p>\n\n\n Next we add similar functions for the paddle and back wall sounds. For these functions, we will use another method of AudioSource – PlayOneShot( )<\/a><\/strong><\/p>\n\n\n PlayOneShot( ) will load and play the included clip one time and immediately stop once it is complete. It is important to note that this will NOT change the value of our AudioSource.clip. If you ran the Play( )<\/strong> command after PlayOneShot( )<\/strong> the audio clip playing would be the same clip that was loaded before.<\/p>\n\n\n\n Finally, just for fun, we added increase in the Rigidbody.velocity<\/strong> of our ball object so that the ball speeds up each time it is hit by a paddle, and we also increased the value of AudioSource.pitch<\/strong> which will make the sounds move to a higher tone and reinforce that effect of more speed.<\/p>\n\n\n\n Right now our \u201cgame\u201d isn\u2019t much of a game yet. We are lacking the basic components of a game such as rules and objectives. We need to add the steps and stages and rules and mechanics that make this a game of Pong! rather than a really basic screensaver.<\/p>\n\n\n\n The goal of our game is for one player to win, which they do by scoring more points than their opponent. This objective implies that we need a method by which to score points, and multiple opportunities for players to score. A score is registered when the ball gets past and hits the wall behind the opposing player\u2019s paddle. In order to have multiple attempts, we need to create \u201crounds\u201d of playing through our core bouncing ball mechanic. Each round starts with the ball reset to the center, and ends when a score is registered.<\/p>\n\n\n\n Given that, we can generate a diagram of the \u201cflow\u201d of our game as such:<\/p>\n\n\n\n This is an example of a Finite State Machine<\/strong> \u2013 a model of our the logic of our game, where our game will inhabit only one state at a time, and certain conditions must be met to move or transition from state to state.<\/p>\n\n\n\n In our model, we can see the need for a few particular stages as we progress. First we have to set up or initialize a new game. This is where we will set our initial score of 0-0 and initialize all of the objects back into their start state. Next we have to set up the individual round. This state is separate from the initialize game state because we will return to this frequently as each new round begins. Here we expect to see behaviors like putting the ball back at the origin, and resetting any modifications that we made to the pitch of the sound or speed of the ball. Once the round begins, we enter the actual gameplay state, which continues until one side scores. Once a point is scored, we need to register that event and determine if someone has won the game, or if we need to reset our board and start a new round. If the objective number of points have been scored, it\u2019s time to declare a winner and move to a \u201cgame over\u201d state.<\/p>\n\n\n\n It is important to note that this is an abstract machine \u2013 we will use this model to code the states and transitions and object behaviors, but these components will be assembled through composite parts so that the preferred action occurs, rather than coding everything into one giant instruction set in one particular function.<\/p>\n\n\n\n Since we will share the responsibility for moving between states across the objects in our scene, we need a reliable method to get and set our current state. Traditionally one might use a string to hold a value so that it hold an easy to read value, or one might use an integer and assign values to each index so that the lookup is fast. Instead, we will use a method that combines the advantages of both \u2013 Enumeration<\/strong>.<\/p>\n\n\n\n Enumeration lets us define all of the possible values for a set, which fits very well when working with a finite number of states. An commonly given example of this would be to create an enumerated set of directions (north, east, south, west) so that the values are plain English, but are also the only possible values for the type.<\/p>\n\n\n\n In our case, we want to define some states for our game \u2013 setting up the game, getting a round ready, the actual gameplay itself, and finally the game over state. We define our enumeration by declaring a public\u00a0enum<\/strong>\u00a0outside of the GameManager <\/strong>class declaration in our project. This will make the type available to use across all scripts in our scene.<\/p>\n\n\n Now that I\u2019ve declare the enumerations, I can declare my own variable in the class and by default put it in the \u201cSetup\u201d state\u2026<\/p>\n\n\n Now we have something that we can test. Let\u2019s hop over to the PaddleScript to see an example of how we can use this\u2026<\/p>\n\n\n\n Last time, we left the instructions for moving the paddle inside of the Update( ) method, meaning that it would be called once per frame. But paddles should only move while the game is in play, not before or after the round. We want to constrict the paddle movement to only occur when the game state is set to \u201cplaying\u201d.<\/p>\n\n\n\n First, we take the contents of the Update( ) method and move them into a new void function called MovePaddle( )<\/strong>. We rewrite Update( ) to feature a check to see if the game state is set to \u201cGameState.Playing\u201d, and if it is, we run the MovePaddle( ) command.<\/p>\n\n\n If we try to run this now, Unity will be cross with us and we will get a Null Reference Exception, because we have no connection to the Game Manager object reference to the game manager to access the \u201cstate\u201d variable.<\/p>\n\n\n\n We could build a public GameObject variable and use our drag-and-drop method to connect the Game Manager object, but let\u2019s try another useful method \u2013 the <\/a>Find( )<\/a><\/strong> command<\/a>.<\/p>\n\n\n Here, we define a private object \u2013 an GameManager <\/strong>variable which we name game<\/strong> – this cleverly named variable will hold the reference to our Game Manager’s GameManager script. This is because we are specifically looking for the script component attached to the \u201cGameManagerObject\u201d object, and we need a place to hold it. The script is of the class GameManager, so the type we declare here has to match that.<\/p>\n\n\n\n Inside of the Start( ) method, we start to assign gameManager with GameObject.Find(\u201cGameManagerObject\u201d)<\/strong>, which\u00a0will return the first object in the scene that it finds with a matching name, and then we add GetComponent<GameManager>()<\/strong> on that result, and now we have direct access into the public variables and methods of that script.<\/p>\n\n\n\n Armed with this new information, we update our Update( ) \u201cif\u201d statement to read as follows:<\/p>\n\n\n NOTE:<\/strong> NOTE:<\/strong> Now go back to Unity and hit play to see what happens. If you have done this correctly, nothing should occur \u2013 the paddles should stay in the same place and be unresponsive to key presses. This is because our currentState <\/strong>value is not set to GameState.Playing<\/strong>. Because we made this public, we can change the setting in our Editor. You will see a dropdown for the Game State – set that to “Playing” and click on your game window and now your paddles should move.<\/p>\n\n\n\n Most games that we play in life will require some sort of preparation before the game itself can begin. Bases must be placed, cards must be dealt, game pieces must be distributed. Our game is no different – before we can play our game, we need to set the objects and attributes and place them into a ready state for play to begin.<\/p>\n\n\n\n In order for our game to have a winner, we need to be able to keep score. We also should have some definition of what “winning” is. (Here it will be the first player to reach 3 points.)<\/p>\n\n\n Here I set two float values for the player scores (putting both declarations on one line with a comma will create two variables of the same time) and a float variable the score limit. Our player one and two scores I will set in our Start( )<\/strong> menu because these could reset again, for instance when we restart the game.<\/p>\n\n\n In our start we reset the scores to 0, fetch the position of the ball object (so that we have a reference point to use once a round is over), and make sure the GameState is at “PreRound”. Finally, move to our next stage – starting an individual round, which we do with our new method InitializeRound( )<\/strong><\/p>\n\n\n\n The start of a new round, whether it is the first round or comes after a scoring event, consists of two primary steps:<\/p>\n\n\n\n To handle this, we created three new functions – InitializeRound( ), ResetBall( ), <\/strong>and StartBall( )<\/strong>. InitializeRound( ) will handle our initial setup of a new round. Here we should start in the \u201csetup\u201d stage. It will call ResetBall( ) for us, which will move the ball back to the origin, and reset any other modifications we made such as pitch modulation. Finally StartBall( ) will put the ball into motion.<\/p>\n\n\n\n public GameObject ballObject;\n private Rigidbody ballRigidbody;\n public float force;\n public Vector3 direction;\n\n \/\/ Start is called before the first frame update\n void Start()\n {\n ballRigidbody = ballObject.GetComponent<Rigidbody>(); \/\/ assign the rigidbody\n direction.Normalize(); \/\/ make the direction vector a heading \n ballRigidbody.AddForce(direction * force);\n }\n<\/pre><\/div>\n\n\n\n
Add a continuous force to the rigidbody, using its mass.
Acceleration<\/a>
Add a continuous acceleration to the rigidbody, ignoring its mass.
Impulse<\/a>
Add an instant force impulse to the rigidbody, using its mass.
VelocityChange<\/a>
Add an instant velocity change to the rigidbody, ignoring its mass.<\/cite><\/blockquote>\n\n\n\nballRigidbody.AddForce(direction * force, ForceMode.Impulse);<\/code><\/p>\n\n\n\n![\"\"](\"https:\/\/courses.etc.cmu.edu\/53-353\/wp-content\/uploads\/2024\/09\/image.png\")
<\/figure>\n\n\n\n![\"\"](\"https:\/\/courses.etc.cmu.edu\/53-353\/wp-content\/uploads\/2024\/09\/image-1.png\")
Part 2: Prefabs and Overrides<\/h3>\n\n\n\n
\npublic string upButton;\npublic string downButton;\n<\/pre><\/div>\n\n\n
\nprivate float speed = 50.0f;\nprivate float offset = 18.0f;\n<\/pre><\/div>\n\n\n
\nvoid Update()\n{\n Vector3 currentPosition = transform.position;\n\n if (Input.GetKey(upButton))\n {\n currentPosition.z += speed * Time.deltaTime;\n }\n\n if (Input.GetKey(downButton))\n {\n currentPosition.z -= speed * Time.deltaTime;\n }\n\n currentPosition.z = Mathf.Clamp(currentPosition.z, -offset, offset);\n\n transform.position = currentPosition;\n\n}\n<\/pre><\/div>\n\n\n\ncurrentPosition.z = Mathf.Clamp(currentPosition.z, -offset, offset);\n<\/pre><\/div>\n\n\n
Part 3: Detecting collisions and making noise<\/h3>\n\n\n\n
\nprivate AudioSource audio;\n\n\/\/ Start is called before the first frame update\nvoid Start()\n{\n audio = GetComponent<AudioSource>();\n}\n<\/pre><\/div>\n\n\n\nprivate void OnCollisionEnter(Collision collision)\n{\n if(collision.gameObject.tag == "Wall")\n {\n audio.Play();\n }\n}\n<\/pre><\/div>\n\n\n![\"\"](\"https:\/\/courses.etc.cmu.edu\/53-353\/wp-content\/uploads\/2024\/09\/image-2.png\")
<\/figure>\n\n\n\n![\"\"](\"https:\/\/courses.etc.cmu.edu\/53-353\/wp-content\/uploads\/2024\/09\/image-4.png\")
\n
\n public AudioClip wallSound;\n public AudioClip paddleSound;\n public AudioClip deathSound;\n<\/pre><\/div>\n\n\n
![\"\"](\"https:\/\/courses.etc.cmu.edu\/53-353\/wp-content\/uploads\/2024\/09\/image-5.png\")
<\/figure>\n\n\n\n\n private void MakeWallSound()\n {\n audio.Stop(); \/\/ stop the audio if it is already playing\n audio.clip = wallSound; \/\/ set the new clip\n audio.Play(); \/\/ play the new clip\n }\n<\/pre><\/div>\n\n\n\n private void OnCollisionEnter(Collision collision)\n {\n if (collision.gameObject.tag == "Wall")\n {\n \/\/ make the paddle sound\n MakeWallSound();\n } \n }\n<\/pre><\/div>\n\n\n\n private void MakePaddleSound()\n {\n audio.PlayOneShot(paddleSound); \/\/ play the paddle sound once\n }\n\n public void MakeDeathSound()\n {\n audio.PlayOneShot(deathSound); \/\/ play the death sound once\n }\n<\/pre><\/div>\n\n\nPart 4: The Finite State Engine<\/h3>\n\n\n\n
![\"\"](\"https:\/\/courses.etc.cmu.edu\/53-353\/wp-content\/uploads\/2023\/09\/image.png\")
<\/figure>\n\n\n\nEnumeration<\/h4>\n\n\n\n
\nusing System.Collections;\nusing System.Collections.Generic;\nusing UnityEngine;\n\npublic enum GameState { None, PreRound, Playing, PostRound, GameOver};\n\npublic class GameManager: MonoBehaviour\n{\n public GameObject ballObject;\n private Rigidbody ballRigidbody;\n ...\n<\/pre><\/div>\n\n\n\n \/\/ define my gamestate variable\n public GameState state = GameState.None;\n<\/pre><\/div>\n\n\n
\n void Update()\n {\n if (game.state == GameState.Playing)\n {\n MovePaddles();\n }\n }\n\n private void MovePaddles()\n {\n Vector3 currentPosition = transform.position; \/\/ get my position\n\n if (Input.GetKey(upButton))\n {\n currentPosition.z += speed * Time.deltaTime;\n }\n\n if (Input.GetKey(downButton))\n {\n currentPosition.z -= speed * Time.deltaTime;\n }\n\n currentPosition.z = Mathf.Clamp(currentPosition.z, -offset, offset);\n\n transform.position = currentPosition;\n }\n<\/pre><\/div>\n\n\n\n private EasyPong gameManager;\n\n \/\/ Start is called before the first frame update\n void Start()\n {\n \/\/ get the game manager object\n game = GameObject.Find("GameManagerObject").GetComponent<GameManager>(;\n }\n<\/pre><\/div>\n\n\n\nif (game.state == GameState.Playing)\n<\/pre><\/div>\n\n\n
Although we used a single variable here, we could have also done this by declaring a GameObject variable that we find, and then a second variable that uses GetComponent<> on the object we just retrieved. Both are valid methods, ours here just shortened the trip.<\/p>\n\n\n\n
You may have noticed the Debug.Log( )<\/strong> commands also used here. This is a function that allows you to print a message directly to the Log and the Console Window for debugging purposes. I tend to have these scattered throughout my code as they are useful for tracking down whether or not a particular function is being called, and what values are set at different locations. Note the use of the \u201c+\u201d symbol to concatenate a string with another value. More on Debug.Log( )\u2026<\/a><\/p>\n\n\n\nPart 5: Moving Through States<\/h3>\n\n\n\n
Initializing the Game<\/h4>\n\n\n\n
\n\/\/ score tracking\nprivate int playerOneScore, playerTwoScore;\n\nprivate int scoreLimit = 3;\n<\/pre><\/div>\n\n\n
\nvoid Start()\n{\n ballRigidbody = ballObject.GetComponent<Rigidbody>(); \/\/ assign the rigidbody\n\n \/\/ initialize the score\n playerOneScore = 0;\n playerTwoScore = 0;\n\n \/\/ get the start position of the ball\n ballStartPosition = ballObject.transform.position;\n\n \/\/ set the game state\n state = GameState.PreRound;\n\n \/\/ start the first round\n InitializeRound();\n}\n<\/pre><\/div>\n\n\nStarting the Round<\/h4>\n\n\n\n
\n
\nprivate void InitializeRound()\n{\n \/\/ set the state\n state = GameState.PreRound;\n\n \/\/ Reset Ball\n ResetBall();\n\n \/\/ Start Ball\n StartBall();\n}\n\nprivate void ResetBall()\n{\n \/\/ make sure we have control of the ball, not physics\n ballRigidbody.isKinematic = true;\n\n \/\/ move the ball to the start position\n ballObject.transform.position = ballStartPosition;\n\n}\n\nprivate void StartBall()\n{\n \/\/ turn kinematics off\n ballRigidbody.isKinematic = false;\n\n \/\/ make the direction vector a heading\n direction.Normalize(); \n\n \/\/ move the ball by adding force\n ballRigidbody.AddForce(direction * force, ForceMode.Impulse);\n\n \/\/ change the state to playing\n state = GameState.Playing;\n}\n<\/pre><\/div>\n\n\n