User Tools
Differences
This shows you the differences between two versions of the page.
| Both sides previous revision Previous revision Next revision | Previous revision | ||
|
labs:pong_part_2 [2019/11/11 12:51] jgoeders [Exercise #1 - Drawing the objects] |
labs:pong_part_2 [2019/12/03 16:26] (current) jgoeders [Exercise #1 - Drawing the objects] |
||
|---|---|---|---|
| Line 15: | Line 15: | ||
| This video shows an implementation of the Pong game for this lab. Your implementation does not need to look exactly like this. Feel free to change colors, object sizes, paddle positions, etc. Note that the video shows a wide-screen monitor, so there are "black bars" on the left and right that aren't part of the drawable space. | This video shows an implementation of the Pong game for this lab. Your implementation does not need to look exactly like this. Feel free to change colors, object sizes, paddle positions, etc. Note that the video shows a wide-screen monitor, so there are "black bars" on the left and right that aren't part of the drawable space. | ||
| - | {{youtube>JRMBcn9saP8?rel=0&noborder&560x315}} | + | {{youtube>cUQDCrGownw?rel=0&noborder&560x315}} |
| - | As you can see in the video above, the Pong game consists of drawing and moving around three objects: the ball, the left paddle and the right paddle. The animation is done by continuously drawing the objects, waiting some time, erasing them, moving them, and then immediately redrawing them and repeating the process. Erasing is done by drawing the objects black. | + | |
| + | As you can see in the video above, the Pong game consists of drawing and moving around three objects: the ball, the left paddle and the right paddle. The animation is done by continuously drawing the objects, waiting some time, erasing them, moving them, and then immediately redrawing them and repeating the process. Erasing is done by drawing the objects black. The buttons are used to move the paddles, and the score is displayed using the seven segment controller. | ||
| ==== State Machine ==== | ==== State Machine ==== | ||
| - | The diagram below provides the state machine that will control most of the Pong game. Rather than have separate states for drawing and erasing, the state machine is designed to use the same three states to draw the objects. Thus, the state machine will continuously repeat the state ordering (BALL->PADDLE_L->PADDLE_R->WAIT_TIMER->) to draw the objects and wait for some time, then (BALL->PADDLE_L->PADDLE_R->MOVE->) to erase the objects, and move them before repeating the same sequence again. | + | The diagram below provides the state machine that will control most of the Pong game. Rather than have separate states for drawing and erasing, the state machine is designed to use the same three states to draw the objects. Thus, the state machine will continuously repeat the state ordering (PADDLE_L->BALL->PADDLE_R->WAIT_TIMER->) to draw the objects and wait for some time, then (PADDLE_L->BALL->PADDLE_R->MOVE->) to erase the objects, and move them before repeating the same sequence again. |
| {{ :labs:lab_pong:pong_sm.png?600 |}} | {{ :labs:lab_pong:pong_sm.png?600 |}} | ||
| Line 30: | Line 31: | ||
| * You are free to choose how long to wait in the WAIT_TIMER state. Somewhere between 0.1s and 0.001s is a good choice, depending on how fast you want the gameplay. | * You are free to choose how long to wait in the WAIT_TIMER state. Somewhere between 0.1s and 0.001s is a good choice, depending on how fast you want the gameplay. | ||
| - | <color #ed1c24>Given your system clock, how many cycles do you need to wait for, in order to implement a 0.01 second delay?</color> | + | <color #ed1c24>Given your system clock, how many cycles do you need to wait for, in order to implement a 0.01 second delay? How many bits wide does your counter need to be to implement this wait?</color> |
| + | |||
| + | <color #ed1c24>Why is ''invertErasing'' a mealy output when leaving state ''PADDLE_R'' instead of just having it be a moore output in that state?</color> | ||
| + | |||
| ==== Module Design ==== | ==== Module Design ==== | ||
| Line 189: | Line 194: | ||
| - | 5. Create the above state machine with just the states needed to start the game and draw the objects: INIT, BALL, PADDLE_L and PADDLE_R. For this exercise you might want to create a DONE state that the state machine stays in once it is down drawing the right paddle. | + | 5. Create the above state machine with just the states needed to start the game and draw the objects: INIT, BALL, PADDLE_L and PADDLE_R. For this exercise you might want to create a DONE state that the state machine stays in once it is done drawing the right paddle. |
| 6. Implement the other components as follows: | 6. Implement the other components as follows: | ||
| - | * **Ball Location:** You should create a new ''always_ff'' block to manage the ball location. Create two registers, ''BallX'' and ''BallY'' that are reset to the center of the screen when ''initGame'' is true. This is sufficient for this exercise. | + | * **Ball Location:** You should create a new ''always_ff'' block to manage the ball location. Create two registers, ''ballX'' and ''ballY'' that are reset to the center of the screen when ''initGame'' is true. This is sufficient for this exercise. |
| * **Paddle Locations:** You should create a new ''always_ff'' block to manage the paddle locations. Create two registers, ''LPaddleY'' and ''RPaddleY'' that position the paddles halfway down the screen when ''initGame'' is true. This is sufficient for this exercise. | * **Paddle Locations:** You should create a new ''always_ff'' block to manage the paddle locations. Create two registers, ''LPaddleY'' and ''RPaddleY'' that position the paddles halfway down the screen when ''initGame'' is true. This is sufficient for this exercise. | ||
| * **Player Scores:** You should create a new ''always_ff'' block to manage the player scores. For this exercise, just assign the ''P1score'' and ''P2score'' registers to 0 when ''initGame'' is true. | * **Player Scores:** You should create a new ''always_ff'' block to manage the player scores. For this exercise, just assign the ''P1score'' and ''P2score'' registers to 0 when ''initGame'' is true. | ||
| Line 223: | Line 228: | ||
| 2. Update the following components: | 2. Update the following components: | ||
| - | * **Game Loop Timer:** Implement this as a counter, similar to how you have done in previous labs. It should be reset with the ''timerRst'' signal, increment each cycle, and output a ''timerDone'' signal when it reaches a value of your choosing. | + | * **Game Loop Timer:** Implement this as a counter using the ''timerRst'' and ''timerDone'' signals. |
| * **Ball Location:** Add more logic to your ball location component. When in the move state (''moveAndScore'' is high), update the ball location according to its direction. Consider the values of ''ballMovingRight'' and ''ballMovingDown'' and either add 1 or subtract 1 from ''ballX'' and ''ballY'' accordingly. | * **Ball Location:** Add more logic to your ball location component. When in the move state (''moveAndScore'' is high), update the ball location according to its direction. Consider the values of ''ballMovingRight'' and ''ballMovingDown'' and either add 1 or subtract 1 from ''ballX'' and ''ballY'' accordingly. | ||
| - | * **Ball Direction: ** You should create a new ''always_ff'' block to manage the ball directions (''ballMovingRight'' and ''ballMovingDown'' registers). On ''initGame'', you should reset these registers to values of your choice. Based on the ball location (''ballX'' and ''ballY'') you should update these registers appropriately. | + | * **Ball Direction: ** You should create a new ''always_ff'' block to manage the ball directions (''ballMovingRight'' and ''ballMovingDown'' registers). On ''initGame'', you should reset these registers to values of your choice. When the ball hits a wall (check the ball location), you should update these registers appropriately. |
| - | * **Paddle Locations:** Nothing to update in this exercise. | + | * **Erase Switch:** Create a flip-flop, ''erasing'' that is reset to 0 on ''initGame'' and flips its value if ''invertErase'' is high. |
| - | * **Player Scores:** Nothing to update in this exercise. | + | |
| - | * **Erase Switch:** Create a flip-flop, ''erasing'' that is reset to 0 on ''initGame'' and flips its value if ''switchErase'' is high. | + | |
| - | Use simulation to debug your design. You might consider making the timer delay small to make it faster to simulate your design. | + | ** A note on debugging:** You will likely need to debug your design to get it working properly. The best way to do this is to set up a simulation tcl file. Consider how you can change your design to make it easier to simulate and debug. For example, you could make the timer delay small to make it faster to simulate, or change the values assigned to registers on ''initGame''. For example, you could initialize the ball close to a wall so that you don't need much simulation time in order to see if it bounced off of the wall correctly. |
| Line 242: | Line 246: | ||
| Update the following components: | Update the following components: | ||
| - | * **Ball Direction:** Detect if the ball is located on a player paddle, and update the ball direction appropriately. | + | * **Ball Direction:** Detect if the ball is located on a player paddle, and update the ball direction appropriately. To keep things simple, you can assume the ball only bounces off of the front of the paddle. |
| * **Paddle Locations:** In the move state (''moveAndScore'' is high), move the paddles appropriately based on the button inputs (''LPaddleUp'', ''RPaddleUp'', etc.) Because we have a wait state in our game loop, you don't need to worry about any button debouncing, it is sufficient to just check the button values, and modify the paddle locations as necessary. You may want to move the paddles by 2 or 3 pixels, so that the paddles can move faster than the ball. The logic to do this is a bit tricky, so think about it carefully. You don't want the paddles to be able to move off of the screen. | * **Paddle Locations:** In the move state (''moveAndScore'' is high), move the paddles appropriately based on the button inputs (''LPaddleUp'', ''RPaddleUp'', etc.) Because we have a wait state in our game loop, you don't need to worry about any button debouncing, it is sufficient to just check the button values, and modify the paddle locations as necessary. You may want to move the paddles by 2 or 3 pixels, so that the paddles can move faster than the ball. The logic to do this is a bit tricky, so think about it carefully. You don't want the paddles to be able to move off of the screen. | ||
