ckx/pong.ck

   1 // morse code - gluck keyboard event demo
   2 // june 2004 Philip Davidson ( philipd@alumni.princeton.edu )
   3 //
   4 //
   5 //
   6
   7 "gl.ckx" => (:gl:);
   8 "glu.ckx" => (:glu:);
   9 "gluck.ckx" => (:gluck:);
  10
  11 //our variables
  12
  13 Shakers shake1 => JCRev r => Echo a => Echo b => Echo c => dac;
  14 Shakers shake2 => r;
  15 TubeBell t => r;
  16 0.1 => t.gain;
  17 r => dac;
  18
  19 1    => int oldskool;
  20
  21 0.01 => float dt;
  22 0.0 => float p1f;
  23 0.0 => float p2f;
  24
  25 -1.0 => float grav;
  26
  27 0.0 => float puckx;
  28 0.0 => float pucky;
  29
  30 0.0 => float puckvx;
  31 0.0 => float puckvy;
  32
  33 0.0 => float puckax;
  34 0.0 => float puckay;
  35
  36 0.02 => float puckrad;
  37
  38 0.0 => float pad1y;
  39 0.0 => float pad1vy;
  40
  41 0.0 => float pad2y;
  42 0.0 => float pad2vy;
  43
  44 0.03 => float padw;
  45 0.3 => float padh;
  46
  47 1.0 => float boardw;
  48 1.0 => float boardh;
  49
  50 0.1 => float padspace;
  51 -boardw + padspace => float pad1x;
  52 boardw - padspace => float pad2x;
  53 0.0 => float pad1vx;
  54 0.0 => float pad2vx;
  55
  56
  57
  58 0 => int bouncex;
  59 0 => int bouncey;
  60
  61 0 => int out1;
  62 0 => int out2;
  63
  64 now => time lasttime;
  65 0 => int lastx;
  66 0 => int lasty;
  67
  68 0.0 => float lastdx;
  69 0.0 => float lastdy;
  70
  71 0 => int p1score;
  72 0 => int p2score;
  73
  74 1 => int running;
  75
  76 function void keycode ( uint k ) {
  77
  78         if ( k == gluck.KEY_q ) {
  79                 0 => running;
  80         }
  81
  82         if ( k == gluck.KEY_t ) {
  83                 1 - oldskool => oldskool;
  84                 if ( oldskool ) {
  85                         -boardw + padspace => pad1x;
  86                         boardw - padspace =>  pad2x;
  87                 }
  88         }
  89
  90         if ( k == gluck.KEY_w ) {
  91                 math.max ( 0.2, math.min ( 1.6 , pad1vy + 0.2) ) => pad1vy;
  92         }
  93         if ( k == gluck.KEY_s ) {
  94                 0.0 => pad1vy;
  95         }
  96         if ( k == gluck.KEY_x ) {
  97                 math.min ( -0.2 , math.max (-1.6 , pad1vy - 0.2) ) => pad1vy;
  98         }
  99
 100         if ( k == gluck.KEY_i ) {
 101                 math.max ( 0.2, math.min ( 1.6 , pad2vy + 0.2) ) => pad2vy;
 102         }
 103         if ( k == gluck.KEY_j ) {
 104                 0.0 => pad2vy;
 105         }
 106         if ( k == gluck.KEY_n ) {
 107                 math.min ( -0.2, math.max (-1.6 , pad2vy - 0.2) ) => pad2vy;
 108         }
 109         if ( k == gluck.KEY_SPACE ) {
 110                 std.rand2f( 0.0, 100.0 ) => float deg;
 111                 std.rand2f( 1.0, 2.0 ) => float mag;
 112                 mag * math.cos(deg) => puckvx;
 113                 mag * math.sin(deg) => puckvy;
 114         }
 115 }
 116
 117 function void motion ( int x, int y ) {
 118         x => lastx;
 119         y => lasty;
 120 }
 121
 122
 123 function void drag ( int x, int y ) {
 124         x - lastx => int dx;
 125         y - lasty => int dy;
 126         if ( x > gluck.GetViewDims(0) / 2 ) {
 127                 -0.6 * (float)dy => pad2vy;
 128                  0.6 * (float)dx => pad2vx;
 129         }
 130         else {
 131                 -0.6 * (float)dy => pad1vy;
 132                  0.6 * (float)dx => pad1vx;
 133         }
 134 }
 135
 136
 137 function void theeventpoll() {
 138         while ( gluck.HasEvents() && running == 1 ) {
 139
 140                 gluck.GetNextEvent() => int curid;
 141                 gluck.GetEventType(curid) => uint curtype;
 142
 143                 if ( curtype == gluck.EVENT_KEY ) { //keyboard
 144                         gluck.GetEventKey(curid) => uint k;
 145                         keycode(k);
 146                 }
 147                 if ( curtype == gluck.EVENT_PMOTION ) { //keyboard
 148                         gluck.GetEventX(curid) => int x;
 149                         gluck.GetEventY(curid) => int y;
 150                         motion(x,y);
 151                 }
 152                 if ( curtype == gluck.EVENT_MOTION ) { //keyboard
 153                         gluck.GetEventX(curid) => int x;
 154                         gluck.GetEventY(curid) => int y;
 155                         drag(x,y);
 156                         motion(x,y);
 157                 }
 158         }
 159 }
 160
 161 function void drawWindow() {
 162
 163                 gl.ClearColor( 0.4, 0.4, 0.4 , 0.0);
 164                 gl.Clear( gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT );
 165
 166                 gl.LineWidth(3.0);
 167
 168
 169                 0 => int ix;
 170                 gl.Color4f ( 0.5, 1.0, 0.5, 0.5 ) ;
 171                 gl.PushMatrix();
 172                 gl.Translatef( -0.1 , -boardh, 0.0 );
 173                 gl.Scalef( 0.1, 0.1, 1.0 );
 174                 for ( 0 => ix; ix < p1score ; ix + 1 => ix ) {
 175                         gl.Begin(gl.QUADS);
 176                         gl.Vertex2f( 0.0, 0.0 );
 177                         gl.Vertex2f( 0.0, 0.9 );
 178                         gl.Vertex2f( 0.9, 0.9 );
 179                         gl.Vertex2f( 0.9, 0.0 );
 180                         gl.End();
 181                         gl.Translatef ( 0.0, 1.0 , 0.0 );
 182                 }
 183                 gl.PopMatrix();
 184
 185                 gl.PushMatrix();
 186                 gl.Translatef( 0.01 , -boardh, 0.0 );
 187                 gl.Scalef( 0.1, 0.1, 1.0 );
 188
 189                 for ( 0 => ix; ix < p2score ; ix + 1 => ix ) {
 190                         gl.Begin(gl.QUADS);
 191                         gl.Vertex2f( 0.0, 0.0 );
 192                         gl.Vertex2f( 0.0, 0.9 );
 193                         gl.Vertex2f( 0.9, 0.9 );
 194                         gl.Vertex2f( 0.9, 0.0 );
 195                         gl.End();
 196                         gl.Translatef ( 0.0, 1.0 , 0.0 );
 197                 }
 198                 gl.PopMatrix();
 199
 200
 201                 gl.Color4f ( 0.0, 1.0, 0.0, 0.5 ) ;
 202
 203                 gl.Begin(gl.LINE_LOOP);
 204                 gl.Vertex2f(-boardw, -boardh);
 205                 gl.Vertex2f( boardw, -boardh);
 206                 gl.Vertex2f( boardw,  boardh);
 207                 gl.Vertex2f(-boardw,  boardh);
 208                 gl.End();
 209
 210                 gl.PushMatrix();
 211                 gl.Translatef ( pad1x, pad1y, 0.0 );
 212                 gl.Begin(gl.QUADS );
 213                 gl.Vertex3f ( -padw, -padh, 0.0 );
 214                 gl.Vertex3f (  padw, -padh, 0.0 );
 215                 gl.Vertex3f (  padw,  padh, 0.0 );
 216                 gl.Vertex3f ( -padw,  padh, 0.0 );
 217                 gl.End();
 218                 gl.PopMatrix();
 219
 220                 gl.PushMatrix();
 221                 gl.Translatef (  pad2x , pad2y, 0.0 );
 222                 gl.Begin(gl.QUADS );
 223                 gl.Vertex3f ( -padw, -padh, 0.0 );
 224                 gl.Vertex3f (  padw, -padh, 0.0 );
 225                 gl.Vertex3f (  padw,  padh, 0.0 );
 226                 gl.Vertex3f ( -padw,  padh, 0.0 );
 227                 gl.End();
 228                 gl.PopMatrix();
 229
 230                 gl.PushMatrix();
 231                 gl.Translatef ( puckx ,  pucky , 0.1);
 232                 gl.Begin(gl.QUADS) ;
 233                 gl.Vertex2f ( -puckrad, -puckrad );
 234                 gl.Vertex2f (  puckrad, -puckrad );
 235                 gl.Vertex2f (  puckrad,  puckrad );
 236                 gl.Vertex2f ( -puckrad,  puckrad );
 237                 gl.End();
 238                 gl.PopMatrix();
 239
 240                 gl.Begin(gl.LINES);
 241                 gl.Vertex2f(0.0,  boardh );
 242                 gl.Vertex2f(0.0, -boardh );
 243                 gl.End();
 244
 245
 246                 gl.Flush();
 247                 gluck.SwapBuffers();
 248
 249 }
 250
 251 function void sndtrigger ( int which ) {
 252
 253         if ( which == 1 ) {
 254                 1.5 => shake1.noteOn;
 255         }
 256         else if ( which == 2 ) {
 257                 1.5 => shake2.noteOn;
 258         }
 259         else if ( which == 3 ) {
 260                 220.0 => t.freq;
 261                 0.9  + math.max ( 0.0, math.min ( 1.0 , std.abs( puckvy * 0.3 ))) => t.noteOn;
 262         }
 263
 264         else if ( which == 4 ) {
 265                 440.0 => t.freq;
 266                 0.7  + math.max ( 0.0, math.min ( 1.0 , std.abs( puckvy * 0.3 ))) => t.noteOn;
 267         }
 268 }
 269
 270
 271
 272 function void score ( int which ) {
 273         if ( which == 1 ) {
 274                 p1score + 1 => p1score;
 275                 p1score => shake1.which;
 276         }
 277
 278         else if ( which == 2 ) {
 279                 p2score + 1 => p2score;
 280                 p2score => shake2.which;
 281         }
 282         0.0 => puckx;
 283         0.0 => pucky;
 284         0.0 => puckvx;
 285         0.0 => puckvy;
 286 }
 287
 288 function void testcollisions() {
 289
 290         //pad1;
 291         if ( pad1y + padh > boardh ) {
 292                 pad1vy * -0.1 => pad1vy;
 293                 boardh + (  boardh - ( pad1y + padh ) ) - padh => pad1y;
 294         }
 295         if ( pad1y - padh < -boardh ) {
 296                 pad1vy * -0.1 => pad1vy;
 297                 -boardh + ( -boardh - (pad1y-padh) ) + padh  => pad1y;
 298         }
 299
 300         math.max ( -boardw , math.min ( -boardw * 0.5 , pad1x ) ) => pad1x;
 301         math.max (  boardw * 0.5 , math.min ( boardw  , pad2x ) ) => pad2x;
 302
 303         //pad2;
 304         if ( pad2y + padh > boardh ) {
 305                 pad2vy * -0.1 => pad2vy;
 306                 boardh + (  boardh - ( pad2y + padh ) ) - padh => pad2y;
 307         }
 308         if ( pad2y - padh < -boardh ) {
 309                 pad2vy * -0.1 => pad2vy;
 310                 -boardh + ( -boardh - (pad2y-padh) ) + padh  => pad2y;
 311         }
 312
 313         //puck
 314
 315         //top/bottom
 316         if ( pucky < -boardh ) {
 317                 sndtrigger(3);
 318                 puckvy * -1.0 => puckvy;
 319         }
 320         if ( boardh < pucky) {
 321                 sndtrigger(4);
 322                 puckvy * -1.0 => puckvy;
 323         }
 324
 325         pad1x + padw => p1f;
 326         pad2x - padw => p2f;
 327
 328         if ( puckx < -boardw ) {
 329                 score( 2 );
 330         }
 331         else if ( puckx > boardw ) {
 332                 score( 1 );
 333         }
 334
 335
 336         if ( puckx - puckrad < p1f && pucky < pad1y + padh && pucky > pad1y - padh ) {
 337                 if ( puckx - puckrad + puckvx * -dt * 5.0  > p1f + pad1vx * -dt * 5.0 ) {
 338                         p1f + ( p1f - ( puckx - puckrad )  ) + puckrad => puckx;
 339                         puckvy + 0.3 * ( pad1vy - puckvy ) => puckvy; //friction transfer...
 340                         if ( oldskool ) { puckvx * -1.0 => puckvx; }
 341                         else {
 342                                 pad1vx + -0.3 * ( puckvx - pad1vx ) => puckvx; //ricochet
 343                         }
 344                         sndtrigger(1);
 345                 }
 346         }
 347         else if ( puckx + puckrad > p2f && pucky < pad2y + padh && pucky > pad2y - padh ) {
 348                 if ( puckx + puckrad + puckvx * -dt * 5.0 < p2f + pad2vx * -dt * 5.0 ) {
 349                         p2f + ( p2f - ( puckx + puckrad ) ) - puckrad  => puckx;
 350                         puckvy + 0.3 * ( pad2vy - puckvy )  => puckvy; //friction transfer...
 351                         if ( oldskool ) { puckvx * -1.0 => puckvx; }
 352                         else {
 353                                 pad2vx + -0.3 * ( puckvx - pad2vx ) => puckvx; //ricochet
 354                         }
 355                         sndtrigger(2);
 356                 }
 357         }
 358 }
 359
 360
 361 function void simulshred() {
 362
 363         while ( running == 1 ) {
 364
 365                 0.0 => puckax;
 366                 0.0 => puckay;
 367
 368                 //drag on the paddles.
 369                 std.sgn( pad1vy ) * math.max( 0.0, std.abs(pad1vy) - 0.2 * dt ) => pad1vy;
 370                 std.sgn( pad2vy ) * math.max( 0.0, std.abs(pad2vy) - 0.2 * dt ) => pad2vy;
 371                 std.sgn( pad1vx ) * math.max( 0.0, std.abs(pad1vx) - 0.2 * dt ) => pad1vx;
 372                 std.sgn( pad2vx ) * math.max( 0.0, std.abs(pad2vx) - 0.2 * dt ) => pad2vx;
 373
 374                 testcollisions();
 375
 376                 //gravittles
 377
 378                 if ( !oldskool ) puckay + grav => puckay;
 379
 380                 pad1y + pad1vy * dt => pad1y;
 381                 pad2y + pad2vy * dt => pad2y;
 382
 383                 if ( !oldskool ) {
 384                         pad1x + pad1vx * dt => pad1x;
 385                         pad2x + pad2vx * dt => pad2x;
 386                 }
 387
 388                 puckvx + puckax * dt => puckvx;
 389                 puckvy + puckay * dt => puckvy;
 390
 391                 puckx + puckvx * dt => puckx;
 392                 pucky + puckvy * dt => pucky;
 393
 394                 10::ms => now;
 395
 396         }
 397 }
 398
 399 function void eventshred() {
 400
 401         //handle events that were buffered by glut's calls.
 402         //once we have events, this will change.
 403
 404         while ( running == 1 ) {
 405                 theeventpoll();
 406                 30::ms => now;
 407         }
 408
 409 }
 410
 411 function void gluckinitcall() {
 412
 413
 414         gluck.Init();   //MUST be called before any other gluck function
 415
 416         gluck.InitBasicWindow("ponnng?"); //request a window...
 417
 418         gluck.InitCallbacks(0, 1, 1); //register callbacks for the window
 419         //arguments monitor ( mouse, motion, keyboard );
 420
 421         //set up a simple view matrix
 422
 423         gl.MatrixMode(gl.PROJECTION);
 424         gl.LoadIdentity();
 425         gl.Ortho(-1.0, 1.0, -1.0 , 1.0, -4.0 , 4.0 );
 426
 427         gl.MatrixMode(gl.MODELVIEW);
 428         gl.LoadIdentity();
 429
 430
 431         gl.ClearColor ( 0.0 , 0.0, 0.3, 0.0 );
 432 }
 433
 434 function void eventloop( ) {
 435
 436         gluck.MainLoopEvent(); // let glut do its bizness
 437         if ( gluck.NeedDraw() && running == 1 ) { drawWindow(); }
 438         gluck.PostRedisplay(); // request that we draw again;
 439
 440 }
 441
 442 function void gluckshred() {
 443
 444         gluckinitcall();
 445         spork ~ eventshred();
 446         while ( running == 1 ) {
 447                 eventloop();
 448                 33::ms => now; //30 fps
 449         }
 450 }
 451
 452 spork ~ gluckshred();
 453 spork ~ simulshred();
 454
 455 while ( running == 1 ) {
 456
 457         0.3::second => now;
 458
 459 }