[pingpong] Two player pingpong gameplay ready

Author: scopeInfinity

include/fuzzy/kernel/process/process.h

@@ -75,6 +75,7 @@ void process_scheduler(int *_e_ip, int *_e_cs, int *_e_sp, int *_e_ss);
 // user space <-> kernel space data transfer helper
 extern void syscall_strncpy_user_to_kernel(int user_ds, char *src_es_address, char *dest_ds_address, size_t size);
 extern void syscall_strncpy_kernel_to_user(int user_ds, char *dest_address, char *src_address, size_t size);
+// assumes size is multiple of 4
 extern void kernel_memncpy_absolute(int dst_ds, char *dst_address, int src_ds, char *src_address, size_t size);
 
 // operations

src/kernel/process/process.asm

@@ -59,6 +59,7 @@ global kernel_memncpy_absolute
         ret
 
     kernel_memncpy_absolute:
+        ; assumes count is multiple of 4
         push ebp
         mov ebp, esp
         ; callee save register
@@ -69,13 +70,14 @@ global kernel_memncpy_absolute
         push es
 
         mov ecx, [ebp + 0x18]         ; count
+        shr ecx, 2                    ; count/4
         mov esi, [ebp + 0x14]         ; src_loc
         mov  ds, [ebp + 0x10]         ; src_ds
         mov edi, [ebp + 0x0C]         ; dest_loc
         mov  es, [ebp + 0x08]         ; dest_ds
 
         ; strcpy
-        rep movsb
+        rep movsd                     ; move double word
 
         pop es
         pop ds

src/usr/include/graphics.h

@@ -34,14 +34,15 @@ int graphresult();
 void closegraph();
 void cleardevice();
 
+void graphautoflush_enable();
+void graphautoflush_disable();
 int graphflush();
 
 void setcolor(int color);
 int getcolor();
 void setbkcolor(int color);
 int getbkcolor();
 
-void putpixel_noflush(int x, int y, int color);
 void putpixel(int x, int y, int color);
 
 void line(int x1, int y1, int x2, int y2);

src/usr/lib/graphics.c

@@ -6,6 +6,7 @@ static struct GraphicsState {
     int bkcolor;
     int color;
     int last_err;
+    int auto_flush_disabled;
 } gstate = {0};
 
 static uint8_t BUFFER[GRAPHICS_MAX_HEIGHT][GRAPHICS_MAX_WIDTH]={0};
@@ -32,6 +33,20 @@ void closegraph() {
     gstate.last_err = SYSCALL_A1(SYSCALL_GRAPHICS, SYSCALL_GRAPHICS_CLOSEGRAPH);
 }
 
