/* cocosmash.c Copyright (C) 2026 Pierre Sarrazin This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include "cocosmash.h" #include "DirtyRectList.h" #include "util.h" #include "pmode4game.h" /* cardgame library */ //#define NO_MISSILES /* Keeps shooter from shooting missiles. */ //#define SPINNERS_DO_NOT_KILL /* A spinner that lands does not kill the shooter. */ //#define SHOOTER_NOT_KILLABLE typedef void (*NoiseFuncPtr)(void); static void silence(void) { } // Background noise function. // Must preserve U and Y. // NoiseFuncPtr noiseFuncPtr = silence; // Addresses of the two graphics pages. // The writable page is the one that is not currently displayed. // byte *buffers[2] = { grbuf0, grbuf1 }; byte writablePageIndex; // 0..1 index of currently writable page #ifdef STATS word numFlips; word numPrematureFlips; #endif word numFrames = 0; // frame counter // Must be set to setCoCo12ColorSet or setCoCo3ColorSet according // to emulatingPMode4OnCoCo3. // __gcccall void (*setColorSet)(byte colorSet); #if 0 /* Useful for debugging. */ asm void beckerPortConsoleOutHook(void) { asm { sta $FF42 } } byte debugState; void breakpoint(void) { printf("*** STOPPED AT BREAKPOINT ***\n"); while (! isKeyPressed(KEY_PROBE_1, KEY_BIT_1)) ; while (isKeyPressed(KEY_PROBE_1, KEY_BIT_1)) ; } void printDecimalArray(const byte array[], byte numDigits) { for ( ; numDigits--; ++array) putchar('0' + *array); } #endif DirtyRectList dirtyLists[2]; // [0] for page 0, [1] for page 1 // Erases the rectangles in the current dirty list and clears that list. // #define cleanWritablePage() (DirtyRectList_clean(writablePageIndex ? dirtyLists + 1 : dirtyLists)) // samPageNo: SAM address (0..127) of the graphics page to show. // The actual address will be samPageNo * 512. // Assumes that the correct PMODE has already been set up. // void showGraphicsPage(byte samPageNo) { static_assert(page0 == 7 && page1 == 19); // re: optimization in this function assert(samPageNo == page0 || samPageNo == page1); BOOL didSync = FALSE; while (numVSyncsBeforeScreenFlip > 0) // decremented by irqService() at v-sync { asm { sync } didSync = TRUE; } numVSyncsBeforeScreenFlip = VSYNCS_PER_FLIP; if (!didSync) { // We are here because numVSyncsBeforeScreenFlip was zero upon entry // to this function. This means that doMainGameLoop() worked for // too long, i.e., more than 'VSYNCS_PER_FLIP' TV frames. // We tolerate this, but we do a sync instruction here to wait for // the next v-sync, so that the buffer flip happens during the // vertical retrace. Otherwise, we would risk flipping while the // VDG is drawing a screen, which could show as tearing or flickering. // asm { sync } } if (emulatingPMode4OnCoCo3) { // Set the CoCo 3 Vertical offset register. // It receives the absolute address of the screen buffer, divided by 8. // Here, we assume that samPageNo designates an address >= $70000. // * (word *) 0xFF9D = 0xE000 | ((word) samPageNo << 6); } else { // samPageNo is assumed to be either 7 or 19. // 7 is 0000111. // 19 is 0010011. // ^ ^ // bits: 4 2 // Only bits 2 and 4 differ, so we only need to change the words at // $FFC6+2*2 and $FFC6+2*4, i.e., $FFCA and $FFCE. // So instead of calling // setSAMRegisters((byte *) 0xFFC6, samPageNo, 7); // we change only 2 bits of the SAM F register. // if (samPageNo == 7) asm { clr $FFCB // set bit 2 to 1 (use odd adress of the SAM word) clr $FFCE // set bit 4 to 0 (use even address of the SAM word) } else asm { clr $FFCA // set bit 2 to 0 (use even adress of the SAM word) clr $FFCF // set bit 4 to 1 (use odd address of the SAM word) } } #ifdef STATS ++numFlips; if (!didSync) ++numPrematureFlips; #endif } void clearScreen(byte *screen) { memset(screen, 0, BYTES_PER_SCREEN); } void showPmode4ColorSet1(void) { if (emulatingPMode4OnCoCo3) { * (byte *) 0xFF90 = 0x7E; // not CoCo compatible mode * (byte *) 0xFF98 = 0x80; // graphics mode * (byte *) 0xFF99 = 0x09; // 192 pixel rows, 32 bytes per row, 4 pixels per byte (i.e., 128x192, 4 colors) * (byte *) 0xFF9A = 0xFF; // white border setCoCo3ColorSet(1); } else { // PMODE 4: byte *pia1bData = (byte *) 0xff22; *pia1bData = *pia1bData & 7 | ((PMODE + 3) << 4); // SCREEN 1,1: setSAMRegisters((byte *) 0xFFC0, PMODE4_SAMV_VALUE, 3); *pia1bData |= 0x88; } } // Switches 'writablePageIndex' between 0 and 1. // Waits for the v-sync then shows the previously writable page. // void flipDisplayedBuffer(void) { writablePageIndex ^= 1; // If page 1 is now the writable page, then show page 0. // If page 0 is now the writable page, then show page 1. // showGraphicsPage(writablePageIndex ? page0 : page1); setScreenBuffer2((void *) (writablePageIndex ? grbuf0 : grbuf1)); // for cardgame lib } __gcccall asm byte * getWritableBuffer(void) { #if 0 /* Original C code. */ return buffers[writablePageIndex]; #else asm { tst :writablePageIndex ; 0..1 bne @writingInPage1 ldx :buffers rts @writingInPage1 ldx :buffers[1] ; 2 bytes after 'buffer' array start @gotBufferPtr } #endif } typedef struct Sprite { BOOL active; byte x; // horiz. pos. in pixels byte y; // vert. pos. in pixels (-64..191) byte h; // height in pixels (1..MAX_BITMAP_HEIGHT) sbyte dx; // horiz. speed in pixels per frame sbyte dy; // vert. speed in pixels per frame const PreShiftedBitmap *bm; // pointer to _bm bitmap def byte aux; // extra info, e.g., time to live } Sprite; word framesBeforeNextRock = 0; word framesBeforeNextSpinner = 0; word framesBeforeNextPulsar = 0; word framesBeforeNextSaucer = 0; word framesBeforeNextSaucerBullet = 0; word framesBeforeNextMissile = 0; byte numLives = INIT_NUM_LIVES; // BCD, max at MAX_NUM_LIVES Sprite shooter; Sprite missiles[MAX_MISSILES]; Sprite rocks[MAX_ROCKS]; Sprite spinners[MAX_SPINNERS]; Sprite pulsar; Sprite explosions[MAX_EXPLOSIONS]; Sprite saucer; enum { SAUCER_DESCENDING, SAUCER_SIDEWAYS, SAUCER_ASCENDING }; byte saucerPhase; // values of the enum above byte saucerYPos; // position of the sideways travel Sprite saucerBullet; byte numFramesBeforeNewShooter; BOOL spacePressedPreviously; BOOL muteKeyPressedPreviously; BOOL soundEnabled = TRUE; extern const PreShiftedBitmap shooter_bm; extern const PreShiftedBitmap shooter_cc3_bm; static const PreShiftedBitmap *shooter_bm_ptr; // will point to one of the 2 previous bitmaps extern const PreShiftedBitmap missile_bm; extern const PreShiftedBitmap rock0_bm; extern const PreShiftedBitmap rock1_bm; extern const PreShiftedBitmap rock2_bm; extern const PreShiftedBitmap rock3_bm; extern const PreShiftedBitmap pulsar_empty_bm; extern const PreShiftedBitmap pulsar_mid_bm; extern const PreShiftedBitmap pulsar_full_bm; const PreShiftedBitmap *pulsar_bitmaps[3] = { &pulsar_empty_bm, &pulsar_mid_bm, &pulsar_full_bm }; extern const PreShiftedBitmap saucer0_bm; extern const PreShiftedBitmap saucer1_bm; extern const PreShiftedBitmap saucer_bullet_bm; extern const PreShiftedBitmap explosion0_bm; extern const PreShiftedBitmap explosion1_bm; extern const PreShiftedBitmap spinner0_bm; extern const PreShiftedBitmap spinner1_bm; extern const PreShiftedBitmap spinner2_bm; extern const PreShiftedBitmap spinner3_bm; const PreShiftedBitmap *spinner_bitmaps[4] = { &spinner0_bm, &spinner1_bm, &spinner2_bm, &spinner3_bm, }; extern const ThinBitmap digit0_bm; extern const ThinBitmap digit1_bm; extern const ThinBitmap digit2_bm; extern const ThinBitmap digit3_bm; extern const ThinBitmap digit4_bm; extern const ThinBitmap digit5_bm; extern const ThinBitmap digit6_bm; extern const ThinBitmap digit7_bm; extern const ThinBitmap digit8_bm; extern const ThinBitmap digit9_bm; const ThinBitmap *digitBitmaps[10] = // each digit bitmap is 8x5 pixels, 12 bytes each { &digit0_bm, &digit1_bm, &digit2_bm, &digit3_bm, &digit4_bm, &digit5_bm, &digit6_bm, &digit7_bm, &digit8_bm, &digit9_bm, }; extern const ThinBitmap space_bm; extern const ThinBitmap minus_bm; byte decimalScore[SCORE_WIDTH]; // array of 0..9 byte decimalPeakScore[SCORE_WIDTH]; // array of 0..9 byte numFramesScoreRedrawRequested; byte currentLevelNo = 1; // 1..MAX_LEVEL_NO // Initializes the sprite at 's' at position (0, 0), // with speed (0, 0) and makes it use the specified bitmap. // Sets the active field to true. // void Sprite_init(Sprite *s, const PreShiftedBitmap *bitmap) { s->active = TRUE; s->x = 0; s->y = 0; s->dx = 0; s->dy = 0; s->bm = bitmap; s->h = bitmap->height; assert(s->h <= MAX_BITMAP_HEIGHT); s->aux = 0; } // Returns the address of a Sprite in the given array whose 'active' field is FALSE. // If none is found, returns NULL. // Sprite * findInactiveSprite(Sprite sprites[], byte numSprites) { for (byte i = 0; i < numSprites; ++i) { Sprite *s = &sprites[i]; assert(s); if (!s->active) return s; } return NULL; } void initFramesBeforeNextMissile(void) { framesBeforeNextMissile = 4; } void initFramesBeforeNextRock(void) { framesBeforeNextRock = 6 + ((byte) rand() & 0x07); } void initFramesBeforeNextSpinner(void) { word min, max; if (currentLevelNo == 1) min = 20, max = 100; else if (currentLevelNo == 2) min = 10, max = 50; else min = 10, max = 35; framesBeforeNextSpinner = rnd(min, max); } void initFramesBeforeNextPulsar(void) { word min = 110 - 10 * currentLevelNo; word max = 150 - 20 * currentLevelNo; framesBeforeNextPulsar = rnd(min, max); } void initFramesBeforeNextSaucer(void) { assert(currentLevelNo >= MIN_SAUCER_LEVEL); word lev = currentLevelNo - MIN_SAUCER_LEVEL; word min = 100 - lev * 40; word max = 600 - lev * 200; framesBeforeNextSaucer = rnd(min, max); } // Tells the double buffering system to redraw the current // score on both screen buffers. // #define requestScoreRedraw() (numFramesScoreRedrawRequested = 4) void initSprites(void) { (*setColorSet)(1); Sprite_init(&shooter, shooter_bm_ptr); shooter.x = COLS_PER_SCREEN / 2 - 8; // sprite is 16x16 shooter.y = ROWS_PER_SCREEN - 1 - GROUND_HEIGHT - 16; numFramesBeforeNewShooter = 0; for (byte i = 0; i < MAX_MISSILES; ++i) missiles[i].active = FALSE; // no missiles initially initFramesBeforeNextMissile(); for (byte i = 0; i < MAX_ROCKS; ++i) rocks[i].active = FALSE; initFramesBeforeNextRock(); for (byte i = 0; i < MAX_SPINNERS; ++i) spinners[i].active = FALSE; initFramesBeforeNextSpinner(); pulsar.active = FALSE; // no pulsar initially saucer.active = FALSE; saucerBullet.active = FALSE; initFramesBeforeNextPulsar(); // initFramesBeforeNextSaucer() only called at level where saucers start appearing for (byte i = 0; i < MAX_EXPLOSIONS; ++i) explosions[i].active = FALSE; } #define isScoreNegative() (decimalScore[0] >= 5) BOOL isScoreHigherThanPeak(void) { if (isScoreNegative()) return FALSE; for (byte i = 0; i < SCORE_WIDTH; ++i) { byte scoreDigit = decimalScore[i]; byte peakDigit = decimalPeakScore[i]; if (scoreDigit > peakDigit) return TRUE; if (scoreDigit < peakDigit) return FALSE; } return FALSE; } // scoreIndex: Must be a SCORE_* enum from scoring.h, which is // generated by generate-scoring.pl. (See also the makefile.) // void addToScore(byte scoreIndex) { assert(scoreIndex <= SCORE_MAX_INDEX); assert(currentLevelNo >= 1 && currentLevelNo <= MAX_LEVEL_NO); const byte *fourDigitArray = scoringTable[scoreIndex][currentLevelNo - 1]; addToDecimalDigit(fourDigitArray[3], SCORE_WIDTH - 1, decimalScore); // units addToDecimalDigit(fourDigitArray[2], SCORE_WIDTH - 2, decimalScore); // tens addToDecimalDigit(fourDigitArray[1], SCORE_WIDTH - 3, decimalScore); // hundreds addToDecimalDigit(fourDigitArray[0], SCORE_WIDTH - 4, decimalScore); // thousands requestScoreRedraw(); // Check if new score is new peak score. if (isScoreHigherThanPeak()) { byte tenThousands, thousands; if (currentLevelNo < MAX_LEVEL_NO) // if max level not reached { tenThousands = decimalPeakScore[SCORE_WIDTH - 5]; thousands = decimalPeakScore[SCORE_WIDTH - 4]; } static_assert(SCORE_WIDTH == 9); // assumption in following asm code: asm { // memcpy(decimalPeakScore, decimalScore, SCORE_WIDTH): IF_OS9(pshs y, ;) leax :decimalScore ; source leay :decimalPeakScore ; destination ldd ,x++ std ,y++ ldd ,x++ std ,y++ ldd ,x++ std ,y++ ldd ,x++ std ,y++ ldb ,x+ stb ,y+ IF_OS9(puls y, ;) } if (currentLevelNo < MAX_LEVEL_NO) { byte newTenThousands = decimalPeakScore[SCORE_WIDTH - 5]; byte newThousands = decimalPeakScore[SCORE_WIDTH - 4]; if (newTenThousands != tenThousands || newThousands != thousands) // if changed { if (newTenThousands == 0 && newThousands == 1) // if reached 1000 currentLevelNo = 2; else if (newTenThousands == 0 && newThousands == 5) // if reached 5000 currentLevelNo = 3; else if (newTenThousands == 2 && newThousands == 0) // if reached 20000 { currentLevelNo = 4; initFramesBeforeNextSaucer(); // schedule 1st saucer } else if (newTenThousands == 5 && newThousands == 0) // if reached 50000 currentLevelNo = 5; else if (newTenThousands == 0 && newThousands == 0) // if reached 100000 currentLevelNo = 6; } if (newThousands != thousands && numLives < MAX_NUM_LIVES) { // Add a life. asm { lda :numLives adda #1 ; inca would not affect C, which is needed by daa daa sta :numLives } } } } } // valueToSubtract: 0..9. // digitIndex: Index in decimalScore[]. // void subFromDecimalDigit(byte valueToSubtract, sbyte digitIndex) { byte *digitInArray = decimalScore + digitIndex; for (;;) { sbyte diff = (sbyte) *digitInArray - (sbyte) valueToSubtract; // 0..9 - 0..9 = 9..-9 if (diff >= 0) // if no borrow { *digitInArray = diff; return; } *digitInArray-- = diff + 10; if (digitIndex == 0) return; // out of digits in array --digitIndex; valueToSubtract = 1; // next iteration will borrow one from previous digit } } #ifndef NDEBUG void dumpScore(const byte digitArray[SCORE_WIDTH]) { printf("[DUMP:"); for (byte i = 0; i < SCORE_WIDTH; ++i) putchar(digitArray[i] + '0'); printf("]"); } #endif // bcdValue: Binary-coded decimal value between 0x000 and 0x999. // void subFromScore(word bcdValue) { subFromDecimalDigit((byte) bcdValue & 0x0F, SCORE_WIDTH - 1); subFromDecimalDigit((byte) bcdValue >> 4, SCORE_WIDTH - 2); subFromDecimalDigit((byte) (bcdValue >> 8), SCORE_WIDTH - 3); requestScoreRedraw(); } // Draws to the buffer given by getWritableBuffer(). // Calls noiseFuncPtr while drawing (if soundEnabled is non-zero): // That function can be used for background noise. // void drawSprite(const Sprite *s) { if (!s->active) return; byte spriteY = s->y; byte spriteHeight = s->h; byte numSkippedRows = 0; if (spriteY >= ROWS_PER_SCREEN) { // spriteY considered negative (-64..-1). if (- (sbyte) spriteY >= (sbyte) spriteHeight) return; // nothing to do: sprite completely above screen spriteHeight += spriteY; // decrease spriteHeight, to only draw rows that are on screen numSkippedRows = - spriteY; // skip the first rows of the bitmap spriteY = 0; // start writing at row 0 of screen } // y is in 0..191. // Compute the byte offset of the first affected screen byte. // Assumes PMODE 4. // byte *firstChangedAddr = getWritableBuffer() + ((word) spriteY << 5) + (word) (s->x >> 3); assert(((word) firstChangedAddr & 0x001F) <= 29); // check not too far at right byte shiftIndex = (byte) (s->x & 0b110u) >> 1; // 0..3 word preShiftOffset = s->bm->preShiftOffsets[shiftIndex]; const byte *preShiftedBytes = s->bm->bytes + preShiftOffset + numSkippedRows * BYTES_PER_BITMAP_ROW; byte *dest = firstChangedAddr; byte i = 0; // row index (0 .. spriteHeight - 1). #define drawSprite_asm #ifndef drawSprite_asm /* Original C code. (Very slow.) */ for (;;) { word screenWord = * (word *) dest; screenWord &= * (word *) preShiftedBytes; // AND with high word of mask screenWord |= * (word *) (preShiftedBytes + 3); // OR with high word of image * (word *) dest = screenWord; byte screenByte = dest[2]; screenByte &= preShiftedBytes[2]; screenByte |= preShiftedBytes[5]; dest[2] = screenByte; if (++i >= spriteHeight) break; dest += BYTES_PER_ROW, preShiftedBytes += BYTES_PER_BITMAP_ROW; } #else /* Inline asssembly language version. */ asm { IF_OS9(pshs y, ;) ldy :preShiftedBytes ldx :dest @loop ldd ,x ; screenWord anda ,y andb 1,y ora 3,y orb 4,y std ,x ; lda 2,x ; screenByte anda 2,y ora 5,y sta 2,x ; inc :i ldb :i cmpb :spriteHeight bhs @done ; leax BYTES_PER_ROW,x ; advance dest leay BYTES_PER_BITMAP_ROW,y ; advance preShiftedBytes ; tst :soundEnabled beq @skipNoise pshs x jsr [:noiseFuncPtr] ; trashes D, X; preserves U, Y puls x @skipNoise bra @loop @done IF_OS9(puls y, ;) } #endif if (!DirtyRectList_add(&dirtyLists[writablePageIndex], firstChangedAddr, spriteHeight)) assert(!"TOO MANY DIRTY RECTS"); // Request redraw of score if sprite displayed near it. if (s->x < (1 + SCORE_WIDTH) * DIGIT_WIDTH) // "1 +" takes minus sign into account { sword spriteBottomPos = signExtendYPos(spriteY) + (sword) spriteHeight; if (spriteBottomPos > SCORE_Y_POS) requestScoreRedraw(); } } // x: Digit position (one digit per byte). // Writes at row SCORE_Y_POS. // void drawThinBitmap(byte x, const ThinBitmap *bitmap) { #if 0 /* Original C code. */ byte *p = getWritableBuffer() + ((word) SCORE_Y_POS << 5) + x; const byte *src = bitmap->bytes; for (byte row = 0; row < bitmap->height; ++row) { *p = *src; ++src; p += BYTES_PER_ROW; } #else asm { IF_OS9(pshs y, ;) lbsr getWritableBuffer ; address received in X leax SCORE_Y_POS*BYTES_PER_ROW,x ; point to left of top pixel row of score ldb :x abx ; ldy :bitmap ; must not refer to C globals while Y is modified ldb ,y ; counter init w/ bitmap->height leay 1,y ; src = bitmap->bytes @loop lda ,y+ ; load from src sta ,x ; write at p leax BYTES_PER_ROW,x ; point to row below decb ; another row to do? bne @loop ; branch if yes IF_OS9(puls y, ;) } #endif } // Counts the number of leading zeroes in the string of decimal digits // at 'digitArray', and draws the equivalent number of spaces in the // score line. // scoreXPos: Points to a character position in the score row. // That position gets incremented for each space written. // // Returns the number of spaces written. // byte drawLeadingScoreSpaces(const byte digitArray[SCORE_WIDTH], byte *scoreXPos) { // Count number of leading zeroes. byte i; for (i = 0; i < SCORE_WIDTH; ++i) if (digitArray[i] != 0) break; byte numLeadingZeroes; if (i == SCORE_WIDTH) // if all zeroes numLeadingZeroes = SCORE_WIDTH - 1; else { numLeadingZeroes = i; if (numLeadingZeroes == 0) return 0; } for (byte i = numLeadingZeroes; i--; ++*scoreXPos) drawThinBitmap(*scoreXPos, &space_bm); return numLeadingZeroes; } void drawLives(void) { // Write number of lives at center of score row. assert(numLives <= MAX_NUM_LIVES); byte tens = numLives >> 4; drawThinBitmap(BYTES_PER_ROW - 17, tens == 0 ? &space_bm : digitBitmaps[tens]); drawThinBitmap(BYTES_PER_ROW - 16, digitBitmaps[numLives & 0x0F]); } void drawCurrentLevelNo(void) { drawThinBitmap(BYTES_PER_ROW - 1, digitBitmaps[currentLevelNo]); } // Redraws the score given by 'decimalScore' if numFramesScoreRedrawRequested // is positive; numFramesScoreRedrawRequested is then decremented. // void drawScore(void) { // Redraw score if needed. if (numFramesScoreRedrawRequested == 0) return; --numFramesScoreRedrawRequested; byte negatedDecimalScore[SCORE_WIDTH]; const byte *scoreToDraw; if (isScoreNegative()) { // Negate it into a separate array. for (byte i = 0; i < SCORE_WIDTH; ++i) negatedDecimalScore[i] = 9 - decimalScore[i]; addToDecimalDigit(1, SCORE_WIDTH - 1, negatedDecimalScore); scoreToDraw = negatedDecimalScore; } else scoreToDraw = decimalScore; // Draw minus sign if score negative, space if positive. drawThinBitmap(0, scoreToDraw == negatedDecimalScore ? &minus_bm : &space_bm); byte scoreXPos = 1; // character position in the score row, past the sign const byte numSpacesWritten = drawLeadingScoreSpaces(scoreToDraw, &scoreXPos); // scoreXPos has now been advanced past the spaces. const byte *curDigitAddr = &scoreToDraw[numSpacesWritten]; byte numDigits = SCORE_WIDTH - numSpacesWritten; do { drawThinBitmap(scoreXPos, digitBitmaps[*curDigitAddr++]); ++scoreXPos; } while (--numDigits != 0); } void drawGroundLine(void) { asm { tst :writablePageIndex ; 0..1 bne @writingInPage1 ldx :buffers bra @gotBufferPtr @writingInPage1 ldx :buffers[1] ; 2 bytes after buffer array start @gotBufferPtr leax GROUND_Y_POS*BYTES_PER_ROW,x ldd #$AAAA ; 16 pixels to write ; Write 32 bytes in 16 steps. std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ std ,x++ } } void drawInWritablePage(void) { drawGroundLine(); drawSprite(&shooter); for (byte i = 0; i < MAX_ROCKS; ++i) drawSprite(&rocks[i]); for (byte i = 0; i < MAX_SPINNERS; ++i) drawSprite(&spinners[i]); for (byte i = 0; i < MAX_MISSILES; ++i) drawSprite(&missiles[i]); drawSprite(&pulsar); drawSprite(&saucer); drawSprite(&saucerBullet); for (byte i = 0; i < MAX_EXPLOSIONS; ++i) drawSprite(&explosions[i]); // Writing to score row should be last. // That row can get dirtied by preceding drawSprite() calls. drawScore(); drawLives(); drawCurrentLevelNo(); } // Starts an explosion in the middle of 'destroyedSprite'. // Returns the explosion that got started, if there is room for an additional explosion. // Returns NULL if no explosion could be started. // Sprite * startExplosion(const Sprite *destroyedSprite) { Sprite *explosion = findInactiveSprite(explosions, MAX_EXPLOSIONS); if (!explosion) { assert(!"TOO MANY EXPL"); return NULL; } Sprite_init(explosion, &explosion0_bm); explosion->x = destroyedSprite->x; // Position explosion center at center of destroyedSprite. explosion->y = destroyedSprite->y + (destroyedSprite->h - explosion->h) / 2; explosion->aux = FRAMES_PER_EXPLOSION; // explosion will live for this many frames return explosion; } // Returns TRUE if the x field was changed, or FALSE if it remains unchanged // because the move would have taken the sprite out of bounds. // BOOL addXSpeedToSpritePos(Sprite *sprite) { sword newValue = (sword) sprite->x + (sword) sprite->dx; if (newValue < 0) return FALSE; if (newValue + SPRITE_WIDTH > COLS_PER_SCREEN - 2) // - 2 to avoid rightmost pos return FALSE; sprite->x = (byte) newValue; return TRUE; } // Returns FALSE if sprite has fallen to the ground (and has been deactivated). // Returns TRUE if sprite remains active. // BOOL letSpriteFall(Sprite *sprite) { sword newValue = sprite->dy + signExtendYPos(sprite->y); if (newValue + (sword) sprite->h <= ROWS_PER_SCREEN) { sprite->y = (byte) newValue; return TRUE; } sprite->active = FALSE; return FALSE; } void moveRock(Sprite *rockSprite) { if (!rockSprite->active) return; addXSpeedToSpritePos(rockSprite); if (!letSpriteFall(rockSprite)) { // Rock has landed. Decrease score. subFromScore(0x005); } } // Random values that approximate white noise. // Bits 0 and 1 are zero in each byte. // const byte randomSoundSamples[256] = { 0x94, 0x9c, 0x74, 0x70, 0x80, 0x7c, 0x68, 0x6c, 0x80, 0x88, 0x68, 0x58, 0xa0, 0x8c, 0x5c, 0xa0, 0x5c, 0x80, 0xa8, 0x6c, 0xa4, 0x7c, 0xa0, 0xa4, 0x8c, 0x60, 0xa4, 0x80, 0x88, 0x68, 0x6c, 0x98, 0x74, 0x94, 0x68, 0x94, 0x70, 0xa4, 0x64, 0x88, 0x6c, 0x94, 0x60, 0x94, 0x74, 0x84, 0x60, 0xa0, 0x84, 0x80, 0x80, 0x88, 0x74, 0x6c, 0x64, 0x74, 0x84, 0x88, 0x8c, 0x80, 0x8c, 0x8c, 0x7c, 0x88, 0x74, 0x78, 0x68, 0x68, 0x84, 0x6c, 0x88, 0x6c, 0x84, 0x80, 0x6c, 0x80, 0x94, 0x80, 0x64, 0x98, 0x9c, 0x70, 0x60, 0x70, 0x7c, 0x98, 0x8c, 0x5c, 0xa4, 0x70, 0x8c, 0xa0, 0x70, 0x98, 0x88, 0x8c, 0x74, 0x88, 0x9c, 0x88, 0x68, 0x78, 0x70, 0x98, 0x74, 0x6c, 0x84, 0x88, 0x88, 0x64, 0x74, 0x64, 0xa0, 0x84, 0x80, 0x84, 0x64, 0xa0, 0x5c, 0x84, 0xa8, 0x84, 0x98, 0xa4, 0x7c, 0x60, 0x58, 0xa4, 0xa4, 0x90, 0x88, 0x5c, 0x60, 0x64, 0x64, 0x60, 0x80, 0x60, 0x84, 0x80, 0x88, 0xa8, 0x90, 0x7c, 0x94, 0x60, 0x74, 0x9c, 0xa0, 0xa0, 0x9c, 0x84, 0x74, 0x80, 0x58, 0x84, 0x60, 0x90, 0x60, 0x7c, 0x5c, 0xa4, 0x88, 0x84, 0x74, 0xa0, 0x64, 0x78, 0xa0, 0x7c, 0x80, 0x7c, 0x6c, 0x70, 0x94, 0x88, 0x6c, 0x60, 0xa0, 0xa0, 0x84, 0x80, 0x90, 0xa0, 0x6c, 0x7c, 0x64, 0x88, 0x5c, 0x68, 0x7c, 0x88, 0x68, 0x64, 0x9c, 0x88, 0x80, 0x70, 0x78, 0x78, 0xa0, 0x98, 0x5c, 0xa0, 0x80, 0x90, 0x90, 0x80, 0x7c, 0xa4, 0x84, 0x68, 0x84, 0x90, 0x68, 0x68, 0xa0, 0x8c, 0x64, 0x88, 0x90, 0x80, 0x5c, 0x5c, 0x94, 0x80, 0x60, 0x5c, 0x64, 0x90, 0x70, 0xa0, 0x7c, 0x98, 0x6c, 0x64, 0x80, 0x70, 0x7c, 0x88, 0x88, 0x84, 0x70, 0x9c, 0x88, 0x68, 0xa4, 0x70, 0x74, 0x8c, 0x94, 0xa8, 0x6c, 0x64, 0x74, 0x8c, }; byte randomSoundSampleIndex = 0; // index into randomSoundSamples[] // Plays the byte designated by randomSoundSamples[randomSoundSampleIndex]. // Increments randomSoundSampleIndex for the next call. // Preserves U and Y. // Assumes that randomSoundSamples[] has 256 elements. // void asm playShooterExplosionSoundSample(void) { asm { leax :randomSoundSamples ldb :randomSoundSampleIndex abx lda ,x sta $FF20 ; write to PIA1 incb ; rolls over to 0, so stays in 0..255 stb :randomSoundSampleIndex } } const struct { sbyte dx, dy; } explosionDirections[5] = { { -4, 0 }, // dx fields must be even { -2, -2 }, { 0, -4 }, { 2, -2 }, { 4, 0 }, }; void killShooter(void) { // Start several explosion sprites. for (byte i = 0; i < 5; ++i) { Sprite *explosion = startExplosion(&shooter); explosion->aux = 40; explosion->dx = explosionDirections[i].dx; explosion->dy = explosionDirections[i].dy; } shooter.active = FALSE; numFramesBeforeNewShooter = 60; if (numLives > 0) { asm // Decrement the number of lives, which is in binary-coded decimal. { lda :numLives ; BCD adda #$99 ; (A + 99) % 100 = A - 1 over 8 bits daa sta :numLives } } pulsar.active = FALSE; // avoids pulsar dithering around shooter's position (*setColorSet)(0); // green-black during shooter explosion noiseFuncPtr = playShooterExplosionSoundSample; } void moveSpinner(Sprite *spinner) { if (!spinner->active) return; if (!shooter.active && (spinner->aux & 0x40)) // is this spinner killed shooter return; // do not animate it; it will get destroyed when new life created (or game over) if (((byte) numFrames & 3) == 0) { // See addSpinners() for the format of 'aux' for a spinner. byte bitmapIndex = spinner->aux & 0x7F; byte inc = ((spinner->aux & 0x80) ? 3 : 1); // CCW vs CW roration bitmapIndex = (bitmapIndex + inc) & 3; spinner->bm = spinner_bitmaps[bitmapIndex]; spinner->aux = spinner->aux & ~3 | bitmapIndex; // remember for next time } addXSpeedToSpritePos(spinner); if (!letSpriteFall(spinner)) { #if !defined(SPINNERS_DO_NOT_KILL) && !defined(SHOOTER_NOT_KILLABLE) // Spinner has landed. Shooter dies. if (shooter.active) { killShooter(); spinner->active = TRUE; // continue to show spinner that killed shooter spinner->aux = 0x40; // mark this spinner as killer (see top of this function) } #endif } } // Does nothing if 's' is not active. Otherwise, // moves missile sprite 's' up (its Sprite.dy must be negative). // Marks the sprite as inactive if its y position goes below -16. // void moveMissile(Sprite *s) { if (!s->active) return; sword yPos = signExtendYPos(s->y); sword newYPos = yPos + s->dy; if (newYPos <= -16) // if completely above the screen s->active = FALSE; else s->y = (sbyte) newYPos; } // Used by areSpriteRectanglesColliding(). // byte secondSpriteWidth = SPRITE_WIDTH; byte secondSpriteXMargin = 0; // (x1, y1, height1) is the bounding rectangle of the first sprite. // (x2, y2, height2) is the bounding rectangle of the second sprite. // The width of the 2nd sprite is assumed to be given by secondSpriteWidth. // x2 is advanced by secondSpriteXMargin before doing the test. // All arguments are signed. // BOOL areSpriteRectanglesColliding(sword x1, sword y1, sword height1, sword x2, sword y2, sword height2) { x2 += secondSpriteXMargin; if (x1 + SPRITE_WIDTH <= x2) // if sprite 1 at left of sprite 2 return FALSE; if (y1 + height1 <= y2) // if sprite 1 above sprite 2 return FALSE; if (x2 + secondSpriteWidth <= x1) // if sprite 1 at right of sprite 2 return FALSE; if (y2 + height2 <= y1) // if sprite 1 below sprite 2 return FALSE; return TRUE; } // Upon a collision, an explosion is started at the position of sprite 'a', // and both sprites are marked as inactive. // Does not check if 'a' or 'b' are currently active. // Returns TRUE iff a collision was detected. // Sprite 'b' is subject to secondSpriteWidth and secondSpriteXMargin; // see areSpriteRectanglesColliding(). // BOOL detectCollision2Sprites(Sprite *a, Sprite *b) { if (!areSpriteRectanglesColliding(a->x, signExtendYPos(a->y), a->h, b->x, signExtendYPos(b->y), b->h)) return FALSE; startExplosion(a); a->active = FALSE; b->active = FALSE; return TRUE; } // Adds (hundreds, tens, units) to the score for each detected collision. // bcdValue: Binary-coded decimal value between 0x000 and 0x999. // 'other' is passed to detectCollision2Sprites() as the 2nd argument. // BOOL detectCollisionWithSpriteList(Sprite sprites[], byte numSprites, Sprite *other, byte scoreIndex) { BOOL collisionDetected = FALSE; for (byte i = 0; i < numSprites; ++i) { Sprite *s = &sprites[i]; if (s->active) { if (detectCollision2Sprites(s, other)) { collisionDetected = TRUE; addToScore(scoreIndex); } } } return collisionDetected; } // Very short square wave. // static const byte missileCollisionSound[] = { 0xBE, 0x42, 0xBE, 0x42 }; // N.B.: Temporarily changes secondSpriteWidth and secondSpriteXMargin, // but restores them to their default values before returning. // See detectCollision2Sprites() and areSpriteRectanglesColliding(). // void detectMissileCollisions(Sprite *missile) { if (!missile->active) return; BOOL collisionDetected = FALSE; // Make areSpriteRectanglesColliding() more strict by making its second sprite // as thin as the missile.bm bitmap. // These global variables are restored to their default values before // this function returns. // Global variables are used to avoid having to pass them to multiple // function calls, for speed reasons. // secondSpriteXMargin = 6; secondSpriteWidth = SPRITE_WIDTH - 6 * 2; // reduce width by two margins // N.B.: A missile destroys every object that it collides with. // detectCollision2Sprites() marks the missile as inactive upon a collision. // detectCollision2Sprites() checks for a collision even if either sprite // is marked inactive. // // N.B.: 'missile' must be passed to detectCollision2Sprites() as the 2nd argument, // so that secondSpriteWidth and secondSpriteXMargin are applied to 'missile' // and not to the other sprite. // if (pulsar.active) { if (detectCollision2Sprites(&pulsar, missile)) { collisionDetected = TRUE; addToScore(SCORE_PULSAR); initFramesBeforeNextPulsar(); } } if (saucer.active) { if (detectCollision2Sprites(&saucer, missile)) { collisionDetected = TRUE; addToScore(SCORE_SAUCER); initFramesBeforeNextSaucer(); } } if (saucerBullet.active) { if (detectCollision2Sprites(&saucerBullet, missile)) { collisionDetected = TRUE; framesBeforeNextSaucerBullet = 0; } } if (detectCollisionWithSpriteList(spinners, MAX_SPINNERS, missile, SCORE_SPINNER)) collisionDetected = TRUE; if (detectCollisionWithSpriteList(rocks, MAX_ROCKS, missile, SCORE_ROCK)) collisionDetected = TRUE; if (soundEnabled && collisionDetected) playSoundSample(missileCollisionSound, ARRAY_END(missileCollisionSound), 200); secondSpriteXMargin = 0; secondSpriteWidth = SPRITE_WIDTH; } void detectCollisions(void) { for (byte i = 0; i < MAX_MISSILES; ++i) detectMissileCollisions(&missiles[i]); #ifndef SHOOTER_NOT_KILLABLE if (shooter.active) { BOOL shooterKilled = FALSE; if (pulsar.active && detectCollision2Sprites(&shooter, &pulsar)) { shooterKilled = TRUE; startExplosion(&pulsar); } if (saucerBullet.active && detectCollision2Sprites(&shooter, &saucerBullet)) { shooterKilled = TRUE; startExplosion(&saucerBullet); } for (byte i = 0; i < MAX_SPINNERS; ++i) { Sprite *spinner = &spinners[i]; if (spinner->active && detectCollision2Sprites(&shooter, spinner)) { shooterKilled = TRUE; startExplosion(spinner); } } for (byte i = 0; i < MAX_ROCKS; ++i) { Sprite *rock = &rocks[i]; if (rock->active && detectCollision2Sprites(&shooter, rock)) { shooterKilled = TRUE; startExplosion(rock); } } if (shooterKilled) { killShooter(); subFromScore(0x100); } } #endif /* SHOOTER_NOT_KILLABLE */ } void shootMissile(void) { if (!shooter.active) return; if (framesBeforeNextMissile != 0) // if not time to add missile { --framesBeforeNextMissile; return; } Sprite *missile = findInactiveSprite(missiles, MAX_MISSILES); if (!missile) return; Sprite_init(missile, &missile_bm); // Position missile on shooter. missile->x = shooter.x; // left of missile pixmap aligned with shooter pixmap missile->y = shooter.y - 16; // start missile near top of shooter missile->dy = - PLAYER_MISSILE_Y_SPEED; // missile moves up // Schedule next missile. initFramesBeforeNextMissile(); } void manageMissiles(void) { for (byte i = 0; i < MAX_MISSILES; ++i) moveMissile(&missiles[i]); #ifndef NO_MISSILES shootMissile(); #endif } // Returns TRUE if *sprite was initialized, FALSE if not (not time yet, // or the sprite is already active). // BOOL addEnemy(Sprite *sprite, word *framesBeforeNextInstance, const PreShiftedBitmap *bm, sbyte verticalSpeed) { if (*framesBeforeNextInstance != 0) // if not time to add this type of enemy { --*framesBeforeNextInstance; // wait another iteration return FALSE; } if (sprite->active) return FALSE; // enemy already present Sprite_init(sprite, bm); sprite->y = - bm->height; sprite->dy = verticalSpeed; return TRUE; } // Sets pulsar.dx according to shooter.x and pulsar.x. // void setPulsarSpeedTowardsShooter(void) { sword d = (sword) pulsar.x - (sword) shooter.x; sbyte dx; if (d >= -2) // if pulsar at left of shooter, or above it { if (d <= 2) // if above dx = 0; // pulsar already near target horiz. pos., so it goes down else dx = - PULSAR_X_SPEED; // send pulsar left } else // pulsar at right of shooter dx = + PULSAR_X_SPEED; pulsar.dx = dx; } void addPulsar(void) { if (!addEnemy(&pulsar, &framesBeforeNextPulsar, &pulsar_mid_bm, PULSAR_Y_SPEED)) return; pulsar.x = (byte) (rand() % (COLS_PER_SCREEN - PULSAR_WIDTH)); setPulsarSpeedTowardsShooter(); } // 4 states: elements are indexes in pulsar_bitmaps[]. // const byte pulsarAnimTable[] = { 0, 1, 2, 1 }; // A pulsar descends on the shooter, then moves horizontally // near the ground for some time. // The 'aux' field of the sprite is used to keep track of how many // frames are left in the duration of the horizontal movement. // void movePulsar(void) { if (!pulsar.active) return; if (((byte) numFrames & 1) == 0) { byte bitmapIndex = pulsarAnimTable[((byte) numFrames >> 1) & 3]; pulsar.bm = pulsar_bitmaps[bitmapIndex]; } if (pulsar.aux > 0) // if moving horiz. near ground { if (--pulsar.aux == 0) // end of life { pulsar.active = FALSE; initFramesBeforeNextPulsar(); return; } pulsar.dx = (shooter.x < pulsar.x ? - PULSAR_X_SPEED : PULSAR_X_SPEED); addXSpeedToSpritePos(&pulsar); return; } if (((byte) numFrames & 7) == 0) // once every 8 frames setPulsarSpeedTowardsShooter(); addXSpeedToSpritePos(&pulsar); sword newY = pulsar.dy + signExtendYPos(pulsar.y); if (newY + (sword) pulsar.h <= GROUND_Y_POS) { pulsar.y = (byte) newY; return; } pulsar.aux = (byte) (rand() & 0x3F) + 20; // frames of horiz. movement } // A saucer appears above the screen, at the leftmost or rightmost position. // It goes down to a certain vertical position, then it travels sideways at // that position. Once it has reached the other side of the screen, it goes up // and gets deactivated when it has disappeared above the screen. // This differs from Cosmosmash and it is due to the limitations of drawSprite(), // which does not support drawing only a part of a PreShiftedBitmap. // void addSaucer(void) { if (!addEnemy(&saucer, &framesBeforeNextSaucer, &saucer0_bm, SAUCER_Y_SPEED)) return; saucerPhase = SAUCER_DESCENDING; int r = rand(); BOOL goingRight = ((byte) r & 1); saucer.x = (goingRight ? 2 : COLS_PER_SCREEN - SPRITE_WIDTH - 2); saucer.y = - SAUCER_HEIGHT; saucerYPos = (((byte) (r >> 1)) & 0x07) * SAUCER_Y_SPEED; // must be a multiple of SAUCER_Y_SPEED saucer.dx = 0; } sbyte computeHorizontalSpeed(byte startX, byte destX, byte pixelHeightToTravel, sbyte dy) { assert(dy > 0); byte deltaX = (startX < destX ? destX - startX : startX - destX); // Compute the number of steps to move the object completely // below the screen. byte numSteps = ceilDiv(pixelHeightToTravel, (byte) dy); sbyte dx = (sbyte) (deltaX / numSteps); // absolute value of horiz. speed return (startX < destX ? dx : -dx); } // Shoot bullet periodically, if the saucer is active. // void addSaucerBullet(void) { if (saucerBullet.active || !saucer.active || !shooter.active) return; if (framesBeforeNextSaucerBullet != 0) // if not time yet { --framesBeforeNextSaucerBullet; return; } Sprite_init(&saucerBullet, &saucer_bullet_bm); // Start the bullet behind the saucer, so that their baselines // are the same initially. saucerBullet.x = saucer.x; saucerBullet.y = saucer.y + (SAUCER_HEIGHT - SAUCER_BULLET_HEIGHT); saucerBullet.dy = 6; saucerBullet.dx = computeHorizontalSpeed(saucerBullet.x, shooter.x, shooter.y - saucerBullet.y, saucerBullet.dy); // The first bullet is shot after a random delay. framesBeforeNextSaucerBullet = (word) rand() & 0x0F; } void moveSaucer(void) { if (!saucer.active) return; if (((byte) numFrames & 3) == 0) { saucer.aux ^= 1; saucer.bm = (saucer.aux ? &saucer1_bm : &saucer0_bm); } if (saucerPhase == SAUCER_DESCENDING) { if (saucer.y != saucerYPos) { saucer.y += saucer.dy; return; } saucerPhase = SAUCER_SIDEWAYS; saucer.dx = (saucer.x < COLS_PER_SCREEN / 2 ? SAUCER_X_SPEED : - SAUCER_X_SPEED); saucer.dy = 0; } if (saucerPhase == SAUCER_SIDEWAYS) { addSaucerBullet(); if (addXSpeedToSpritePos(&saucer)) return; saucerPhase = SAUCER_ASCENDING; saucer.dx = 0; saucer.dy = - SAUCER_Y_SPEED; } // saucerPhase == SAUCER_ASCENDING. if (saucer.y + SAUCER_HEIGHT == 0) // if off screen { saucer.active = FALSE; initFramesBeforeNextSaucer(); } saucer.y += saucer.dy; } void moveSaucerBullet(void) { if (!saucerBullet.active) return; addXSpeedToSpritePos(&saucerBullet); if (!letSpriteFall(&saucerBullet)) framesBeforeNextSaucerBullet = 0; } void animateExplosions(void) { byte bitmapIndex = (byte) numFrames & 1; for (byte i = 0; i < MAX_EXPLOSIONS; ++i) { Sprite *e = &explosions[i]; if (!e->active) continue; if (--e->aux == 0) // if time to live goes to 0 { e->active = FALSE; continue; } e->bm = (bitmapIndex ? &explosion1_bm : &explosion0_bm); if (e->dx != 0 && !addXSpeedToSpritePos(e)) // if going off screen { e->active = FALSE; continue; } if (e->dy < 0) // if explosion moving up e->y = (byte) (e->dy + signExtendYPos(e->y)); } } void setSpriteHorizontalSpeed(Sprite *object, byte dxCase) { assert(object->dy > 0); assert(ROWS_PER_SCREEN + (word) object->h <= 255); // fits a byte // Object starts at object->x. // Choose destination x randomly, between 2 and 238 inclusively, and make it even. byte destX = (2 + (byte) (rand() % (COLS_PER_SCREEN - 2 - SPRITE_WIDTH))) & 0xFE; object->dx = computeHorizontalSpeed(object->x, destX, ROWS_PER_SCREEN + object->h, object->dy); } void addRocks(void) { if (framesBeforeNextRock != 0) // if not time to add rock { --framesBeforeNextRock; return; } Sprite *rock = findInactiveSprite(rocks, MAX_ROCKS); if (!rock) // if max rocks reached return; int r = rand(); // Choose a rock type at random. // Use bits 5-6 of 'r' for this. const PreShiftedBitmap *rockBM = NULL; switch ((byte) r & 0b01100000) // 0, 32, 64, 96 { case 0: rockBM = &rock0_bm; break; case 32: rockBM = &rock1_bm; break; case 64: rockBM = &rock2_bm; break; case 96: rockBM = &rock3_bm; break; } Sprite_init(rock, rockBM); // Set random position. rock->x = (2 + (byte) (rand() % (COLS_PER_SCREEN - 2 - SPRITE_WIDTH))) & 0xFE; // even rock->y = - ROCK_HEIGHT; rock->dy = 3 + ((byte) r & 1); byte dxCase = ((byte) r) & 0b11110; // use bits 1-4: value is 0,2,4,...,30 setSpriteHorizontalSpeed(rock, dxCase); // Schedule next rock. initFramesBeforeNextRock(); } void moveRocks(void) { for (byte i = 0; i < MAX_ROCKS; ++i) moveRock(&rocks[i]); } void addSpinners(void) { if (framesBeforeNextSpinner != 0) // if not time to add spinner { --framesBeforeNextSpinner; return; } Sprite *spinner = findInactiveSprite(spinners, MAX_SPINNERS); if (!spinner) // if max spinners reached return; int r = rand(); byte initBitmapIndex = ((byte) r >> 5) & 3; // use bits 5-6 of 'r' Sprite_init(spinner, spinner_bitmaps[initBitmapIndex]); // The 'aux' field of a spinner sprite has this format: // - bits 0-1: index in spinner_bitmaps[] (0..3); // - bit 6: 1 if this is the spinner whose landing killed the shooter; // - bit 7: 0 for counter-clockwise rotation, 1 for clockwise. // spinner->aux = initBitmapIndex | ((byte) r & 0x80); // use bit 7 of 'r' // Set random position. spinner->x = (2 + (byte) (rand() % (COLS_PER_SCREEN - 2 - SPRITE_WIDTH))) & 0xFE; // even spinner->y = - SPRITE_WIDTH; spinner->dy = 3 + ((byte) r & 1); byte dxCase = ((byte) r) & 0b11110; // use bits 1-4: value is 0,2,4,...,30 setSpriteHorizontalSpeed(spinner, dxCase); // Schedule next spinner. initFramesBeforeNextSpinner(); } void moveSpinners(void) { for (byte i = 0; i < MAX_SPINNERS; ++i) moveSpinner(&spinners[i]); } BOOL checkForKey(byte probe, byte testBit) { if (!isKeyPressed(probe, testBit)) return FALSE; while (isKeyPressed(probe, testBit)) ; return TRUE; } #define checkForSpaceKey() (checkForKey(KEY_PROBE_SPACE, KEY_BIT_SPACE)) #define checkForBreakKey() (checkForKey(KEY_PROBE_BREAK, KEY_BIT_BREAK)) static const byte hyperspaceSound[] = { 0xF0, 0xB8, 0x80, 0x48, 0x10, 0x48, 0x80, 0xB8, 0xE0, 0xB0, 0x80, 0x50, 0x20, 0x50, 0x80, 0xB0, 0xD0, 0xA8, 0x80, 0x58, 0x30, 0x58, 0x80, 0xA8, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x60, 0x80, 0xA0, 0xB0, 0x98, 0x80, 0x68, 0x50, 0x68, 0x80, 0x98, 0xA0, 0x90, 0x80, 0x70, 0x60, 0x70, 0x80, 0x90, 0x90, 0x88, 0x80, 0x78, 0x70, 0x78, 0x80, 0x88, }; void hyperspace(void) { // Hyperspace. Move shooter to a random horizontal position. // Avoid the 2 leftmost and 2 rightmost columns. sword minDisplacement = COLS_PER_SCREEN / 4; // The shooter must move by at least minDisplacement, in pixels. // There is an interval of admissible positions at the left of the shooter, // and another one at the right, e.g.: // |---------| [SHOOTER] |-----| // x0 x1 x2 x3 // One of these intervals may be empty, e.g., is the shooter is too far // at the left of the screen. word r = (word) rand(); sword x0 = 2; sword x1 = shooter.x - minDisplacement; // may be <= x0 sword x2 = shooter.x + minDisplacement; // may be >= x3 sword x3 = COLS_PER_SCREEN - 2 - SPRITE_WIDTH; BOOL goLeft; if (x1 <= x0) // if left interval empty, go right goLeft = FALSE; else if (x2 >= x3) // if right interval empty, go left goLeft = TRUE; else // both intervals { goLeft = (byte) r & 1; r >>= 1; } if (!goLeft) { x1 = x3; x0 = x2; } shooter.x = (byte) x0 + (byte) (r % (x1 - x0 + 1)) & ~1; if (soundEnabled) playSoundSample(hyperspaceSound, ARRAY_END(hyperspaceSound), 10); } // Returnsw TRUE to continue, FALSE to stop. // void moveShooter(void) { BOOL spacePressedNow = isKeyPressed(KEY_PROBE_SPACE, KEY_BIT_SPACE); if (isKeyPressed(KEY_PROBE_LEFT, KEY_BIT_LEFT)) { // The "+ 2" keeps the shooter from going at the extreme left // of the screen, which is a restriction that mirrors the one // on movement to the right (see next if()). // if (shooter.x >= SHOOTER_X_SPEED + 2) shooter.x -= SHOOTER_X_SPEED; } else if (isKeyPressed(KEY_PROBE_RIGHT, KEY_BIT_RIGHT)) { // The "- 2" keeps the shooter from going at the extreme right // of the screen, which is a restriction that helps optimize // the pixmap writing routine. // if (shooter.x <= COLS_PER_SCREEN - SHOOTER_WIDTH - 2 - SHOOTER_X_SPEED) shooter.x += SHOOTER_X_SPEED; } else if (!spacePressedPreviously && spacePressedNow) { hyperspace(); } spacePressedPreviously = spacePressedNow; } void checkForMute(void) { BOOL muteKeyPressedNow = isKeyPressed(KEY_PROBE_M, KEY_BIT_M); if (!muteKeyPressedPreviously && muteKeyPressedNow) soundEnabled = !soundEnabled; muteKeyPressedPreviously = muteKeyPressedNow; } BOOL isAnySpinnerActive(void) { for (byte i = 0; i < MAX_SPINNERS; ++i) if (spinners[i].active) return TRUE; return FALSE; } static const byte saucerBulletSound[] = { 0xFC, 0x04, 0xFC, 0x04 }; static const byte pulsarSound[] = { 0xFC, 0x04, 0xFC, 0x04 }; static const byte spinnerSound[] = { 0xFC, 0x04, 0xFC, 0x04 }; void playEnemySounds(void) { if (!soundEnabled) return; if (numFramesBeforeNewShooter > 0) // if shooter is exploding return; if ((numFrames & 7) != 0) // only write a sound sample at this rate return; // Play a different click for different types of enemies, with priorities. // if (saucerBullet.active) playSoundSample(saucerBulletSound, ARRAY_END(saucerBulletSound), 20); else if (pulsar.active) playSoundSample(pulsarSound, ARRAY_END(pulsarSound), 40); else if (isAnySpinnerActive()) playSoundSample(spinnerSound, ARRAY_END(spinnerSound), 60); } #ifndef NDEBUG enum { DEBUG_BUFFER_SIZE = 1024 }; char debugBuffer[DEBUG_BUFFER_SIZE]; size_t debugBufferIndex = 0; void printDebugChar(void) { asm { pshs u,y,x,b,a ldd :debugBufferIndex cmpd #DEBUG_BUFFER_SIZE-1 ; reserve last byte of buffer for terminating NUL bhs @done leax :debugBuffer leax d,x addd #1 std :debugBufferIndex ; for next call lda ,s ; char to write sta ,x @done puls a,b,x,y,u } } #endif void onFailedAssert(const char *file, int lineno, const char *condition) { moveCursor(0, 0); // cardgame library function printf("*** FAILED ASSERT: %s:%d: %s\n", file, lineno, condition); for (;;) ; } void waitForKeyRelease(byte probe, byte testBit) { while (isKeyPressed(probe, testBit)) ; } byte waitForGameStartKey(void) { for (;;) { if (isKeyPressed(KEY_PROBE_SPACE, KEY_BIT_SPACE)) { waitForKeyRelease(KEY_PROBE_SPACE, KEY_BIT_SPACE); return ' '; } if (isKeyPressed(KEY_PROBE_S, KEY_BIT_S)) // start with fixed random seed { waitForKeyRelease(KEY_PROBE_S, KEY_BIT_S); return 'S'; } if (isKeyPressed(KEY_PROBE_I, KEY_BIT_I)) // show instructions { waitForKeyRelease(KEY_PROBE_I, KEY_BIT_I); return 'I'; } if (isKeyPressed(KEY_PROBE_CLEAR, KEY_BIT_CLEAR) // cold boot && isKeyPressed(KEY_PROBE_BREAK, KEY_BIT_BREAK)) { waitForKeyRelease(KEY_PROBE_CLEAR, KEY_BIT_CLEAR); waitForKeyRelease(KEY_PROBE_BREAK, KEY_BIT_BREAK); coldBoot(); } } } byte waitForGamePauseKey(BOOL allowResume) { for (;;) { if (allowResume && isKeyPressed(KEY_PROBE_R, KEY_BIT_R)) { waitForKeyRelease(KEY_PROBE_R, KEY_BIT_R); return 'R'; } if (isKeyPressed(KEY_PROBE_N, KEY_BIT_N)) // new game { waitForKeyRelease(KEY_PROBE_N, KEY_BIT_N); return 'N'; } if (isKeyPressed(KEY_PROBE_I, KEY_BIT_I)) // show instructions { waitForKeyRelease(KEY_PROBE_I, KEY_BIT_I); return 'I'; } if (isKeyPressed(KEY_PROBE_CLEAR, KEY_BIT_CLEAR) // cold boot && isKeyPressed(KEY_PROBE_BREAK, KEY_BIT_BREAK)) { waitForKeyRelease(KEY_PROBE_CLEAR, KEY_BIT_CLEAR); waitForKeyRelease(KEY_PROBE_BREAK, KEY_BIT_BREAK); coldBoot(); } } } // Prints to the graphics page designated by writablePageIndex, at the current // text row (textPosY). // Clears the dirty rectangle list. // x: Even pixel position on the text row given by textPosY. Must be in 0..238. // newline: If non-zero, advances textPosY after drawing the bitmap. // void printBitmap(byte x, BOOL newline, const PreShiftedBitmap *bm) { assert(textPosY * PIXEL_ROWS_PER_TEXT_ROW + bm->height <= ROWS_PER_SCREEN); Sprite sprite; Sprite_init(&sprite, bm); sprite.x = x; sprite.y = textPosY * PIXEL_ROWS_PER_TEXT_ROW; drawSprite(&sprite); if (newline) textPosY += (bm->height + PIXEL_ROWS_PER_TEXT_ROW - 1) / PIXEL_ROWS_PER_TEXT_ROW; DirtyRectList_init(&dirtyLists[writablePageIndex]); } void showInstructionsScreen(void) { clearScreen(scrnBuffer); printCentered(1, "INSTRUCTIONS"); moveCursor(0, 3); printWrapped( "YOU CONTROL AN AUTOMATIC LASER GUN AT THE BOTTOM:\n" "\n"); printBitmap((COLS_PER_SCREEN - SPRITE_WIDTH) / 2, TRUE, shooter_bm_ptr); printWrapped( "\n" "MOVE IT WITH THE KEYBOARD'S ^LEFT^ AND ^RIGHT ARROWS^.\n" "\n" "SHOOT THE ROCKS:\n" "\n"); byte x4 = (COLS_PER_SCREEN - 4 * SPRITE_WIDTH) / 5; printBitmap(x4, FALSE, &rock0_bm); printBitmap(x4 * 2 + SPRITE_WIDTH, FALSE, &rock1_bm); printBitmap(x4 * 3 + 2 * SPRITE_WIDTH, FALSE, &rock2_bm); printBitmap(x4 * 4 + 3 * SPRITE_WIDTH, TRUE, &rock3_bm); printWrapped( "\n" "IF THEY LAND, IT REDUCES YOUR SCORE.\n"); printWrapped( "\n" "PRESS ^SPACE^ NOW TO CONTINUE...\n"); while (!checkForSpaceKey()) ; clearScreen(scrnBuffer); moveCursor(0, 1); printWrapped( "SHOOT EVERY SPINNER:\n" "\n"); printBitmap(x4, FALSE, &spinner2_bm); printBitmap(x4 * 2 + SPRITE_WIDTH, FALSE, &spinner1_bm); printBitmap(x4 * 3 + 2 * SPRITE_WIDTH, FALSE, &spinner0_bm); printBitmap(x4 * 4 + 3 * SPRITE_WIDTH, TRUE, &spinner3_bm); printWrapped( "\n" "IF ONE LANDS, IT KILLS YOUR GUN.\n" "\n" "SHOOT THE GUIDED MISSILE BEFORE IT HITS YOU:\n" "\n"); byte x3 = (COLS_PER_SCREEN - 3 * SPRITE_WIDTH) / 4; printBitmap(x3, FALSE, &pulsar_empty_bm); printBitmap(x3 * 2 + SPRITE_WIDTH, FALSE, &pulsar_mid_bm); printBitmap(x3 * 3 + 2 * SPRITE_WIDTH, TRUE, &pulsar_full_bm); printWrapped( "\n" "TO HELP AVOID IT WHEN IT IS LOW, PRESS THE ^SPACE BAR^ TO MOVE TO A RANDOM POSITION.\n"); printWrapped( "\n" "PRESS ^SPACE^ NOW TO CONTINUE...\n"); while (!checkForSpaceKey()) ; clearScreen(scrnBuffer); moveCursor(0, 1); printWrapped( "THE SCORE APPEARS AT THE BOTTOM LEFT.\n" "\n" "THE NUMBER OF LIVES REMAINING IS AT THE BOTTOM CENTER. " "YOU START WITH"); char initNumLives[8]; sprintf(initNumLives, " %u", (INIT_NUM_LIVES >> 4) * 10 + (INIT_NUM_LIVES & 0x0F)); // decode BCD printWrapped(initNumLives); printWrapped( " LIVES.\n" "\n" "THE CURRENT LEVEL NUMBER IS AT THE BOTTOM RIGHT.\n" "\n" "\n" "PRESS ^M^ TO ^MUTE OR UNMUTE^ THE CLICKS AND NOISES THAT PURPORTEDLY PASS FOR SOUND EFFECTS.\n" "\n" "\n" "PRESS ^BREAK^ NOW TO GO BACK."); moveCursor(5, 22); printf("SCORE LIVES LEVEL"); numFramesScoreRedrawRequested = 1; drawGroundLine(); drawScore(); drawLives(); drawCurrentLevelNo(); while (!checkForBreakKey()) ; clearScreen(scrnBuffer); } // Made with Verdana Bold 18 font in GIMP 2.10. // static const uint32_t titleBitmap[14][8] = { { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xfc000000, }, { 0x00000fff, 0x00000000, 0x03ffc000, 0x000003ff, 0xc0000000, 0x00000000, 0x00000000, 0xfc000000, }, { 0x0000ffff, 0xc0000000, 0x3ffff000, 0x00003fff, 0xf0000000, 0x00000000, 0x00000000, 0xfc000000, }, { 0x0003fc03, 0xc0000000, 0xff00f000, 0x0000ff00, 0xf0000000, 0x00000000, 0x00000000, 0xfc000000, }, { 0x0003f000, 0xc00ffc00, 0xfc003003, 0xff00fc00, 0x300fcff0, 0xff003fff, 0x000fffc0, 0xfcffc000, }, { 0x000fc000, 0x00ffff03, 0xf000003f, 0xffc0ff00, 0x000fffff, 0xffc03fff, 0xc03fffc0, 0xfffff000, }, { 0x000fc000, 0x00fc3f03, 0xf000003f, 0x0fc0ffff, 0x000fc0fc, 0x0fc0300f, 0xf0fc00c0, 0xfc03f000, }, { 0x000fc000, 0x03f00fc3, 0xf00000fc, 0x03f03fff, 0xf00fc0fc, 0x0fc00003, 0xf0ff0000, 0xfc03f000, }, { 0x000fc000, 0x03f00fc3, 0xf00000fc, 0x03f003ff, 0xfc0fc0fc, 0x0fc003ff, 0xf0ffff00, 0xfc03f000, }, { 0x000fc000, 0x03f00fc3, 0xf00000fc, 0x03f00003, 0xfc0fc0fc, 0x0fc03fff, 0xf03fffc0, 0xfc03f000, }, { 0x0003f000, 0xc3f00fc0, 0xfc0030fc, 0x03f0c000, 0xfc0fc0fc, 0x0fc0fc03, 0xf0003fc0, 0xfc03f000, }, { 0x0003fc03, 0xc0fc3f00, 0xff00f03f, 0x0fc0fc03, 0xfc0fc0fc, 0x0fc0fc03, 0xf0c00fc0, 0xfc03f000, }, { 0x0000ffff, 0xc0ffff00, 0x3ffff03f, 0xffc0ffff, 0xf00fc0fc, 0x0fc0ffff, 0xf0ffff00, 0xfc03f000, }, { 0x00000fff, 0x003ffc00, 0x03ffc00f, 0xff003fff, 0x000fc0fc, 0x0fc03ff3, 0xf03ffc00, 0xfc03f000, }, }; byte showPresentationScreen(void) { for (;;) { moveCursor(1, 2); byte x = (COLS_PER_SCREEN - SPRITE_WIDTH) / 2 - 2; printBitmap(x, FALSE, shooter_bm_ptr); // Display the large, garish game title. // const byte numTitleRows = sizeof(titleBitmap) / sizeof(titleBitmap[0]); byte *screenPtr = getWritableBuffer() + ((word) 11 * PIXEL_ROWS_PER_TEXT_ROW * BYTES_PER_ROW) / 2; copyDoubleRowBitmap(screenPtr, titleBitmap, numTitleRows); byte titleVertMargin = 4; byte *xoredRegion = screenPtr - titleVertMargin * BYTES_PER_ROW; byte numXoredRows = numTitleRows * 2 + titleVertMargin * 2; xorRegion(xoredRegion, numXoredRows, 0x55); printCentered(11, "VERSION " VERSION); printCentered(13, "(C) " COPYRIGHT_YEARS " PIERRE SARRAZIN"); printCentered(15, "DISTRIBUTED UNDER"); printCentered(16, "THE GNU GPL V3 OR LATER"); moveCursor(4, 19); printWrapped("PRESS ^I^ FOR INSTRUCTIONS"); // ^ supported by printWrapped() moveCursor(6, 21); printWrapped("PRESS ^SPACE^ TO START"); byte key = waitForGameStartKey(); if (key == 'I') { showInstructionsScreen(); continue; } return key; } } byte showGamePauseScreen(void) { byte nextLine; if (numLives == 0) { moveCursor(3, 6); putstr("GAME OVER", 9); moveCursor(3, 8); putstr("PEAK SCORE: ", 12); BOOL seenNonZero = FALSE; // used to avoid printing leading zeroes for (byte i = 0; i < SCORE_WIDTH; ++i) { byte curDigit = decimalPeakScore[i]; if (curDigit != 0) seenNonZero = TRUE; if (seenNonZero || i == SCORE_WIDTH - 1) putchar('0' + curDigit); } moveCursor(3, 11); printWrapped("PRESS ^N^ FOR A NEW GAME, OR"); nextLine = 13; } else { moveCursor(3, 6); putstr("GAME PAUSED", 11); moveCursor(3, 11); printWrapped("PRESS ^R^ TO RESUME,"); moveCursor(9, 13); printWrapped("^N^ FOR A NEW GAME, OR"); nextLine = 15; } moveCursor(9, nextLine); printWrapped("^I^ FOR INSTRUCTIONS."); return waitForGamePauseKey(numLives != 0); } void initNewGame(byte startKey) { // Pressing S in presentation screen uses a fixed seed, which is // helpful for debugging. Otherwise, a variable seed is used. srand(startKey == 'S' ? 1u : timer); // Initialize the score. memset(decimalScore, '\0', SCORE_WIDTH); memset(decimalPeakScore, '\0', SCORE_WIDTH); requestScoreRedraw(); currentLevelNo = 1; spacePressedPreviously = FALSE; muteKeyPressedPreviously = FALSE; numLives = INIT_NUM_LIVES; // BCD initSprites(); numVSyncsBeforeScreenFlip = 1; numFrames = 0; // init frame counter } // Returns when the player has just lost the last life, or when // the quit key has been pressed. // void doMainGameLoop(void) { requestScoreRedraw(); BOOL pauseRequested = FALSE; for (;;) // main game loop { ++numFrames; cleanWritablePage(); drawInWritablePage(); flipDisplayedBuffer(); // waits for v-sync then changes visible graphics page checkForMute(); playEnemySounds(); detectCollisions(); manageMissiles(); moveRocks(); moveSpinners(); movePulsar(); moveSaucer(); moveSaucerBullet(); animateExplosions(); if (shooter.active) { addRocks(); addSpinners(); addPulsar(); if (currentLevelNo >= MIN_SAUCER_LEVEL) addSaucer(); moveShooter(); } else if (numFramesBeforeNewShooter > 0) // if shooter still exploding { --numFramesBeforeNewShooter; if (numFramesBeforeNewShooter == 0) // if explosion has just finished { noiseFuncPtr = silence; // stop playing explosion sound (*setColorSet)(1); if (numLives == 0) // if no lives left break; initSprites(); // start new life if (pauseRequested) break; // do pause that was requested during explosion } } if (checkForBreakKey()) // if player pauses { if (numFramesBeforeNewShooter == 0) // if player not exploding break; // pause now pauseRequested = TRUE; // pause will happen after explosion finished } } } // Interrupts are masked upon entry to main(), because // of decbfile_runDOSLoader(), the function called by loader.c // to load an execute this program. // The CoCo is assumed to have been put in all-RAM mode by that loader. // int main() { // Turn the disk motors off. * (byte *) 0xFF40 = 0; // Initializations that depend on the type of CoCo (1/2 vs 3). emulatingPMode4OnCoCo3 = (* (word *) 0xFFF8 == 0xFEF7); // using global from cardgame library if (emulatingPMode4OnCoCo3) { setColorSet = setCoCo3ColorSet; shooter_bm_ptr = &shooter_cc3_bm; } else { setColorSet = setCoCo12ColorSet; shooter_bm_ptr = &shooter_bm; } setupIRQService(); enableInterrupts(); _SetFailedAssertHandler(onFailedAssert); enableSound(); clearScreen(grbuf1); clearScreen(grbuf0); // Initialize both dirty lists. DirtyRectList_init(&dirtyLists[0]); DirtyRectList_init(&dirtyLists[1]); asm { sync } // wait for v-sync to change screen mode if (emulatingPMode4OnCoCo3) * (word *) 0xFF9D = 0xE000 | ((word) page1 << 6); // assumes buffer in $7xxxx range else setSAMRegisters((byte *) 0xFFC6, page1, 7); // show page 1 (empty screen) showPmode4ColorSet1(); // Cardgame library: setScreenBuffer2((void *) grbuf1); // must be consistent w/ preceding setSAMRegisters() call textScreenWidth = TEXT_COLS_PER_ROW; textScreenHeight = TEXT_ROWS_PER_SCREEN; setConsoleOutHook(hiResTextConsoleOutHook); setInvertedColorsParameters(TRUE, TRUE); makeSpacesTransparent(TRUE); setWrappedPrinting(1, BYTES_PER_SCREEN_ROW - 2); // required to use printWrapped() writablePageIndex = 1; // for printBitmap() calls in showPresentationScreen() byte startKey = showPresentationScreen(); writablePageIndex = 0; //setConsoleOutHook(beckerPortConsoleOutHook); // to debug after presentation screen clearScreen(grbuf1); for (;;) { if (startKey == ' ' || startKey == 'S') initNewGame(startKey); else if (startKey == 'N') initNewGame(' '); else assert(startKey == 'R'); // resume paused game doMainGameLoop(); for (;;) { startKey = showGamePauseScreen(); if (startKey != 'I') break; // Temporarily switch writablePageIndex so that the drawSprite() call // in printBitmap() will write the the displayed page. // writablePageIndex ^= 1; showInstructionsScreen(); writablePageIndex ^= 1; // switch back to original page } clearScreen(grbuf0); clearScreen(grbuf1); } return 0; }