Introduction to Game Programming: Using C# and Unity 3D - Chapter 6 (Preview)

Vahé Karamian 185 Chapter 6 – Creating Battleship Historical Background The game of Battleship is thought to have its origins in the French game L'Attaque played during World War I. The game is said to have been played by Russian officers before World War I. The first commer- cial version of the game was Salvo, published in 1931 in the United States by the Starex company. Other versions of the game were printed in the 1930s and 1940s, including the Strathmore Company's Combat: The Battleship Game, Milton Bradley's Broadsides: A Game of Naval Strategy and Maurice L. Freedman's Warfare Naval Combat. Figure 68-Grid Sample Layout Battleship was one of the earliest games to be produced as a computer game, with a version being released for the Z80 Compucolor in 1979. Many computer editions of the game have been produced since. In Clubhouse Games for the Nintendo DS, Battleship is known as Grid Attack. It is played on an 8×8 grid, and includes slight variations, such as 4-player gameplay, various ship sizes and shapes, as well as the op- tion to make the ships touch each other.

Unity 3D – Game Programming Intro 186 Game Play The game is played on four grids, two for each player. The grids are typically square – usually 10×10 – and the individual squares in the grid are identified by letter and number. On one grid the player arranges ships and records the shots by the opponent. On the other grid the player records his/her own shots. Before play begins, each player secretly arranges their ships on their primary grid. Each ship occupies a number of consecutive squares on the grid, arranged either horizontally or vertically. The number of squares for each ship is determined by the type of the ship. The ships cannot overlap (i.e., only one ship can occupy any given square in the grid). The types and numbers of ships allowed are the same for each player. These may vary depending on the rules. Type of Ship Size Aircraft Carrier 5 Battleship 4 Submarine 3 Destroyer 3 Patrol Boat 2 After the ships have been positioned, the game proceeds in a series of rounds. In each round, each player takes a turn to announce a target square in the opponent's grid which is to be shot at. The opponent an- nounces whether or not the square is occupied by a ship, and if it is a "miss", the player marks their primary grid with a white peg; if a "hit" they mark this on their own primary grid with a red peg. The attacking player notes the hit or miss on their own "tracking" grid with the ap- propriate color peg (red for "hit", white for "miss"), in order to build up a picture of the opponent's fleet. The player who successfully locates all their opponent’s ships first by hitting each square they occupy is the winner as all ships have been destroyed.

Vahé Karamian 187 Game Plan for Implementation Since we have a good understanding of the game and the game rules, we can start thinking about how to implement our version of the Battleship board game. The first thing we should concentrate on is creating the board on which we are going to play our game. Representing the board digitally in the computer memory is going to be simple based on the rules that we have. There are two items we need to think about (1) representing the board visually (2) keeping track of board data. Let’s take a look and see how we are going to represent our board visually. We know that the board is going to be of size N x N. In this case we have decided to make it a 10 x 10 board. The next step is to determine how we are going to represent each single unit on the board. To make it easier, we can use a cube with the following scale vec- tor: <1,0.1,1> in the <x,y,z> coordinates. This will give us a nice unit base for the board. Figure 69-Base Board Unit

Vahé Karamian 189 public Text lblBoardPosition; public int ROW; public int COL; public bool OCCUPIED; // Use this for initialization void Start () { this.OCCUPIED = false; } // Update is called once per frame void Update () { } } Code Block 44-BoardUIVer1 Class Definition A simple class that will store the row and column data for the unit. A reference to the UI Text Label for the unit so it can be updated when it has been instantiated, and finally a Boolean variable that indicates if the unit is occupied or not. The Steps to Create Board Unit: 1. Create a Cube primitive GameObject, name it BoardUnit. 2. Change the scale to be <1,0.1,1> on the <x,y,z> 3. Create a new Material type called BoardUnit 4. Assign your preferred texture to the Albedo property under Main Maps. 5. Assign the new material to the BoardUnit GameObject 6. Create a new .cs script named BoardUIVer1.cs 7. Enter your script code and assign the script to BoardUnit GameObject

