2473 lines
68 KiB
C
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;
|
|
}
|