![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to BreakView.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / BreakApp|
Return to BreakView.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / BreakApp |
1.1 ! root 1: /* ! 2: * BreakView.m, view to implement the "BreakApp" game. ! 3: * Author: Ali Ozer ! 4: * Written for 0.8 October 88. ! 5: * Modified for 0.9 March 89. ! 6: * Modified for 1.0 July 89. ! 7: * Removed use of Bitmap and threw away some classes May 90. ! 8: * Final 2.0 fixes/enhancements Sept 90. ! 9: * 3.0 update March 92. ! 10: * Sound-related changes for 3.1 March 92. ! 11: * ! 12: * BreakView implements an interactive custom view that allows the user ! 13: * to play "BreakApp," a game similar to a popular arcade classic. ! 14: * ! 15: * BreakView's main control methods are based on the target-action ! 16: * paradigm; thus you can include BreakView in an Interface-Builder based ! 17: * application. Please refer to BreakView.h for a list of "public" methods ! 18: * that you should provide links to in Interface Builder. ! 19: * ! 20: * You may freely copy, distribute and reuse the code in this example. ! 21: * NeXT disclaims any warranty of any kind, expressed or implied, ! 22: * as to its fitness for any particular use. ! 23: */ ! 24: ! 25: #import <libc.h> ! 26: #import <math.h> ! 27: #import <defaults/defaults.h> // For writing/reading high score ! 28: #import <appkit/appkit.h> ! 29: ! 30: #import "BreakView.h" ! 31: #import "SoundEffect.h" ! 32: ! 33: // Max absolute x and y velocities of the ball, in base coordinates per msec. ! 34: ! 35: #define MAXXV ((level > 6) ? 0.3 : 0.2) ! 36: #define MAXYV (0.4) ! 37: ! 38: // Maximum amount of time that is allowed to pass between two calls to the ! 39: // step method. If the time is greater than MAXTIMEDIFFERENCE, then this ! 40: // value is used instead. MAXTIMEDIFFERENCE should be no greater ! 41: // than the time it takes for the ball to go the height of a tile ! 42: // or the height of the ball + height of paddle. The units ! 43: // are in milliseconds. ! 44: ! 45: #define MAXTIMEDIFFERENCE (TILEHEIGHT * 0.8 / MAXYV) ! 46: #define MINTIMEDIFFERENCE 1 ! 47: ! 48: // Max revolution speed of the ball; this is the maximum ! 49: // number of radians it will turn per millisecond when rotating... ! 50: ! 51: #define MAXREVOLUTIONSPEED (M_PI / 250.0) // Max is 2 revs/sec ! 52: ! 53: // The following values are the default sizes for the various pieces. ! 54: ! 55: #define RADIUS 8.0 // Ball radius ! 56: #define PADDLEWIDTH (TILEWIDTH * 1.8) // Paddle width ! 57: #define PADDLEHEIGHT (TILEHEIGHT * 0.6) // Paddle height ! 58: #define BALLWIDTH (RADIUS * 2.0) // Ball width ! 59: #define BALLHEIGHT (RADIUS * 2.0) // Ball height ! 60: ! 61: // SHADOWOFFSET defines the amount the shadow is offset from the piece. ! 62: ! 63: #define SHADOWOFFSET 3.0 ! 64: ! 65: #define LIVES 5 // Number of lives per game ! 66: ! 67: #define STOPGAMEAT (-10) // Number of loops through the ! 68: // game after all tiles die ! 69: ! 70: #define LEVELBONUS 50 // Bonus at the end of a level ! 71: ! 72: // Starting locations... ! 73: ! 74: #define PADDLEX ((gameSize.width - paddleSize.width) / 2.0) ! 75: #define PADDLEY 1.0 ! 76: #define BALLX ((gameSize.width - ballSize.width) / 2.0) ! 77: #define BALLY (paddleY + paddleSize.height) ! 78: ! 79: // Accelaration & score values of the different tile types. ! 80: ! 81: static const float tileAccs[NUMTILETYPES] = {1.0, 1.3}; ! 82: static const int tileScores[NUMTILETYPES] = {5, 25}; ! 83: ! 84: #define NOTILE -1 ! 85: ! 86: extern void srandom(); // Hmm; not in libc.h ! 87: #define RANDINT(n) (random() % ((n)+1)) // Random integer 0..n ! 88: #define ONEIN(n) ((random() % (n)) == 0) // TRUE one in n times ! 89: #define INITRAND srandom(time(0)) // Randomizer ! 90: ! 91: #define gameSize bounds.size ! 92: ! 93: // Restrict a value to the range -max .. max. ! 94: ! 95: inline float restrictValue(float val, float max) ! 96: { ! 97: if (val > max) return max; ! 98: else if (val < -max) return -max; ! 99: else return val; ! 100: } ! 101: ! 102: // Convert x-location to left/right pan for playing sounds ! 103: ! 104: @implementation BreakView ! 105: ! 106: - initFrame:(const NXRect *)frm ! 107: { ! 108: [super initFrame:frm]; ! 109: ! 110: [self allocateGState]; // For faster lock/unlockFocus ! 111: ! 112: [(ball = [[NXImage allocFromZone:[self zone]] init]) setScalable:NO]; ! 113: [ball useDrawMethod:@selector(drawBall:) inObject:self]; ! 114: ! 115: [(paddle = [[NXImage allocFromZone:[self zone]] init]) setScalable:NO]; ! 116: [paddle useDrawMethod:@selector(drawPaddle:) inObject:self]; ! 117: ! 118: [(tile[0] = [[NXImage allocFromZone:[self zone]] init]) setScalable:NO]; ! 119: [(tile[1] = [[NXImage allocFromZone:[self zone]] init]) setScalable:NO]; ! 120: [tile[0] useDrawMethod:@selector(drawNormalTile:) inObject:self]; ! 121: [tile[1] useDrawMethod:@selector(drawToughTile:) inObject:self]; ! 122: ! 123: wallSound = [[SoundEffect allocFromZone:[self zone]] initFromSection:"Wall.snd"]; ! 124: tileSound = [[SoundEffect allocFromZone:[self zone]] initFromSection:"Tile.snd"]; ! 125: missSound = [[SoundEffect allocFromZone:[self zone]] initFromSection:"Miss.snd"]; ! 126: paddleSound = [[SoundEffect allocFromZone:[self zone]] initFromSection:"Paddle.snd"]; ! 127: ! 128: [self setBackgroundFile:NXGetDefaultValue([NXApp appName], "BackGround") andRemember:NO]; ! 129: ! 130: [self resizePieces]; ! 131: ! 132: [self getHighScore]; ! 133: ! 134: demoMode = NO; ! 135: ! 136: INITRAND; ! 137: ! 138: return self; ! 139: } ! 140: ! 141: // free simply gets rid of everything we created for BreakView, including ! 142: // the instance of BreakView itself. This is how nice objects clean up. ! 143: ! 144: - free ! 145: { ! 146: int cnt; ! 147: ! 148: if (gameRunning) { ! 149: DPSRemoveTimedEntry (timer); ! 150: } ! 151: for (cnt = 0; cnt < NUMTILETYPES; cnt++) { ! 152: [tile[cnt] free]; ! 153: } ! 154: ! 155: [ball free]; ! 156: [paddle free]; ! 157: [backGround free]; ! 158: [wallSound free]; ! 159: [tileSound free]; ! 160: [missSound free]; ! 161: [paddleSound free]; ! 162: ! 163: return [super free]; ! 164: } ! 165: ! 166: // resizePieces calculates the new sizes of all the pieces after the game is ! 167: // started or the playing field (the BreakView) is resized. ! 168: ! 169: - resizePieces ! 170: { ! 171: int cnt; ! 172: float xRatio = gameSize.width / GAMEWIDTH; ! 173: float yRatio = gameSize.height / GAMEHEIGHT; ! 174: ! 175: [backGround setSize:&gameSize]; ! 176: ! 177: tileSize.width = floor(xRatio * TILEWIDTH); ! 178: tileSize.height = floor(yRatio * TILEHEIGHT); ! 179: for (cnt = 0; cnt < NUMTILETYPES; cnt++) { ! 180: [tile[cnt] setSize:&tileSize]; ! 181: } ! 182: leftMargin = floor((gameSize.width - (tileSize.width + INTERTILE) * ! 183: NUMTILESX) / 2.0 + 1.0); ! 184: ! 185: paddleSize.width = floor(xRatio * PADDLEWIDTH); ! 186: paddleSize.height = floor(yRatio * PADDLEHEIGHT); ! 187: [paddle setSize:&paddleSize]; ! 188: ! 189: ballSize.width = floor(xRatio * BALLWIDTH); ! 190: ballSize.height = floor(yRatio * BALLHEIGHT); ! 191: [ball setSize:&ballSize]; ! 192: ! 193: return self; ! 194: } ! 195: ! 196: // The following allows BreakView to grab the mousedown event that activates ! 197: // the window. By default, the View's acceptsFirstMouse returns NO. ! 198: ! 199: - (BOOL)acceptsFirstMouse ! 200: { ! 201: return YES; ! 202: } ! 203: ! 204: // This methods allows changing the file used to paint the background of the ! 205: // playing field. Set fileName to NULL to revert to the default. Set ! 206: // remember to YES if you wish the write the value out in the defaults. ! 207: ! 208: - setBackgroundFile:(const char *)fileName andRemember:(BOOL)remember ! 209: { ! 210: [backGround free]; ! 211: backGround = [[NXImage allocFromZone:[self zone]] initSize:&gameSize]; ! 212: if (fileName) { ! 213: [backGround useFromFile:fileName]; ! 214: [backGround setScalable:YES]; ! 215: if (remember) { ! 216: NXWriteDefault ([NXApp appName], "BackGround", fileName); ! 217: } ! 218: } else { ! 219: [backGround useDrawMethod:@selector(drawDefaultBackground:) inObject:self]; ! 220: [backGround setScalable:NO]; ! 221: if (remember) { ! 222: NXRemoveDefault ([NXApp appName], "BackGround"); ! 223: } ! 224: } ! 225: [backGround setBackgroundColor:NX_COLORWHITE]; ! 226: [self display]; ! 227: ! 228: return self; ! 229: } ! 230: ! 231: // The following two methods allow changing the background image from ! 232: // menu items or buttons. ! 233: ! 234: - changeBackground:sender ! 235: { ! 236: if ([[OpenPanel new] runModalForTypes:[NXImage imageFileTypes]]) { ! 237: [self setBackgroundFile:[[OpenPanel new] filename] andRemember:YES]; ! 238: [self display]; ! 239: } ! 240: ! 241: return self; ! 242: } ! 243: ! 244: - revertBackground:sender ! 245: { ! 246: [self setBackgroundFile:NULL andRemember:YES]; ! 247: [self display]; ! 248: return self; ! 249: } ! 250: ! 251: // getHighScore reads the previous high score from the user's defaults file. ! 252: // If no such default is found, then the high score is set to zero. ! 253: ! 254: - getHighScore ! 255: { ! 256: const char *tmpstr; ! 257: if (((tmpstr = NXGetDefaultValue ([NXApp appName], "HighScore")) && ! 258: (sscanf(tmpstr, "%d", &highScore) != 1))) highScore = 0; ! 259: ! 260: return self; ! 261: } ! 262: ! 263: // setHighScore should be called when the user score for a game is above ! 264: // the current high score. setHighScore sets the high score and ! 265: // writes it out the defaults file so that it can be remembered for eternity. ! 266: ! 267: - setHighScore:(int)hScore ! 268: { ! 269: char str[10]; ! 270: [hscoreView setIntValue:(highScore = hScore)]; ! 271: sprintf (str, "%d", highScore); ! 272: NXWriteDefault ([NXApp appName], "HighScore", str); ! 273: return self; ! 274: } ! 275: ! 276: - (int)score ! 277: { ! 278: return score; ! 279: } ! 280: ! 281: - (int)level ! 282: { ! 283: return level; ! 284: } ! 285: ! 286: - (int)lives ! 287: { ! 288: return lives; ! 289: } ! 290: ! 291: // gotoFirstLevel: sets everything up for a new game. ! 292: ! 293: - gotoFirstLevel:sender ! 294: { ! 295: score = 0; ! 296: level = 0; ! 297: lives = LIVES; ! 298: return [self gotoNextLevel:sender]; ! 299: } ! 300: ! 301: // gotoNextLevel: sets everything up for the next level of the game; the level ! 302: // count is incremented and the pieces are set up on the field. The ball and ! 303: // the paddle are also brought to the starting locations. ! 304: // ! 305: // This routine can of course be made infinitely more complicated in ! 306: // determining where the tiles go. Left as an exercise to the reader. 8-) ! 307: ! 308: - gotoNextLevel:sender ! 309: { ! 310: int xcnt, ycnt, yFrom, yTo, xFrom, xTo; ! 311: ! 312: // We are at the next level... Stop the game and increment the level. ! 313: ! 314: [self stop:sender]; ! 315: ! 316: level++; ! 317: ! 318: // Now place the tiles. Here's where we could do some fancy tile layout, ! 319: // depending on the game level. yFrom, yTo, xFrom, and xTo define the "box" ! 320: // in which we will lay the tiles out. These values are inclusive. ! 321: ! 322: switch (level % 6) { ! 323: case 0: yTo = NUMTILESY-2; break; ! 324: case 4: yTo = NUMTILESY-4; break; ! 325: case 5: yTo = 2 * (NUMTILESY / 3); break; ! 326: default: yTo = 3 * (NUMTILESY / 4); break; ! 327: } ! 328: ! 329: xFrom = 0; xTo = NUMTILESX-1; yFrom = yTo - 3; ! 330: ! 331: switch (level % 10) { ! 332: case 1: yFrom++; break; ! 333: case 2: yFrom--; xFrom++; xTo--; break; ! 334: case 4: xFrom += 2; xTo -= 2; break; ! 335: case 6: yFrom = MIN(yFrom, NUMTILESY / 4); xFrom++; xTo--; break; ! 336: case 7: xTo -= 3; break; ! 337: case 8: yFrom -= 2; xFrom += 2; xTo -= 2; break; ! 338: case 9: yFrom = MIN(yFrom, NUMTILESY / 4); ! 339: yTo = MAX(yTo, yFrom+4); ! 340: break; ! 341: case 0: yFrom = MIN(yFrom, NUMTILESY / 5); ! 342: xFrom += (NUMTILESX / 2); ! 343: break; ! 344: default: break; ! 345: } ! 346: ! 347: // The area in the playing field where we place tiles is at least 3 tiles ! 348: // high and at least NUMTILESX-4 tiles wide. ! 349: ! 350: // Empty out the whole playing field. ! 351: for (xcnt = 0; xcnt < NUMTILESX; xcnt++) { ! 352: for (ycnt = 0; ycnt < NUMTILESY; ycnt++) { ! 353: tiles[xcnt][ycnt] = NOTILE; ! 354: } ! 355: } ! 356: ! 357: // Fill up the tile area with wimpy tiles ! 358: for (ycnt = yFrom; ycnt <= yTo; ycnt++) { ! 359: for (xcnt = xFrom; xcnt <= xTo; xcnt++) { ! 360: tiles[xcnt][ycnt] = 0; ! 361: } ! 362: } ! 363: ! 364: // Erase or change some of the tiles, depending on the level. ! 365: // Assumption is that we have at least 3 rows of tiles, yFrom..yTo. ! 366: ! 367: switch (level % 7) { ! 368: case 2: // clear two rows in the middle ! 369: for (xcnt = xFrom; xcnt <= xTo; xcnt++) { ! 370: tiles[xcnt][yFrom+1] = tiles[xcnt][yTo-1] = NOTILE; ! 371: } ! 372: break; ! 373: case 3: // randomly clear out some tiles ! 374: for (xcnt = 0; xcnt < 5; xcnt++) { ! 375: tiles[xFrom+RANDINT(xTo-xFrom)][yFrom+1+RANDINT(yTo-yFrom-2)] = ! 376: NOTILE; ! 377: } ! 378: break; ! 379: case 4: // clear middle columns ! 380: for (xcnt = xFrom + 2; xcnt <= xTo - 2; xcnt++) { ! 381: for (ycnt = yFrom; ycnt <= yTo; ycnt++) { ! 382: tiles[xcnt][ycnt] = NOTILE; ! 383: } ! 384: } ! 385: break; ! 386: case 6: // clear out the insides ! 387: for (ycnt = yFrom+1; ycnt < yTo; ycnt++) { ! 388: for (xcnt = xFrom+1; xcnt < xTo; xcnt++) { ! 389: tiles[xcnt][ycnt] = NOTILE; ! 390: } ! 391: } ! 392: break; ! 393: default: ! 394: break; ! 395: } ! 396: ! 397: // Drop in some tough tiles in all rows except the first one ! 398: for (xcnt = 0; xcnt < 5; xcnt++) { ! 399: tiles[xFrom+RANDINT(xTo-xFrom)][yFrom+1+RANDINT(yTo-yFrom-1)] = 1; ! 400: } ! 401: ! 402: // Compute the number of tiles we actually ended up putting down... ! 403: numTilesLeft = 0; ! 404: for (ycnt = yFrom; ycnt <= yTo; ycnt++) { ! 405: for (xcnt = xFrom; xcnt <= xTo; xcnt++) { ! 406: if (tiles[xcnt][ycnt] != NOTILE) numTilesLeft++; ! 407: } ! 408: } ! 409: ! 410: // Of course you might think there are too many braces in the above code, ! 411: // where probably none would've sufficed. Too many braces never hurt, & it ! 412: // will save you from some bozo bug some day. So use them! They're cheap! ! 413: ! 414: [self resetBallAndPaddle]; ! 415: ! 416: [levelView setIntValue:level]; ! 417: [scoreView setIntValue:score]; ! 418: [livesView setIntValue:lives]; ! 419: [hscoreView setIntValue:highScore]; ! 420: [statusView setStringValue:NXLocalString("Game Ready", NULL, "Message indicating the game is ready to run")]; ! 421: ! 422: killerBall = ((level % 12) == 0); // Every 12 turns, the loses its ! 423: // ability to bounce off tiles ! 424: niceBall = (level % 5 == 0); // Every 5 turns, make the ball ! 425: // bounce towards the paddle ! 426: ! 427: // If the background image is not from a file but our own default, ! 428: // poke it so its redrawn. This way every level will look different. ! 429: // We could've simply used a BOOL to remember if the image is the default ! 430: // one, but this test here works as well. ! 431: ! 432: if ([[backGround lastRepresentation] isKindOf:[NXCustomImageRep class]]) { ! 433: [backGround recache]; ! 434: } ! 435: ! 436: [self display]; // Display the new arrangement ! 437: ! 438: if (demoMode) { ! 439: [self go:sender]; // If in demo mode, start rolling ! 440: } ! 441: ! 442: return self; ! 443: } ! 444: ! 445: // setDemoMode: allows the user to put the game in a demo mode. ! 446: // In the demo mode, the paddle constantly follows the ball. ! 447: ! 448: - setDemoMode:sender ! 449: { ! 450: if (demoMode = ([sender state] == 0 ? NO : YES)) { ! 451: [self go:sender]; ! 452: } else { ! 453: [self stop:sender]; ! 454: } ! 455: return self; ! 456: } ! 457: ! 458: // This method should be called when a new level or game is started or the ! 459: // player misses the ball. It resets the ball & paddle locations back to ! 460: // default. ! 461: ! 462: - resetBallAndPaddle ! 463: { ! 464: paddleX = PADDLEX; ! 465: paddleY = PADDLEY; ! 466: ballX = BALLX; ! 467: ballY = BALLY; ! 468: ! 469: ballXVel = 0.0; ! 470: ballYVel = 0.0; ! 471: ! 472: // The ball shouldn't start out rotating... ! 473: revolutionsLeft = 0; ! 474: ! 475: return self; ! 476: } ! 477: ! 478: // The directBallAt: initializes the velocity vector of the ball so that ! 479: // the ball will go from its current location to the specified destination ! 480: // point. The speed of the ball is determined by the current level. If ballYVel ! 481: // is already set, then only the x velocity & y direction is changed. ! 482: ! 483: - directBallAt:(NXPoint *)dest ! 484: { ! 485: float desiredYVel = dest->y - (ballY + ballSize.height / 2.0); ! 486: float desiredXVel = dest->x - (ballX + ballSize.width / 2.0); ! 487: ! 488: // Transform back to original game coords (velocity values are measured ! 489: // in these). ! 490: ! 491: desiredYVel /= (gameSize.height / GAMEHEIGHT); ! 492: desiredXVel /= (gameSize.width / GAMEWIDTH); ! 493: ! 494: if (fabs(desiredYVel) < 1.0) { ! 495: desiredYVel = desiredYVel < 0.0 ? -1.0 : 1.0; ! 496: } ! 497: if (ballYVel == 0.0) { ! 498: // Come up with a value between 60 and 100% of MAXYV. ! 499: ballYVel = restrictValue(((RANDINT(level * 8) + 60.0) / 100.0) * MAXYV, ! 500: MAXYV); ! 501: } ! 502: ballYVel = fabs(ballYVel) * (desiredYVel < 0.0 ? -1.0 : 1.0); ! 503: ballXVel = restrictValue(ballYVel * (desiredXVel / desiredYVel) ,MAXXV); ! 504: ! 505: return self; ! 506: } ! 507: ! 508: // The stop method will pause a running game. The go method will start it up ! 509: // again. They can be assigned to buttons or other appkit objects through IB. ! 510: ! 511: - go:sender ! 512: { ! 513: void runOneStep (); ! 514: if (lives && !gameRunning) { ! 515: // If the ball velocity wasn't initialized, start it rolling ! 516: // towards the mouse location... ! 517: if (ballXVel == 0.0 && ballYVel == 0.0) { ! 518: NXPoint mouseLoc; ! 519: [[self window] getMouseLocation:&mouseLoc]; ! 520: [self convertPoint:&mouseLoc fromView:nil]; ! 521: [self directBallAt:&mouseLoc]; ! 522: ballYVel = fabs(ballYVel); ! 523: } ! 524: gameRunning = YES; ! 525: timer = DPSAddTimedEntry(0.03, &runOneStep, self, NX_BASETHRESHOLD); ! 526: [statusView setStringValue:NXLocalString("Running", NULL, "Message indicating that the game is running")]; ! 527: } ! 528: return self; ! 529: } ! 530: ! 531: - stop:sender ! 532: { ! 533: if (gameRunning) { ! 534: gameRunning = NO; ! 535: DPSRemoveTimedEntry (timer); ! 536: [statusView setStringValue:NXLocalString("Paused", NULL, "Message indicating that the game is paused")]; ! 537: } ! 538: ! 539: return self; ! 540: } ! 541: ! 542: - sizeTo:(NXCoord)width :(NXCoord)height ! 543: { ! 544: NXSize oldSize = bounds.size; ! 545: ! 546: [super sizeTo:width :height]; ! 547: ! 548: ballX = (ballX * width / oldSize.width); ! 549: ballY = (ballY * height / oldSize.height); ! 550: paddleX = (paddleX * width / oldSize.width); ! 551: paddleY = (paddleY * height / oldSize.height); ! 552: ! 553: [self resizePieces]; ! 554: ! 555: [self display]; ! 556: return self; ! 557: } ! 558: ! 559: // A mousedown effectively allows pausing and unpausing the game by ! 560: // alternately calling one of the above two functions (stop/go). ! 561: ! 562: - mouseDown:(NXEvent *)event ! 563: { ! 564: if (gameRunning) { ! 565: [self stop:self]; ! 566: } else if (lives) { ! 567: [self go:self]; ! 568: } ! 569: return self; ! 570: } ! 571: ! 572: // The following few methods draw the pieces. ! 573: ! 574: - drawBall:imageRep ! 575: { ! 576: PSscale (ballSize.width / BALLWIDTH, ballSize.height / BALLHEIGHT); ! 577: ! 578: // First draw the shadow under the ball. ! 579: ! 580: PSarc (RADIUS+SHADOWOFFSET/2, RADIUS-SHADOWOFFSET/2, ! 581: RADIUS-SHADOWOFFSET-1.0, 0.0, 360.0); ! 582: PSsetgray (NX_BLACK); ! 583: if (NXDrawingStatus == NX_DRAWING) { ! 584: PSsetalpha (0.666); ! 585: } ! 586: PSfill (); ! 587: if (NXDrawingStatus == NX_DRAWING) { ! 588: PSsetalpha (1.0); ! 589: } ! 590: ! 591: // Then the ball. ! 592: ! 593: PSarc (RADIUS-SHADOWOFFSET/2, RADIUS+SHADOWOFFSET/2, ! 594: RADIUS-SHADOWOFFSET-1.0, 0.0, 360.0); ! 595: PSsetgray (NX_LTGRAY); ! 596: PSfill (); ! 597: ! 598: // And the lighter & darker spots on the ball... ! 599: ! 600: PSarcn (RADIUS-SHADOWOFFSET/2, RADIUS+SHADOWOFFSET/2, ! 601: RADIUS-SHADOWOFFSET-3.0, 170.0, 100.0); ! 602: PSarc (RADIUS-SHADOWOFFSET/2, RADIUS+SHADOWOFFSET/2, ! 603: RADIUS-SHADOWOFFSET-2.0, 100.0, 170.0); ! 604: PSsetgray (NX_WHITE); ! 605: PSfill (); ! 606: PSarcn (RADIUS-SHADOWOFFSET/2, RADIUS+SHADOWOFFSET/2, ! 607: RADIUS-SHADOWOFFSET-2.0, 350.0, 280.0); ! 608: PSarc (RADIUS-SHADOWOFFSET/2, RADIUS+SHADOWOFFSET/2, ! 609: RADIUS-SHADOWOFFSET-2.0, 280.0, 350.0); ! 610: PSsetgray (NX_DKGRAY); ! 611: PSfill (); ! 612: ! 613: return self; ! 614: } ! 615: ! 616: // Function to draw a shadow under the given rectangle. ! 617: ! 618: static void drawRectangularShadowUnder (NXRect *rect, float offset) ! 619: { ! 620: NXRect shadeRect = *rect; ! 621: NXOffsetRect (&shadeRect, offset, -offset); ! 622: ! 623: PSsetgray (NX_BLACK); ! 624: if (NXDrawingStatus != NX_PRINTING) { ! 625: PSsetalpha (0.666); ! 626: } ! 627: NXRectFill (&shadeRect); ! 628: if (NXDrawingStatus != NX_PRINTING) { ! 629: PSsetalpha (1.0); ! 630: } ! 631: } ! 632: ! 633: - drawPaddle:imageRep ! 634: { ! 635: NXRect pieceRect = {{0.0, SHADOWOFFSET}, ! 636: {(paddleSize.width-SHADOWOFFSET)-1, ! 637: (paddleSize.height-SHADOWOFFSET)-1}}; ! 638: ! 639: drawRectangularShadowUnder (&pieceRect, SHADOWOFFSET); ! 640: ! 641: NXDrawButton (&pieceRect, NULL); ! 642: ! 643: return self; ! 644: } ! 645: ! 646: - drawToughTile:imageRep ! 647: { ! 648: NXRect pieceRect = {{0.0, SHADOWOFFSET}, ! 649: {(tileSize.width-SHADOWOFFSET)-1, ! 650: (tileSize.height-SHADOWOFFSET)-1}}; ! 651: ! 652: drawRectangularShadowUnder (&pieceRect, SHADOWOFFSET); ! 653: ! 654: NXDrawButton (&pieceRect, NULL); ! 655: NXInsetRect (&pieceRect, 3.0, 3.0); ! 656: NXDrawWhiteBezel (&pieceRect, NULL); ! 657: ! 658: return self; ! 659: } ! 660: ! 661: - drawNormalTile:imageRep ! 662: { ! 663: NXRect pieceRect = {{0.0, SHADOWOFFSET}, ! 664: {(tileSize.width-SHADOWOFFSET)-1, ! 665: (tileSize.height-SHADOWOFFSET)-1}}; ! 666: ! 667: drawRectangularShadowUnder (&pieceRect, SHADOWOFFSET); ! 668: ! 669: NXDrawButton (&pieceRect, NULL); ! 670: ! 671: return self; ! 672: } ! 673: ! 674: #define NUMYBOXES 10 ! 675: #define NUMXBOXES 6 ! 676: ! 677: // This method draws the default background. The default background consists of ! 678: // NUMXBOXES x NUMYBOXES raised boxes. Each box is drawn as four triangles to ! 679: // provide a raised effect. Boxes near the top left corner are lighter in color ! 680: // than the ones near the bottom right. ! 681: ! 682: - drawDefaultBackground:imageRep ! 683: { ! 684: #define NOTFOUND ((id)-1) ! 685: static NXColorList *colorList = nil; // Static because it's shared ! 686: NXSize boxSize = {gameSize.width / NUMXBOXES, gameSize.height / NUMYBOXES}; ! 687: int xCnt, yCnt; ! 688: NXColor color; ! 689: ! 690: // The first time we're here, we load and cache the color list. If we don't find ! 691: // it, we remember that fact so that we don't go through the search again. ! 692: if (colorList == nil) { ! 693: char colorListPath[MAXPATHLEN]; ! 694: if ([[NXBundle mainBundle] getPath:colorListPath forResource:"BreakApp" ofType:"clr"]) { ! 695: colorList = [[NXColorList allocFromZone:NXDefaultMallocZone()] initWithName:NULL fromFile:colorListPath]; ! 696: } ! 697: if (!colorList) { ! 698: NXLogError ("Can't find color list for backgrounds."); ! 699: colorList = NOTFOUND; ! 700: } ! 701: } ! 702: ! 703: // Now get the color. If the color list wasn't found, we use some default random color. ! 704: // Note that because colors in different color spaces might look different on ! 705: // different devices (although they might look identical on screen), it's ! 706: // important to always use colors from the same color space when creating ! 707: // a wash. Below we assure that our colors always start off in HSB color space. ! 708: ! 709: if (colorList != NOTFOUND) { ! 710: color = [colorList colorNamed:[colorList nameOfColorAt:(level % [colorList colorCount])]]; ! 711: color = NXConvertHSBToColor (NXHueComponent(color), NXSaturationComponent(color), 1.0); ! 712: } else { ! 713: color = NXConvertHSBToColor((level % 8) / 7.0, 0.8, 1.0); ! 714: } ! 715: ! 716: for (yCnt = 0; yCnt < NUMYBOXES; yCnt++) { ! 717: for (xCnt = 0; xCnt < NUMXBOXES; xCnt++) { ! 718: // Determine brightness (each box has a different brightness) ! 719: color = NXChangeBrightnessComponent(color, 0.4 + (yCnt + (4 - xCnt)) * (0.2 / (NUMYBOXES + NUMXBOXES))); ! 720: // The bottom triangle ! 721: PSmoveto (xCnt * boxSize.width + boxSize.width / 2.0, yCnt * boxSize.height + boxSize.height / 2.0); ! 722: PSrlineto (-boxSize.width / 2.0, -boxSize.height / 2.0); ! 723: PSrlineto (boxSize.width, 0); ! 724: NXSetColor (color); ! 725: PSfill (); ! 726: // The right triangle ! 727: PSmoveto (xCnt * boxSize.width + boxSize.width / 2.0, yCnt * boxSize.height + boxSize.height / 2.0); ! 728: PSrlineto (boxSize.width / 2.0, boxSize.height / 2.0); ! 729: PSrlineto (0, -boxSize.height); ! 730: NXSetColor (NXChangeBrightnessComponent(color, NXBrightnessComponent(color) * 1.2)); ! 731: PSfill (); ! 732: // The left triangle ! 733: PSmoveto (xCnt * boxSize.width + boxSize.width / 2.0, yCnt * boxSize.height + boxSize.height / 2.0); ! 734: PSrlineto (-boxSize.width / 2.0, boxSize.height / 2.0); ! 735: PSrlineto (0, -boxSize.height); ! 736: NXSetColor (NXChangeBrightnessComponent(color, NXBrightnessComponent(color) * 1.2 * 1.2)); ! 737: PSfill (); ! 738: // The right triangle ! 739: PSmoveto (xCnt * boxSize.width + boxSize.width / 2.0, yCnt * boxSize.height + boxSize.height / 2.0); ! 740: PSrlineto (boxSize.width / 2.0, boxSize.height / 2.0); ! 741: PSrlineto (-boxSize.width, 0.0); ! 742: NXSetColor (NXChangeBrightnessComponent(color, NXBrightnessComponent(color) * 1.2 * 1.2 * 1.2)); ! 743: PSfill (); ! 744: } ! 745: } ! 746: return self; ! 747: } ! 748: ! 749: // The following methods show or erase the ball and the paddle from the field. ! 750: ! 751: - showBall ! 752: { ! 753: NXRect tmpRect = {{floor(ballX), floor(ballY)}, ! 754: {ballSize.width, ballSize.height}}; ! 755: [ball composite:NX_SOVER toPoint:&tmpRect.origin]; ! 756: return self; ! 757: } ! 758: ! 759: - showPaddle ! 760: { ! 761: NXRect tmpRect = {{floor(paddleX), floor(paddleY)}, ! 762: {paddleSize.width, paddleSize.height}}; ! 763: [paddle composite:NX_SOVER toPoint:&tmpRect.origin]; ! 764: return self; ! 765: } ! 766: ! 767: - eraseBall ! 768: { ! 769: NXRect tmpRect = {{ballX, ballY}, {ballSize.width, ballSize.height}}; ! 770: return [self drawBackground:&tmpRect]; ! 771: } ! 772: ! 773: - erasePaddle ! 774: { ! 775: NXRect tmpRect = {{paddleX, paddleY}, ! 776: {paddleSize.width, paddleSize.height}}; ! 777: return [self drawBackground:&tmpRect]; ! 778: } ! 779: ! 780: // drawBackground: just draws the specified piece of the background by ! 781: // compositing from the background image. ! 782: ! 783: - drawBackground:(NXRect *)rect ! 784: { ! 785: NXRect tmpRect = *rect; ! 786: ! 787: NX_X(&tmpRect) = floor(NX_X(&tmpRect)); ! 788: NX_Y(&tmpRect) = floor(NX_Y(&tmpRect)); ! 789: if (NXDrawingStatus == NX_DRAWING) { ! 790: PSsetgray (NX_WHITE); ! 791: PScompositerect (NX_X(&tmpRect), NX_Y(&tmpRect), ! 792: NX_WIDTH(&tmpRect), NX_HEIGHT(&tmpRect), NX_COPY); ! 793: } ! 794: [backGround composite:NX_SOVER fromRect:&tmpRect toPoint:&tmpRect.origin]; ! 795: return self; ! 796: } ! 797: ! 798: // drawSelf::, a method every decent View should have, redraws the game ! 799: // in its current state. This allows us to print the game very easily. ! 800: ! 801: - drawSelf:(NXRect *)rects :(int)rectCount ! 802: { ! 803: int xcnt, ycnt; ! 804: ! 805: [self drawBackground:(rects ? rects : &bounds)]; ! 806: ! 807: for (xcnt = 0; xcnt < NUMTILESX; xcnt++) { ! 808: for (ycnt = 0; ycnt < NUMTILESY; ycnt++) { ! 809: if (tiles[xcnt][ycnt] != NOTILE) { ! 810: NXPoint tileLoc = {floor(leftMargin + (tileSize.width + INTERTILE) * xcnt), floor((tileSize.height + INTERTILE) * ycnt)}; ! 811: [tile[tiles[xcnt][ycnt]] composite:NX_SOVER toPoint:&tileLoc]; ! 812: } ! 813: } ! 814: } ! 815: ! 816: if (lives) { ! 817: [self showBall]; ! 818: [self showPaddle]; ! 819: } ! 820: ! 821: return self; ! 822: } ! 823: ! 824: // incrementGameScore: adds the value of the argument to the score if the game ! 825: // is not in demo mode. ! 826: ! 827: - incrementGameScore:(int)scoreIncrement ! 828: { ! 829: if (demoMode == NO) { ! 830: score += scoreIncrement; ! 831: } ! 832: return self; ! 833: } ! 834: ! 835: // hitTileAt:: checks to see if there's a tile at tile location x, y; ! 836: // if so, it is considered hit by the ball and cleared. hitTileTile:: also ! 837: // updates the score and the ball velocity. hitTileAt:: returns YES if there ! 838: // was a tile, NO otherwise. ! 839: ! 840: -(BOOL) hitTileAt:(int)x :(int)y ! 841: { ! 842: NXRect rect = {{floor(leftMargin + (tileSize.width + INTERTILE) * x), ! 843: floor((tileSize.height + INTERTILE) * y)}, ! 844: {tileSize.width, tileSize.height}}; ! 845: ! 846: if (x < NUMTILESX && y < NUMTILESY && x >= 0 && y >= 0 && ! 847: (tiles[x][y] != NOTILE)) { ! 848: [self incrementGameScore:tileScores[tiles[x][y]]]; ! 849: ballYVel = restrictValue(ballYVel * tileAccs[tiles[x][y]], MAXYV); ! 850: [self drawBackground:&rect]; ! 851: tiles[x][y] = NOTILE; ! 852: numTilesLeft--; ! 853: return YES; ! 854: } else { ! 855: return NO; ! 856: } ! 857: } ! 858: ! 859: ! 860: // The paddleHit method is called whenever the ball hits the paddle. ! 861: // This method bounces the ball back at an angle depending on what part of ! 862: // the paddle was hit. ! 863: ! 864: - paddleHit ! 865: { ! 866: float whereHit = ((ballX + RADIUS) - paddleX) / paddleSize.width; ! 867: ! 868: ballYVel = -ballYVel; ! 869: ballY = paddleSize.height; ! 870: ! 871: [self playSound:paddleSound atXLoc:paddleX]; ! 872: ! 873: // Alter the x-velocity and make sure it is in the valid range. ! 874: // If the ball hits the edges of the paddle, bounce it back at some angle. ! 875: ! 876: if (whereHit < 0.1) { ! 877: ballXVel = - MAXXV; ! 878: } else if (whereHit > 0.9) { ! 879: ballXVel = MAXXV; ! 880: } else { ! 881: // Now whereHit is in the range 0.1 .. 0.9, with 0.5 indicating middle ! 882: // of the paddle. Convert to a number in the range 0.2 to 1, with 0.2 ! 883: // indicating the middle and 1 either end. ! 884: whereHit = (fabs(whereHit - 0.5) + 0.1) * 2.0; ! 885: ballXVel = ((ballXVel > 0.0) ? 1.0 : -1.0) * MAXXV * whereHit; ! 886: } ! 887: ! 888: return self; ! 889: } ! 890: ! 891: // If upon launch we discover that there's no sound, then we fail ! 892: // silently. Note that although the SoundEffect class has the ability ! 893: // to enable/disable sounds, because we might have multiple ! 894: // BreakViews each with its own sound state, we keep a local state in ! 895: // addition to the one in SoundEffect. ! 896: ! 897: // Note that although this is an outlet method, we do not actually ! 898: // have an outlet (instance variable) named soundStateFrom; we just ! 899: // want to take a look at the initial value of the button and see ! 900: // if sound needs to be turned on... ! 901: ! 902: - setSoundStateFrom:sender ! 903: { ! 904: if ([sender state]) { ! 905: [SoundEffect setSoundEnabled:YES]; ! 906: if (!(soundEnabled = [SoundEffect soundEnabled])) { ! 907: [sender setState:NO]; // Silently fail ! 908: } ! 909: } else { ! 910: soundEnabled = NO; ! 911: } ! 912: return self; ! 913: } ! 914: ! 915: // If user tries to enable sound once the game is launched, and it ! 916: // fails, then we do tell him/her about it. ! 917: ! 918: - setSoundMode:sender ! 919: { ! 920: BOOL desiredState = [sender state]; ! 921: [self setSoundStateFrom:sender]; ! 922: if (desiredState && !soundEnabled) { ! 923: NXRunAlertPanel ( ! 924: NXLocalString ("No Sound", NULL, "Title of alert indicating sounds aren't available"), ! 925: NXLocalString ("Can't play sounds.", NULL, "Contents of alert panel"), ! 926: NXLocalString ("Bummer", NULL, "Acceptance that sounds can't be played"), ! 927: NULL, NULL); ! 928: } ! 929: return self; ! 930: } ! 931: ! 932: - (void)playSound:sound atXLoc:(float)xLoc ! 933: { ! 934: if (soundEnabled) { ! 935: [sound play:1.0 pan:restrictValue((xLoc / gameSize.width - 0.5) * 2.0, 1.0)]; ! 936: } ! 937: } ! 938: ! 939: // Alters the given velocity vector so that it is ! 940: // rotated by the indicated amount. We restrict both the resulting x and v ! 941: // velocity values to the maximum of their max possible values... ! 942: ! 943: - rotate:(float *)xVel :(float *)yVel by:(float)radians ! 944: { ! 945: float newAngle = atan2 (*yVel, *xVel) + radians; ! 946: float velocity = hypot (*xVel, *yVel); ! 947: ! 948: *yVel = restrictValue(velocity * sin(newAngle), MAX(MAXYV, MAXXV)); ! 949: *xVel = restrictValue(velocity * cos(newAngle), MAX(MAXYV, MAXXV)); ! 950: ! 951: return self; ! 952: } ! 953: ! 954: // The step method implements one step through the main game loop. ! 955: // The distance traveled by the ball is adjusted by the time between frames. ! 956: ! 957: - step:(double)timeNow ! 958: { ! 959: NXPoint mouseLoc; ! 960: float newX; ! 961: unsigned int timeDelta = MIN(MAX((timeNow - lastFrameTime) * 1000, MINTIMEDIFFERENCE), MAXTIMEDIFFERENCE); ! 962: lastFrameTime = timeNow; ! 963: ! 964: [self lockFocus]; ! 965: ! 966: [self eraseBall]; ! 967: ! 968: // If the ball is rotating, rotate it by the indicated amount. ! 969: ! 970: if (revolutionsLeft > 0.0) { ! 971: float revsThisTime = revolutionSpeed * timeDelta; ! 972: [self rotate:&ballXVel :&ballYVel by:revsThisTime]; ! 973: revolutionsLeft -= revsThisTime; ! 974: if (revolutionsLeft <= 0.0 && (fabs(ballYVel) < MAXYV * 0.6)) { ! 975: // Done rotating; make sure we have a good y-velocity ! 976: ballYVel = MAXYV * 0.8 * (ballYVel < 0.0 ? -1 : 1); ! 977: ballXVel = restrictValue(ballXVel,MAXXV); ! 978: } ! 979: } else if (ONEIN(1000 + (level < 8 ? (8 - level) * 250 : 0)) && (ballY > gameSize.height * 0.6)) { ! 980: // If we're not rotating, we go into rotating mode one out of ! 981: // 1500 or more steps, provided that the ball is not too close to ! 982: // the paddle at the time. ! 983: revolutionsLeft = M_PI * (2 + RANDINT(5)); // 1 to 3.5 full turns ! 984: revolutionSpeed = MAXREVOLUTIONSPEED * (RANDINT(8) + 2.0) / 10.0; ! 985: } ! 986: ! 987: // Update the ball location ! 988: ! 989: ballX += ballXVel * timeDelta * gameSize.width / GAMEWIDTH; ! 990: ballY += ballYVel * timeDelta * gameSize.height / GAMEHEIGHT; ! 991: ! 992: ! 993: if (gameRunning) { ! 994: ! 995: if (ballX < 0.0) { // Hit on the left wall ! 996: ballX = 0.0; ! 997: ballXVel = -ballXVel; ! 998: [self playSound:wallSound atXLoc:ballX]; ! 999: } else if (ballX > gameSize.width - ballSize.width) { // Right wall ! 1000: ballX = gameSize.width - ballSize.width; ! 1001: ballXVel = -ballXVel; ! 1002: [self playSound:wallSound atXLoc:ballX]; ! 1003: } ! 1004: ! 1005: if (ballY > gameSize.height - ballSize.height) { // Top wall ! 1006: ballY = gameSize.height - ballSize.height; ! 1007: ballYVel = -ballYVel; ! 1008: if (niceBall && !ONEIN(5) && !demoMode) { ! 1009: NXPoint mid = {paddleX + paddleSize.width / 2.0, paddleY}; ! 1010: [self directBallAt:&mid]; ! 1011: } else if (ONEIN(10)) { ! 1012: ballXVel = MAXXV-(RANDINT((int)(MAXXV*20))/10.0); ! 1013: } ! 1014: [self playSound:wallSound atXLoc:ballX]; ! 1015: } ! 1016: ! 1017: // Now checking for collisions with tiles... ! 1018: ! 1019: { ! 1020: int y1 = (int)(floor(ballY / ! 1021: (tileSize.height + INTERTILE))); ! 1022: int x1 = (int)(floor((ballX - leftMargin) / ! 1023: (tileSize.width + INTERTILE))); ! 1024: int y2 = (int)(floor((ballY + ballSize.height) / ! 1025: (tileSize.height + INTERTILE))); ! 1026: int x2 = (int)(floor((ballX + ballSize.width - leftMargin) / ! 1027: (tileSize.width + INTERTILE))); ! 1028: ! 1029: if ([self hitTileAt:x1 :y1] | [self hitTileAt:x2 :y1] | ! 1030: [self hitTileAt:x1 :y2] | [self hitTileAt:x2 :y2]) { ! 1031: [self playSound:tileSound atXLoc:ballX]; ! 1032: if (!killerBall) { ! 1033: ballYVel = -ballYVel; ! 1034: } ! 1035: [scoreView setIntValue:score]; ! 1036: [[self window] flushWindow]; ! 1037: } ! 1038: } ! 1039: } ! 1040: ! 1041: // Get the mouse location and convert from window to the view coords. ! 1042: // If in demo, mode, make the paddle track the ball. Endless fun. ! 1043: ! 1044: if (demoMode) { ! 1045: mouseLoc.x = ballX + ballSize.width / 2.0; ! 1046: } else { ! 1047: [[self window] getMouseLocation:&mouseLoc]; ! 1048: [self convertPoint:&mouseLoc fromView:nil]; ! 1049: } ! 1050: ! 1051: newX = MAX(MIN(mouseLoc.x - paddleSize.width/2, ! 1052: gameSize.width - paddleSize.width), 0); ! 1053: ! 1054: if (ballY >= paddleY + paddleSize.height) { ! 1055: ! 1056: // Ball is above the paddle; redraw it and the paddle and continue ! 1057: // We flush twice as the ball and the paddle are not too close ! 1058: // together ! 1059: ! 1060: [self showBall]; ! 1061: [[self window] flushWindow]; ! 1062: [self erasePaddle]; ! 1063: paddleX = newX; ! 1064: [self showPaddle]; ! 1065: [[self window] flushWindow]; ! 1066: ! 1067: } else if (ballY + ballSize.height > 0) { ! 1068: ! 1069: // Ball is past the paddle but not totally gone... ! 1070: ! 1071: [self erasePaddle]; ! 1072: paddleX = newX; ! 1073: ! 1074: // Check to see if the user managed to catch the ball after all ! 1075: ! 1076: if ((ballY > paddleY - ballSize.height / 2.0) && ! 1077: (ballX <= paddleX + paddleSize.width) && ! 1078: (ballX + ballSize.width > paddleX)) { ! 1079: [self paddleHit]; ! 1080: } ! 1081: ! 1082: // The ball and the paddle are close, so one flushWindow is fine. ! 1083: ! 1084: [self showBall]; ! 1085: [self showPaddle]; ! 1086: [[self window] flushWindow]; ! 1087: ! 1088: } else { ! 1089: ! 1090: // Too late; the ball is out of sight... ! 1091: ! 1092: [self erasePaddle]; ! 1093: [self stop:self]; ! 1094: [self playSound:missSound atXLoc:0.0]; ! 1095: ! 1096: if (--lives == 0) { ! 1097: if (score > highScore) [self setHighScore:score]; ! 1098: [statusView setStringValue:NXLocalString("Game Over", NULL, "Message indicating that the game is over...")]; ! 1099: } else { ! 1100: [self resetBallAndPaddle]; ! 1101: [self showBall]; ! 1102: [self showPaddle]; ! 1103: [statusView setStringValue:NXLocalString("Game Ready", NULL, "Message indicating the game is ready to run")]; ! 1104: } ! 1105: [[self window] flushWindow]; ! 1106: ! 1107: [livesView setIntValue:lives]; ! 1108: ! 1109: } ! 1110: ! 1111: // numTilesLeft <= 0 indicates that we've blown away every tile. But, ! 1112: // to make the game more exciting, we start decrementing numTilesLeft, ! 1113: // by one everytime through this loop, until it reaches the value ! 1114: // STOPGAMEAT. This makes the ball move a bit more after all the tiles ! 1115: // are gone. But, if gameRunning is NO, then it means we probably just ! 1116: // missed the ball, in which case we should go ahead and jump to the ! 1117: // next level. ! 1118: ! 1119: if ((numTilesLeft <= 0) && ! 1120: ((lives && !gameRunning) || (--numTilesLeft == STOPGAMEAT))) { ! 1121: [self incrementGameScore:LEVELBONUS]; ! 1122: [self gotoNextLevel:self]; ! 1123: } ! 1124: ! 1125: NXPing (); // Synchronize postscript for smoother animation ! 1126: ! 1127: [self unlockFocus]; ! 1128: ! 1129: return self; ! 1130: } ! 1131: ! 1132: // Pretty much a dummy function to invoke the step method. ! 1133: ! 1134: void runOneStep (DPSTimedEntry timedEntry, double timeNow, void *data) ! 1135: { ! 1136: [(id)data step:timeNow]; ! 1137: } ! 1138: ! 1139: ! 1140: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.