+void graphautoflush_enable() {
+    gstate.auto_flush_disabled = 1;
+}
+
+void graphautoflush_disable() {
+    gstate.auto_flush_disabled = 0;
+}
+
+static void _autoflushnow() {
+    if(!gstate.auto_flush_disabled) {
+        graphflush();
+    }
+}
+
 int graphflush() {
     gstate.last_err = SYSCALL_A2(SYSCALL_GRAPHICS, SYSCALL_GRAPHICS_COPYBUFFER, BUFFER);
     return gstate.last_err;
@@ -40,7 +55,7 @@ int graphflush() {
 void cleardevice() {
     memset(BUFFER, gstate.bkcolor, sizeof(BUFFER));
     moveto(0, 0);
-    graphflush();
+    _autoflushnow();
 }
 
 void setviewport(int left, int top, int right, int bottom, int clip) {
@@ -73,11 +88,7 @@ int getbkcolor() {
 
 void putpixel(int x, int y, int color) {
     BUFFER[y][x]=color;
-    graphflush();
-}
-
-void putpixel_noflush(int x, int y, int color) {
-    BUFFER[y][x]=color;
+    _autoflushnow();
 }
 
 void line(int x1, int y1, int x2, int y2) {
@@ -111,7 +122,7 @@ void line(int x1, int y1, int x2, int y2) {
             BUFFER[y][x]=color;
         }
     }
-    graphflush();
+    _autoflushnow();
 }
 
 void drawpoly(int num, int polypoints[]) {
@@ -133,7 +144,7 @@ void rectangle(int left, int top, int right, int bottom) {
         BUFFER[y][left]=color;
         BUFFER[y][right]=color;
     }
-    graphflush();
+    _autoflushnow();
 }
 
 void bar(int left, int top, int right, int bottom) {
@@ -144,7 +155,7 @@ void bar(int left, int top, int right, int bottom) {
             BUFFER[y][x]=color;
         }
     }
-    graphflush();
+    _autoflushnow();
 }
 
 void ellipse(int x, int y, int x_radius, int y_radius) {
@@ -173,7 +184,7 @@ void fillellipse(int xcenter, int ycenter, int x_radius, int y_radius) {
             }
         }
     }
-    graphflush();
+    _autoflushnow();
 }
 
 void floodfill(int x,int y, int color) {

src/usr/local/src/pingpong.c

@@ -8,56 +8,140 @@
 #define PLAYER_1  1
 #define PLAYER_2  2
 
+const int BUSY_WAIT_FRAMECOUNTER = 2e7;
+
 const int WINDOW_HEIGHT = GRAPHICS_MAX_HEIGHT;
 const int WINDOW_WIDTH  = GRAPHICS_MAX_WIDTH;
 
+const int BORDER = 5;
+
 const int BAT_HALF_HEIGHT = 15;
 const int BAT_HALF_WIDTH  = 2;
 const int BAT_SPEED = 5;
 
-const int bat_miny = BAT_HALF_HEIGHT;
-const int bat_maxy = (WINDOW_HEIGHT-1)-BAT_HALF_HEIGHT;
-
 const int p1_x = 10;
 const int p2_x = (WINDOW_WIDTH-1)-p1_x;
 
-const int BALL_SPEED = 2;
+const float BALL_SPEED_MAX = 10;
+const float BALL_SPEED_INIT = 5;
+const float BALL_SPEED_INC = 1.1;
 const int BALL_RADIUS = 3;
 
 struct playerState {
-    int y;
+    float y;
+    float yspeed;
 };
 
 struct {
-    int x,y;
-    int xspeed, yspeed;
+    int top, bottom;
+    int left, right;
+} field;
+
+
+struct {
+    float x, y, xprev, yprev;
+    float xspeed, yspeed;
 } ball;
 
 struct {
     struct playerState p1, p2;
+    int turn;
+    int p1Score;
+    int p2Score;
 } gstate;
 
 void frame_wait() {
     // busy wait
-    volatile int counter = 1e7;
+    volatile int counter = BUSY_WAIT_FRAMECOUNTER;
     while (counter--);
 }
 
+void reset_ball() {
+    ball.xprev = ball.x = WINDOW_WIDTH/2;
+    ball.yprev = ball.y = WINDOW_HEIGHT/2;
+    if(gstate.turn == PLAYER_1) {
+        ball.xspeed = BALL_SPEED_INIT*0.8;
+        ball.yspeed = BALL_SPEED_INIT*0.6;
+    } else {
+        ball.xspeed = -BALL_SPEED_INIT*0.8;
+        ball.yspeed =  BALL_SPEED_INIT*0.6;
+    }
+}
+
 void game_init() {
-    gstate.p1.y = (bat_miny+bat_maxy)/2;
+    graphautoflush_disable();
+
+    field.top = BORDER-1;
+    field.bottom = WINDOW_HEIGHT-BORDER;
+    field.left = BORDER-1;
+    field.right = WINDOW_WIDTH-BORDER;
+
+    gstate.p1.y = (field.top+field.bottom)/2;
     gstate.p2 = gstate.p1;
 
-    ball.x = WINDOW_WIDTH/2;
-    ball.y = WINDOW_HEIGHT/2;
-    ball.xspeed = BALL_SPEED*0.8;
-    ball.yspeed = BALL_SPEED*0.6;
+    gstate.p1Score = gstate.p2Score = 0;
+    gstate.turn = PLAYER_1;
+    reset_ball();
+}
+
+static void collision(float zm_border, float zm_prevx, float *zm_newx, float *zm_xspeed, float rigid_x) {
+    // assumes: zm is a square object
+    // collison is written along x-coordinates but can be generalized.
+    if(zm_prevx<=rigid_x-zm_border<=*zm_newx) {
+        // move object as per collision for object moving from left to right.
+        *zm_newx = 2*(rigid_x-zm_border) - (*zm_newx);
+        *zm_xspeed = -1;
+    } else if(zm_prevx>=rigid_x+zm_border>=*zm_newx) {
+        // move object as per collision for object moving from right to left.
+        *zm_newx = 2*(rigid_x+zm_border) - (*zm_newx);
+        *zm_xspeed = -1;
+    }
+}
+
+void check_collision() {
+    // wall
+
+    if(ball.y>field.bottom-BALL_RADIUS) {
+        ball.yspeed *= -1;
+        ball.y = 2*(field.bottom-BALL_RADIUS)-ball.y;
+    } else if(ball.y<field.top+BALL_RADIUS) {
+        ball.yspeed *= -1;
+        ball.y = 2*(field.top+BALL_RADIUS)-ball.y;
+    }
+
+    if(ball.x>p2_x-BAT_HALF_WIDTH-BALL_RADIUS && ball.y>=gstate.p2.y-BAT_HALF_HEIGHT && ball.y<=gstate.p2.y+BAT_HALF_HEIGHT) {
+        // right bat
+        ball.xspeed *= -1 * BALL_SPEED_INC;
+        ball.x = 2*(p2_x-BAT_HALF_WIDTH-BALL_RADIUS)-ball.x;
+    } else if(ball.x<p1_x+BAT_HALF_WIDTH+BALL_RADIUS && ball.y>=gstate.p1.y-BAT_HALF_HEIGHT && ball.y<=gstate.p1.y+BAT_HALF_HEIGHT) {
+        // left bat
+        ball.xspeed *= -1 * BALL_SPEED_INC;
+        ball.x = 2*(p1_x+BAT_HALF_WIDTH+BALL_RADIUS)-ball.x;
+    }
+
+
+    if(ball.x>WINDOW_WIDTH-1) {
+        // player 2 missed ball
+        gstate.p1Score += 1;
+        gstate.turn = (gstate.turn==PLAYER_1)?PLAYER_2:PLAYER_1;
+        reset_ball();
+    } else if(ball.x<0) {
+        // player 1 missed ball
+        gstate.p2Score += 1;
+        gstate.turn = (gstate.turn==PLAYER_1)?PLAYER_2:PLAYER_1;
+        reset_ball();
+    }
 }
 
 void draw_board() {
     // clear screen
     setbkcolor(GREEN);
     cleardevice();
 
+    setcolor(BROWN);
+    bar(0, 0, WINDOW_WIDTH, field.top);
+    bar(0, field.bottom, WINDOW_WIDTH-1, WINDOW_HEIGHT-1);
+
     setcolor(BLUE);
     bar(p1_x-BAT_HALF_WIDTH, gstate.p1.y-BAT_HALF_HEIGHT,
         p1_x+BAT_HALF_WIDTH, gstate.p1.y+BAT_HALF_HEIGHT);
@@ -68,6 +152,8 @@ void draw_board() {
 
     setcolor(WHITE);
     fillellipse(ball.x, ball.y, BALL_RADIUS, BALL_RADIUS);
+
+    graphflush();
 }
 
 void move_bat(int player_id, int dir) {
@@ -87,23 +173,33 @@ void move_bat(int player_id, int dir) {
     }
 
     // keep bat in bounds
-    p->y = max(bat_miny, min(bat_maxy, p->y));
+    const int bat_miny = field.top+1+BAT_HALF_HEIGHT;
+    const int bat_maxy = field.bottom-1-BAT_HALF_HEIGHT;
+
+    if(p->y > bat_maxy) {
+        p->y = bat_maxy;
+    } else if(p->y < bat_miny) {
+        p->y = bat_miny;
+    }
 }
 
 void move_ball() {
+    ball.xprev = ball.x;
+    ball.yprev = ball.y;
     ball.x += ball.xspeed;
     ball.y += ball.yspeed;
 }
 
 void game() {
     game_init();
     while (1)  {
+        check_collision();
         draw_board();
 
         move_ball();
 
+        frame_wait();
         if(!kbhit()) {
-            frame_wait();
             continue;
         }
         char c = getch();