Files

2473 lines
68 KiB
C

/* cocosmash.c
Copyright (C) 2026 Pierre Sarrazin <http://sarrazip.com/>
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 <http://www.gnu.org/licenses/>.
*/
#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;
}