Unity 3D – Game Programming Intro 192 4. Now you will need to assign the BoardUnit prefab to the public variable named BoardUnitPrefab. When you run the game, you will notice the board that has been generated. Figure 72-Showing Details per Board Unit If you look closely, you will notice that information for each board unit is being displayed properly. There are many reason we would like to see these information. First, it is a visual way to pin-point each board unit, which leads to the more important reason, debugging! We can quickly debug our logic and identify the values we get behind the scene with the actual visual representation. You will see the benefit as we progress. Since this is a board game, we need to somehow keep track of the state of the board throughout its life, and also be able to select a particular location on the main board for placing our GameObjects and interacting with them. So let’s see how this portion would be done. Assuming that we will use our mouse pointer to locate and position our pieces, and also submit the attack command, we will have to capture the mouse position and convert the mouse position into our 3D

Vahé Karamian 193 space. There are two features that will enable us to perform these operations, one is the actual Input object which will provide us with the mouse position, and the next is a combination of a Ray object and using the Physics engine to perform a Raycast to determine if we have hit an object in the scene or not. The following code-block will illustrate this operation. NOTE: The code block is partial listing of the Update() function18 . if (Input.mousePosition != null) { // capture the mouse position and cast a ray to see what object we hit Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); if (Physics.Raycast(ray, out tmpHitHighlight, 100)) { BoardUIVer1 tmpUI = tmpHitHighlight.transform.GetCompo- nent<BoardUIVer1>(); if (tmpHitHighlight.transform.tag.Equals("board") && !tmpUI.OCCUPIED) { BoardUIVer1 boardData = board[tmpUI.ROW, tmpUI.COL].transform.GetComponent<BoardUIVer1>(); if (tmpHighlight != null) { if(boardData.OCCUPIED) tmpHighlight.GetComponent<Renderer>().material.color = Color.red; else tmpHighlight.GetComponent<Renderer>().material.color = Color.white; } if(this.tmpBlockHolder != null) { Destroy(this.tmpBlockHolder); } if(this.PLACE_BLOCK) { this.tmpBlockHolder = new GameObject(); this.OK_TO_PLACE = true; if (!this.vertical && (tmpUI.ROW<=10-this.blockSize)) { for(int i=0; i<this.blockSize; i++) { 18 Full listing of the function will be provided in the upcoming sections.

Vahé Karamian 195 } visual.transform.parent = this.tmpBlockHolder.transform; } } } tmpHitHighlight.transform.GetComponent<Renderer>().material.color = Color.blue; tmpHighlight = tmpHitHighlight.transform.gameObject; } } } Code Block 46-Highlighted Lines for Mouse Position and Raycasting Let’s discuss only the section of the code that deal with the mouse position and Ray casting. The first if statement check to see if we have a mouse position. If we do, we convert that mouse position to a Ray object using the built in function provided by the Camera class. Once we have a ray object, we use the Physics engine’s Raycast function to cast a ray and one of the parameters for the raycast function is an out variable named tmpHitHighlight that will return a GameObject if we do hit anything within the active camera view. Remember, tmpHitHighlight is a GameObject that represents our board unit. The board unit Prefab has a script attached to it called BoardUIVer1.cs which is used to update the visuals of the board unit as well as store the state of that particular board unit. Therefore based on our design we know that we at this time, the only object we can technically hit through the raycast is the board unit. So what we are doing is getting the components attached to the board unit using the GetComponent<>() function and we store the returned object in a variable called tmpUI. The next step is to detect if we are actually hitting a board GameObject. This is detected by checking the tag on the GameObject we just hit by the raycast. The idea here is that if we are a board type object and the board unit we are currently pointing to is not occupied, we execute the next logical block. First we get the board data from our two dimensional array by supplying the row and column of the hit

Vahé Karamian 197 Notice that the GameObject is composed of several other GameObjects. One is a Canvas which is used for displaying the label of the BoardUnit. AttackPosition is an empty GameObject used inter- nally for rendering graphics. CubeWreck is another nested GameObject that represents the visual aspect of a hit on the BoardUnit. You will see how these items are being constructed and used when we start looking at the source code. BoardUnitEnemy is a duplicate of BoardUnityPlayer, the structure is exactly the same. The only difference between the two is the Tag and a few other configuration elements. We will also take a look at them when discussing the source code. CubeWreck is the prefab that represents the visual representation of a hit to a board unit that is occupied by a ship. It is the combination of two Cube primitives at specified angles to give us some nice visual effect. Figure 74 - CubeWreck Prefab The Prefabs we just described are not present in the live scene during design time. They will be instantiated during the game play. Now let’s take a look at the GameObjects that are going to be present at design time in the scene. _BackgroundMusic is an empty GameObject that is solely used to store and manage an Audio Source. It basically plays the background music for the level. Main Camera is the GameObject representing the camera in the scene. By default, whenever you create a scene, a Camera GameObject

