platformer

software/Pong_Code/Display.h

@@ -7,11 +7,38 @@
 #ifndef DISPLAY_H_
 #define DISPLAY_H_
 
+// Definition of Screen resolution in pixel
 #define COLS 12
 #define ROWS 8
 
+/*
+ * virtual screen,
+ * The screen is regarded as a Matrix with 8 rows and 12 collums. 
+ * Each field inside the matrix represent one pixel on the screen
+ * consists of a one dimensional array with integer values.
+ * Each row on the screen is represented by one field of the array.
+ * The Integer filling the field convertet to binary state wich pixels are active
+ * Exp.:
+ *										 __					      __
+ *										|  1,0,0,0,0,0,0,0,0,0,0,0  |
+ *										|  1,0,0,0,0,0,0,0,0,0,0,0  |
+ *										|  1,0,0,0,0,0,0,0,0,0,0,0  |
+ *	 [2048,2048,2048,64,0,1,1,1]   ==> 	|  0,0,0,0,0,1,0,0,0,0,0,0  | 
+ *										|  0,0,0,0,0,0,0,0,0,0,0,0  |
+ *										|  0,0,0,0,0,0,0,0,0,0,0,1  |
+ *										|  0,0,0,0,0,0,0,0,0,0,0,1  |
+ *										|__0,0,0,0,0,0,0,0,0,0,0,1__|
+ *
+ * 1-> pixel light up
+ * 0-> pixel is dark
+*/
 int screen[ROWS];
 
+/*
+ * helper function to print integer values as binary.
+ * only used for debugging to display the screen on the console
+ * found at: https://www.geeksforgeeks.org/binary-representation-of-a-given-number/
+*/
 void bin(unsigned n)
 {
     if (n > 1)
@@ -19,7 +46,17 @@ void bin(unsigned n)
     printf("%d", n & 1);
 }
 
-
+/*
+ * actual drawing function. It will output the screen variabe on the designated registers.
+ * every Row of the screen is written to the register one after another in the following format:
+ *  
+ *	0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0
+ *	|______||_____________________|
+ *	 Row-ID		   Row-Data
+ *
+ * Row-ID: 	state which row the data is from. Values from 1 to 8. 0 is an invalid value
+ * Row-Data:	a binary value for each pixel in the row
+*/
 void draw() {
 	int row,i,j;
 	for (i=0 ; i<ROWS ; i++) {
@@ -28,6 +65,10 @@ void draw() {
 	}
 }
 
+
+/*
+ * function to draw the virtual screen on a console. Only used for debugging. 
+*/
 void draw_console() {
 	int i;
 	for (i = 0 ; i < ROWS ; i++) {
@@ -36,10 +77,19 @@ void draw_console() {
 	}
 }
 
+
+/*
+ * function to set the given pixel 1.
+ * x and y are the coordinates, x is collumn number, y row number.
+*/
 void set_pixel(int x, int y) {
 	screen[y] = screen[y] & ~(1<<x) | (1<<x);
 }
 
+
+/*
+ * reset the screen, all pixels are set to 0. 
+*/
 void reset_screen() {
 	int i;
 	for (i=0;i<ROWS;i++) {

software/Pong_Code/Main.c

@@ -6,9 +6,15 @@
 #include "Display.h"
 #include "structs.h"
 
-
-#define ACCELERATION 0.001f
-#define TICK 0.001f
+#define ACCELERATION 0.001f		//increase of the ball speed over time
+#define TICK 0.001f				//movement per tick
+
+/*
+ * button input is 8 bit word.
+ * variables define which of the 8 buttons is assigned to the given functionality
+ * Exp.:
+ * 	#define LEFT_UP_BUTTON 1 -> the first button will move the left pannel up
+*/
 #define LEFT_UP_BUTTON 1
 #define LEFT_DOWN_BUTTON 0
 #define RIGTH_UP_BUTTON 3
@@ -21,6 +27,11 @@ struct Ball ball;
 struct Paddle left_paddle;
 struct Paddle right_paddle;
 
+/*
+ * restes everything to default.
+ * both paddles on highes position, with a length of 3.
+ * ball in the middle, start moving up-rigth.
+*/
 void reset_pos() {
 	ball.x = COLS/2 - 1;
 	ball.y = ROWS/2 - 1;
@@ -32,6 +43,17 @@ void reset_pos() {
 	right_paddle.length = 3;
 }
 
+/*
+ * definition of the game PONG itself.
+ * first read input registers and calculate new paddelpositions depending on the pressed buttons.
+ * 
+ * second calculate the new position of the ball depending on its current position and velocity.
+ * If Ball hits left or rigth border calculate if the ball hits a paddle or strike a goal.
+ * Goal 	-> restart the game
+ * Paddle 	-> bounce ball back
+ * 
+ * Third reset the screen to 0 and draw the new positions on it
+*/
 void game() {
 	int i,k;
 	unsigned buttons;
@@ -42,8 +64,7 @@ void game() {
 	while (1){
 
 		buttons = ~IORD_ALTERA_AVALON_PIO_DATA(PIO_BUTTON_BASE);
-		//buttons = 10;
-
+		// calculate new paddle positions from button imput
 		if (buttons & (1<<LEFT_UP_BUTTON)){
 			left_paddle.y = MAX(left_paddle.y - (10 * TICK),0);
 			printf("%f\n",left_paddle.y);
@@ -60,14 +81,16 @@ void game() {
 			right_paddle.y = MIN(right_paddle.y + (10 * TICK), ROWS - (right_paddle.length));
 		}
 
-
+		// calculate new ball position from old position and velocity
 		ball.y = MAX(MIN(ball.y + ball.vel_y * TICK,ROWS - 1),0);
+		//check for up and down borders
 		if (ball.y == 0 || ball.y == ROWS - 1){
 			ball.vel_y = -ball.vel_y;
 		}
 
 		ball.x = MAX(MIN(ball.x + ball.vel_x * TICK,COLS - 1),0);
 
+		// check for left border
 		if (ball.x <= 1){
 			printf("ballx: %f, ball y: %f\n",ball.x,ball.y);
 			printf("left_paddlex: %f\n",left_paddle.y);
@@ -79,6 +102,7 @@ void game() {
 				reset_pos();
 			}
 		}
+		// check for rigth border
 		if (ball.x >= COLS - 2){
 			if (round(ball.y) >= round(right_paddle.y) && round(ball.y) <= (round(right_paddle.y) + right_paddle.length -1)){
 				ball.vel_x = - ball.vel_x;
@@ -88,7 +112,7 @@ void game() {
 				reset_pos();
 			}
 		}
-
+		//increase balls velocity
 		if (ball.vel_x < 0) {
 			ball.vel_x = ball.vel_x - ACCELERATION;
 		} else {
@@ -100,8 +124,9 @@ void game() {
 			ball.vel_y = ball.vel_y + ACCELERATION;
 		}
 
-
+		// draw new positions on screen
 		reset_screen();
+
 		for (i=0;i<left_paddle.length;i++) {
 			set_pixel( 0, round(left_paddle.y) + i);
 		}
@@ -115,6 +140,11 @@ void game() {
 	}
 }
 
+/*
+ * function to output a test picture. used to verify the VHDL implementation.
+ * Will turn on one pixel after another starting with row 1 on the rigth side
+ * Will also print on console if one of the game buttons is pressed.
+*/
 void test_picture() {
 	int i,j,k;
 	unsigned buttons;
@@ -139,6 +169,7 @@ void test_picture() {
 				printf("\n");
 				set_pixel(j,i);
 				draw();
+				// slepp 
 				for(k=0;k<100000;k++) {
 				}
 			}