Vahé Karamian 199 Game Flow + Logic The following diagram is a high level visual representation of the game flow. As a good rule of thumb, before you start any project, it is a good idea to sketch out and capture some high level representation of how your program will flow. Figure 75 - Game Flow High Level To quickly summarize the diagram, when the game initially starts, the player is asked to place his/her pieces on the designated board19 . When the player has completed placing their pieces, then the computer will start to place its pieces. Once the player and the computer have placed all of the necessary pieces, the game starts! 19 Note, that we have not captured the details of checking the board for proper placement of the pieces, nor did we capture the change of orientation while placing the pieces on the board.

Vahé Karamian 201 As illustrated, the player needs to first select a piece to be placed on the board. When a piece is selected, then he/she has to select where they would like to place the piece on the board, and in what orientation. There are only two orientations available, horizontal and vertical. When a given board unit is selected, the computer checks to see if there is enough room for the placement of the piece, it also check to see if the whole length of the selected ship is clear for placement. That is, if there are no pieces placed already placed on the path of the newly selected piece. This process keeps repeating until all pieces have been successfully placed onto the board. Next, the computer starts placing its pieces. Figure 77 - A.I. Ship Placement Flow Diagram The A.I. goes through a similar process when it is placing its own playing pieces onto the board. It starts by selecting the next available piece to be placed, then it randomly decides what orientation it wasn’t to place the piece, next it decides the coordinates on the playing board, once that is determined, then it starts going through the process of checking and verifying if the selection is valid for placement or not. If

Vahé Karamian 203 Figure 78 provides a more detailed view of how the internal game logic is once both the player and the A.I. have placed their ships onto their respective boards. Each player gets a chance to select a board unit when it is their turn, if the selected board unit is occupied by the oppo- nents piece, then we have a hit, several operations happen behind the scene by the game manager for accounting and also visual and audio representation, finally the game manager checks to see if the player has hit all of the opponent’s pieces, and if so, the game is over. The A.I. starts with similar logic and the program performs the same steps for the hit or miss criteria, however, there is a backtracking20 algorithm developed for the A.I. if there is a hit! This is basically the code that actually give the A.I. its intelligence. It determines what the best next move is for the A.I. if the A.I. has a hit. In the meantime the game manager also checks to determine if the A.I. has hit all of the play’s pieces, and if so, the game is terminated with the A.I. being the winner. As you can see, even for a simple game, there is a lot of planning to do as a designer and programmer. The diagrams are provided to make it easier to visualize the flow of the program. We will look at the implementation in a different section. Game User Interface As any other application, a game also needs to provide a Graphical User Interface (GUI) to the user. The GUI of your game is a means of how the user will interact with your game. Generally speaking, the GUI of an application and or a game is driven by the features and goals of that particular application and or game. Typically the GUI has to display meaningful information to the end user. The information are data related to the environment. For in- stance, in our game, we need a means for the player to select the pieces that are needed to be placed onto their board, we also need a means to 20 Backtracking is a general algorithm for finding all (or some) solutions to some com- putational problems, notably constraint satisfaction problems, that incrementally builds candidates to the solutions, and abandons each partial candidate c ("backtracks") as soon as it determines that c cannot possibly be completed to a valid solution.

Vahé Karamian 205  Display player’s pieces to be placed onto the player’s board before the game starts.  Visually represent the board pieces after player has positioned them onto the board.  Display scores for both the player and the enemy.  Visually represent a hit on both the player’s board and the enemy’s board.  Background music for the game.  Sound FX when there is a hit on either the player’s board or the enemy’s board. Given our list of inputs and outputs, we can come up with a sketch representing the layout of how we would like our GUI to be designed. These process usually will take some time and effort and it will most likely go through a few iterations before you settle down on a final design. Figure 80 - Game GUI Score Display

Introduction to Game Programming: Using C# and Unity 3D - Chapter 6 (Preview)

More Related Content

What's hot

Similar to Introduction to Game Programming: Using C# and Unity 3D - Chapter 6 (Preview)

Recently uploaded

Introduction to Game Programming: Using C# and Unity 3D - Chapter 6 (Preview)