Original author: Pierre Sarrazin. Preserve upstream GPLv3-or-later and file-specific notices. Source: http://sarrazip.com/dev/coco-planes-0.1.0.tar.gz Archive SHA-256: 29191e6ba225965caa637ee726e1189639dc7fcdf2b68310fb93fbffd56c9c52
2699 lines
78 KiB
C
2699 lines
78 KiB
C
/* coco-planes.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 "DirtyRectList.h"
|
|
#include "util.h"
|
|
#include "Sprite.h"
|
|
#include "BiplaneMover.h"
|
|
#include "PreShiftedBitmap.h"
|
|
#include "ThinBitmap.h"
|
|
#include "KeyState.h"
|
|
#include "Score.h"
|
|
#include "Controller.h"
|
|
|
|
#include "pmode4game.h" /* cardgame library */
|
|
#include "Joystick.h" /* bcontrol library */
|
|
|
|
#if SEED_FROM_USER
|
|
#include "Keyboard.h" /* bcontrol library */
|
|
#endif
|
|
|
|
#if COMPUTE_CHECKSUM
|
|
#include "crc16.h" /* decbfile library */
|
|
#endif
|
|
|
|
|
|
#ifdef OS9
|
|
#define IF_OS9(os9_value, non_os9_value) os9_value
|
|
#else
|
|
#define IF_OS9(os9_value, non_os9_value) non_os9_value
|
|
#endif
|
|
|
|
|
|
typedef void (*NoiseFuncPtr)(void);
|
|
|
|
|
|
static void silence(void)
|
|
{
|
|
}
|
|
|
|
|
|
// Background noise function.
|
|
// Must preserve U and Y.
|
|
//
|
|
NoiseFuncPtr noiseFuncPtr = silence;
|
|
|
|
|
|
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);
|
|
|
|
|
|
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 }
|
|
}
|
|
|
|
// Useful to get stats on IRQs per flip. See also irqService().
|
|
//beckputchar('F');
|
|
//beckputchar('\n');
|
|
|
|
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
|
|
}
|
|
|
|
|
|
// Sets the BYTES_PER_SCREEN bytes starting at 'screen' to zero.
|
|
//
|
|
__gcccall void asm
|
|
clearScreen(byte *screen)
|
|
{
|
|
asm
|
|
{
|
|
tfr x,d ; X is 'screen' b/c __gcccall
|
|
addd #BYTES_PER_SCREEN ; end of region to clear
|
|
pshs b,a ; push end address
|
|
clra
|
|
clrb
|
|
@loop:
|
|
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++
|
|
cmpx ,s ; reached end?
|
|
bne @loop
|
|
leas 2,s ; discard end address
|
|
}
|
|
}
|
|
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
// Uses writablePageIndex.
|
|
//
|
|
__gcccall asm byte *
|
|
getWritableBuffer(void)
|
|
{
|
|
#if 0 /* Original C code. */
|
|
return writablePageIndex ? grbuf1 : grbuf0;
|
|
#else
|
|
asm
|
|
{
|
|
tst :writablePageIndex ; 0..1
|
|
bne @writingInPage1
|
|
ldx #grbuf0
|
|
rts
|
|
@writingInPage1
|
|
ldx #grbuf1
|
|
@gotBufferPtr
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
// 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(getWritableBuffer()); // for cardgame lib
|
|
|
|
assert(getWritableBuffer() == scrnBuffer);
|
|
}
|
|
|
|
|
|
BOOL gameStarted;
|
|
|
|
Sprite biplane_red;
|
|
Sprite biplane_blue;
|
|
byte bulletTimeToLive; // number of frames that a bullet lives for
|
|
Sprite bullets_red[MAX_BULLETS_PER_PLANE];
|
|
Sprite bullets_blue[MAX_BULLETS_PER_PLANE];
|
|
Sprite explosions[MAX_EXPLOSIONS];
|
|
Sprite balloon;
|
|
Sprite leftClouds[MAX_CLOUDS];
|
|
Sprite rightClouds[MAX_CLOUDS];
|
|
byte numFramesBeforeCloudMove;
|
|
sbyte windDirection; // in pixels
|
|
|
|
word numFramesBeforeBalloonTakeOff;
|
|
word numBalloonExplosionFramesLeft;
|
|
|
|
BiplaneMover redBiplaneMover;
|
|
BiplaneMover blueBiplaneMover;
|
|
|
|
Score redScore;
|
|
Score blueScore;
|
|
|
|
// Array indexed by writablePageIndex.
|
|
// grPageHasStartPrompt[i] is true iff the start prompt is currently
|
|
// written on graphics page i (0..1).
|
|
//
|
|
BOOL grPageHasStartPrompt[2];
|
|
|
|
BOOL soundAllowed = TRUE; // FALSE means game sounds muted
|
|
|
|
extern const PreShiftedBitmap biplane_red_00_bm;
|
|
extern const PreShiftedBitmap biplane_red_01_bm;
|
|
extern const PreShiftedBitmap biplane_red_02_bm;
|
|
extern const PreShiftedBitmap biplane_red_03_bm;
|
|
extern const PreShiftedBitmap biplane_red_04_bm;
|
|
extern const PreShiftedBitmap biplane_red_05_bm;
|
|
extern const PreShiftedBitmap biplane_red_06_bm;
|
|
extern const PreShiftedBitmap biplane_red_07_bm;
|
|
extern const PreShiftedBitmap biplane_red_08_bm;
|
|
extern const PreShiftedBitmap biplane_red_09_bm;
|
|
extern const PreShiftedBitmap biplane_red_10_bm;
|
|
extern const PreShiftedBitmap biplane_red_11_bm;
|
|
extern const PreShiftedBitmap biplane_red_12_bm;
|
|
extern const PreShiftedBitmap biplane_red_13_bm;
|
|
extern const PreShiftedBitmap biplane_red_14_bm;
|
|
extern const PreShiftedBitmap biplane_red_15_bm;
|
|
|
|
extern const PreShiftedBitmap biplane_blue_00_bm;
|
|
extern const PreShiftedBitmap biplane_blue_01_bm;
|
|
extern const PreShiftedBitmap biplane_blue_02_bm;
|
|
extern const PreShiftedBitmap biplane_blue_03_bm;
|
|
extern const PreShiftedBitmap biplane_blue_04_bm;
|
|
extern const PreShiftedBitmap biplane_blue_05_bm;
|
|
extern const PreShiftedBitmap biplane_blue_06_bm;
|
|
extern const PreShiftedBitmap biplane_blue_07_bm;
|
|
extern const PreShiftedBitmap biplane_blue_08_bm;
|
|
extern const PreShiftedBitmap biplane_blue_09_bm;
|
|
extern const PreShiftedBitmap biplane_blue_10_bm;
|
|
extern const PreShiftedBitmap biplane_blue_11_bm;
|
|
extern const PreShiftedBitmap biplane_blue_12_bm;
|
|
extern const PreShiftedBitmap biplane_blue_13_bm;
|
|
extern const PreShiftedBitmap biplane_blue_14_bm;
|
|
extern const PreShiftedBitmap biplane_blue_15_bm;
|
|
|
|
const PreShiftedBitmap *biplane_red_bitmaps[NUM_BIPLANE_BITMAPS] =
|
|
{
|
|
&biplane_red_00_bm,
|
|
&biplane_red_01_bm,
|
|
&biplane_red_02_bm,
|
|
&biplane_red_03_bm,
|
|
&biplane_red_04_bm,
|
|
&biplane_red_05_bm,
|
|
&biplane_red_06_bm,
|
|
&biplane_red_07_bm,
|
|
&biplane_red_08_bm,
|
|
&biplane_red_09_bm,
|
|
&biplane_red_10_bm,
|
|
&biplane_red_11_bm,
|
|
&biplane_red_12_bm,
|
|
&biplane_red_13_bm,
|
|
&biplane_red_14_bm,
|
|
&biplane_red_15_bm,
|
|
};
|
|
|
|
const PreShiftedBitmap *biplane_blue_bitmaps[NUM_BIPLANE_BITMAPS] =
|
|
{
|
|
&biplane_blue_08_bm,
|
|
&biplane_blue_07_bm,
|
|
&biplane_blue_06_bm,
|
|
&biplane_blue_05_bm,
|
|
&biplane_blue_04_bm,
|
|
&biplane_blue_03_bm,
|
|
&biplane_blue_02_bm,
|
|
&biplane_blue_01_bm,
|
|
&biplane_blue_00_bm,
|
|
&biplane_blue_15_bm,
|
|
&biplane_blue_14_bm,
|
|
&biplane_blue_13_bm,
|
|
&biplane_blue_12_bm,
|
|
&biplane_blue_11_bm,
|
|
&biplane_blue_10_bm,
|
|
&biplane_blue_09_bm,
|
|
};
|
|
|
|
extern const PreShiftedBitmap bullet_bm;
|
|
extern const PreShiftedBitmap explosion0_bm;
|
|
extern const PreShiftedBitmap explosion1_bm;
|
|
extern const PreShiftedBitmap balloon_bm;
|
|
extern const PreShiftedBitmap cloud_left_bm;
|
|
extern const PreShiftedBitmap cloud_right_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;
|
|
|
|
|
|
KeyState muteKeyState = { KEY_PROBE_M, KEY_BIT_M, FALSE };
|
|
|
|
enum { JOY_RIGHT_Y_AXIS = 1, JOY_LEFT_Y_AXIS = 3 }; // 0..3
|
|
enum { JOY_AXIS_LOW_THR = 16, JOY_AXIS_HIGH_THR = 48 }; // 0..63
|
|
enum { JOY_UP = +1, JOY_DOWN = -1, JOY_MIDDLE = 0 };
|
|
enum { JOY_BUTTON_RIGHT_MASK = 1, JOY_BUTTON_LEFT_MASK = 2 }; // 1st button of each joystick
|
|
|
|
sbyte rightJoystickVerticalPos = JOY_MIDDLE;
|
|
sbyte leftJoystickVerticalPos = JOY_MIDDLE;
|
|
byte joystickButtonPreviousStates = 0xFF; // test with JOY_BUTTON_*_MASK
|
|
byte joystickButtonStates = 0xFF; // test with JOY_BUTTON_*_MASK
|
|
|
|
#if SEED_FROM_USER
|
|
Keyboard keyboard;
|
|
#endif
|
|
|
|
Controller redBiplaneController;
|
|
Controller blueBiplaneController;
|
|
|
|
|
|
// 16xTOWER_HEIGHT grid of pixels.
|
|
//
|
|
const word tower_pixels[TOWER_HEIGHT] =
|
|
{
|
|
0b1111111111111111,
|
|
0b0011000000001100,
|
|
0b0011000000001100,
|
|
0b0011000000001100,
|
|
0b0011111111111100,
|
|
0b0011111111111100,
|
|
0b0000110000110000,
|
|
0b0011111111111100,
|
|
0b0011000000001100,
|
|
0b0011000000001100,
|
|
0b0011000000001100,
|
|
0b0011000000001100,
|
|
0b0011111111111100,
|
|
0b0011000000001100,
|
|
0b0011000000001100,
|
|
0b0011000000001100,
|
|
0b0011000000001100,
|
|
};
|
|
|
|
|
|
void asm
|
|
drawTower(void)
|
|
{
|
|
#if 0 /* Original C code. */
|
|
word *writer = (word *) (getWritableBuffer() + (BYTES_PER_SCREEN - TOWER_HEIGHT * BYTES_PER_ROW + BYTES_PER_ROW / 2 - 1));
|
|
for (byte i = 0; i < TOWER_HEIGHT; ++i, writer += BYTES_PER_ROW / 2)
|
|
{
|
|
assert((word) writer - (word) getWritableBuffer() < 6144);
|
|
*writer = tower_pixels[i];
|
|
}
|
|
#else
|
|
asm
|
|
{
|
|
lbsr getWritableBuffer ; point X to start of current graphics buffer
|
|
OFFSET equ BYTES_PER_SCREEN_-TOWER_HEIGHT*BYTES_PER_ROW+BYTES_PER_ROW/2-1
|
|
leax OFFSET,x ; X is 'writer'
|
|
IF_OS9(pshs y, ;)
|
|
leay :tower_pixels ; under OS-9, cannot refer to global C vars after this
|
|
ldb #TOWER_HEIGHT ; number of words to copy
|
|
pshs b ; word counter in stack
|
|
@loop
|
|
ldd ,y++ ; load a word of pixels
|
|
std ,x ; write to graphics buffer
|
|
leax BYTES_PER_ROW,x ; point to next pixel row
|
|
dec ,s ; dec word counter
|
|
bne @loop ; loop if more words to copy
|
|
;
|
|
leas 1,s ; discard word counter
|
|
IF_OS9(puls y, ;)
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
// 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
|
|
initBiplaneSprite(Sprite *biplane,
|
|
const PreShiftedBitmap *bitmapArray[],
|
|
byte initBitmapIndex,
|
|
byte initX)
|
|
{
|
|
assert(biplane);
|
|
assert(bitmapArray);
|
|
assert(initBitmapIndex < NUM_BIPLANE_BITMAPS);
|
|
assert(initX >= 2 && initX + SPRITE_WIDTH + 2 <= COLS_PER_SCREEN);
|
|
|
|
const PreShiftedBitmap *bm = bitmapArray[initBitmapIndex];
|
|
assert(bm->height == BIPLANE_HEIGHT);
|
|
Sprite_init(biplane, bm);
|
|
biplane->x = initX;
|
|
biplane->y = ROWS_PER_SCREEN - bm->height / 2 - bm->height;
|
|
biplane->bitmapIndex = initBitmapIndex;
|
|
}
|
|
|
|
|
|
// Draws to the buffer given by getWritableBuffer().
|
|
// Does nothing if s->active is FALSE.
|
|
// Calls noiseFuncPtr while drawing (if soundAllowed is non-zero):
|
|
// That function can be used for background noise.
|
|
//
|
|
__gcccall void
|
|
drawSprite(const Sprite *s)
|
|
{
|
|
if (!s->active)
|
|
return;
|
|
|
|
assert(s->x >= 2 && s->x <= COLS_PER_SCREEN - 2 - SPRITE_WIDTH);
|
|
assert(s->bm);
|
|
assert(s->h > 0);
|
|
|
|
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 :soundAllowed
|
|
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");
|
|
}
|
|
|
|
|
|
__gcccall void
|
|
drawSpriteList(const Sprite spriteList[], byte numSprites)
|
|
{
|
|
for (byte i = 0; i < numSprites; ++i, ++spriteList)
|
|
drawSprite(spriteList);
|
|
}
|
|
|
|
|
|
// x: Digit position (one digit per byte).
|
|
// Writes at row THIN_BITMAP_Y_POS.
|
|
//
|
|
__gcccall void
|
|
drawThinBitmap(byte x, const ThinBitmap *bitmap)
|
|
{
|
|
#if 0 /* Original C code. */
|
|
byte *p = getWritableBuffer() + ((word) THIN_BITMAP_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 THIN_BITMAP_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
|
|
}
|
|
|
|
|
|
// horizPos: 0..31.
|
|
//
|
|
__gcccall void
|
|
drawScore(const Score *score, byte horizPos, BOOL leftJustified)
|
|
{
|
|
byte tens = score->digits[0];
|
|
byte units = score->digits[1];
|
|
if (tens == 0)
|
|
{
|
|
if (leftJustified)
|
|
{
|
|
drawThinBitmap(horizPos, digitBitmaps[units]);
|
|
drawThinBitmap(horizPos + 1, &space_bm);
|
|
}
|
|
else
|
|
{
|
|
drawThinBitmap(horizPos, &space_bm);
|
|
drawThinBitmap(horizPos + 1, digitBitmaps[units]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
drawThinBitmap(horizPos, digitBitmaps[tens]);
|
|
drawThinBitmap(horizPos + 1, digitBitmaps[units]);
|
|
}
|
|
}
|
|
|
|
|
|
__gcccall void
|
|
drawChars(const char *str)
|
|
{
|
|
for ( ; *str; ++str)
|
|
drawChar((unsigned char) *str);
|
|
}
|
|
|
|
|
|
void
|
|
drawStartPrompt(const char *line0, const char *line1)
|
|
{
|
|
makeSpacesTransparent(FALSE);
|
|
moveCursor(START_PROMPT_COL, START_PROMPT_ROW);
|
|
drawChars(line0);
|
|
moveCursor(START_PROMPT_COL, START_PROMPT_ROW + 1);
|
|
drawChars(line1);
|
|
makeSpacesTransparent(TRUE);
|
|
}
|
|
|
|
|
|
void
|
|
showStartPrompt(void)
|
|
{
|
|
drawStartPrompt("PRESS A PLANE'S FIRE", "BUTTON TO START IT. ");
|
|
}
|
|
|
|
|
|
void
|
|
eraseStartPrompt(void)
|
|
{
|
|
drawStartPrompt(" ", " ");
|
|
}
|
|
|
|
|
|
void
|
|
drawInWritablePage(void)
|
|
{
|
|
drawTower(); // TODO (if needed for perf): Only call this when tower region is dirty.
|
|
|
|
drawSprite(&balloon);
|
|
drawSprite(&biplane_red);
|
|
drawSprite(&biplane_blue);
|
|
drawSpriteList(bullets_red, ARRAY_SIZE(bullets_red));
|
|
drawSpriteList(bullets_blue, ARRAY_SIZE(bullets_blue));
|
|
drawSpriteList(explosions, ARRAY_SIZE(explosions));
|
|
drawSpriteList(leftClouds, ARRAY_SIZE(leftClouds));
|
|
drawSpriteList(rightClouds, ARRAY_SIZE(rightClouds));
|
|
|
|
// Show the start prompt if needed.
|
|
//
|
|
assert(getWritableBuffer() == scrnBuffer);
|
|
if (!gameStarted && !grPageHasStartPrompt[writablePageIndex])
|
|
{
|
|
showStartPrompt();
|
|
grPageHasStartPrompt[writablePageIndex] = TRUE;
|
|
}
|
|
else if (gameStarted && grPageHasStartPrompt[writablePageIndex])
|
|
{
|
|
eraseStartPrompt();
|
|
grPageHasStartPrompt[writablePageIndex] = FALSE;
|
|
}
|
|
|
|
drawScore(&redScore, 1, TRUE);
|
|
drawScore(&blueScore, 29, FALSE);
|
|
}
|
|
|
|
|
|
// 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.
|
|
//
|
|
__gcccall 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;
|
|
}
|
|
|
|
|
|
// 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,
|
|
};
|
|
|
|
|
|
sbyte randomSoundSampleIndex = 0; // signed index into randomSoundSamples[] (-128..127)
|
|
|
|
|
|
// 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
|
|
playExplosionSoundSample(void)
|
|
{
|
|
asm
|
|
{
|
|
leax :randomSoundSamples[128] ; middle of table
|
|
ldb :randomSoundSampleIndex ; signed index
|
|
lda b,x
|
|
sta $FF20 ; write to PIA1
|
|
incb ; rolls over after 127, so stays in -128..127
|
|
stb :randomSoundSampleIndex
|
|
}
|
|
}
|
|
|
|
|
|
// 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.
|
|
//
|
|
__gcccall 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->timeToLive = FRAMES_PER_EXPLOSION; // explosion will live for this many frames
|
|
|
|
noiseFuncPtr = playExplosionSoundSample;
|
|
|
|
return explosion;
|
|
}
|
|
|
|
|
|
// (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 given by width2.
|
|
// All arguments are signed.
|
|
//
|
|
BOOL
|
|
areSpriteRectanglesColliding(sword x1, sword y1, sword height1,
|
|
sword x2, sword y2, sword height2,
|
|
byte width2)
|
|
{
|
|
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 + width2 <= 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;
|
|
}
|
|
|
|
|
|
#if 0 // Not used.
|
|
|
|
|
|
// 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.
|
|
//
|
|
BOOL
|
|
detectCollision2Sprites(Sprite *a, Sprite *b)
|
|
{
|
|
if (!areSpriteRectanglesColliding(a->x, signExtendYPos(a->y), a->h,
|
|
b->x, signExtendYPos(b->y), b->h,
|
|
SPRITE_WIDTH))
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
return collisionDetected;
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
|
|
void
|
|
detectBulletOnPlane(Controller *controller, Sprite *bullet, Score *shooterScore)
|
|
{
|
|
if (!bullet->active)
|
|
return;
|
|
BiplaneMover *mover = controller->mover;
|
|
if (!mover->hasStarted)
|
|
return;
|
|
Sprite *biplane = mover->biplane;
|
|
if (!biplane->active)
|
|
return;
|
|
|
|
if (!areSpriteRectanglesColliding(biplane->x, biplane->y, biplane->h,
|
|
bullet->x + BULLET_MARGIN, bullet->y,
|
|
bullet->h, BULLET_WIDTH)) // re: bullet.bm
|
|
return;
|
|
|
|
startExplosion(biplane);
|
|
biplane->active = FALSE;
|
|
Controller_onBiplaneExplosion(controller);
|
|
|
|
|
|
// Wait until after explosion finished to respawn the plane.
|
|
//
|
|
mover->numFramesBeforeSpawn = FRAMES_PER_EXPLOSION;
|
|
|
|
bullet->active = FALSE;
|
|
Score_addPoint(shooterScore);
|
|
}
|
|
|
|
|
|
void
|
|
detectBulletOnBalloon(Sprite *bullet, Score *shooterScore)
|
|
{
|
|
if (!bullet->active || !balloon.active || numFramesBeforeBalloonTakeOff > 0)
|
|
return;
|
|
|
|
if (!areSpriteRectanglesColliding(balloon.x, balloon.y, balloon.h,
|
|
bullet->x + BULLET_MARGIN, bullet->y,
|
|
bullet->h, BULLET_WIDTH)) // re: bullet.bm
|
|
return;
|
|
|
|
startExplosion(&balloon);
|
|
balloon.active = FALSE;
|
|
|
|
// Wait until after explosion finished to respawn the balloon.
|
|
//
|
|
numBalloonExplosionFramesLeft = FRAMES_PER_EXPLOSION;
|
|
|
|
bullet->active = FALSE;
|
|
Score_addPoint(shooterScore);
|
|
}
|
|
|
|
|
|
void
|
|
detectPlaneOnTower(Controller *controller, Score *otherPlayerScore)
|
|
{
|
|
BiplaneMover *mover = controller->mover;
|
|
if (!mover->hasStarted)
|
|
return;
|
|
Sprite *biplane = mover->biplane;
|
|
if (!biplane->active)
|
|
return;
|
|
|
|
if (!areSpriteRectanglesColliding(biplane->x, biplane->y, biplane->h,
|
|
TOWER_LEFT_X, TOWER_TOP_Y,
|
|
TOWER_HEIGHT, TOWER_WIDTH)) // re: tower_pixels[]
|
|
return;
|
|
|
|
startExplosion(biplane);
|
|
biplane->active = FALSE;
|
|
Controller_onBiplaneExplosion(controller);
|
|
|
|
// Wait until after explosion finished to respawn the plane.
|
|
//
|
|
mover->numFramesBeforeSpawn = FRAMES_PER_EXPLOSION;
|
|
|
|
Score_addPoint(otherPlayerScore);
|
|
}
|
|
|
|
|
|
void
|
|
detectBulletOnTower(Sprite *bullet)
|
|
{
|
|
if (!bullet->active)
|
|
return;
|
|
|
|
if (!areSpriteRectanglesColliding(TOWER_LEFT_X, TOWER_TOP_Y, TOWER_HEIGHT,
|
|
bullet->x + BULLET_MARGIN, bullet->y,
|
|
bullet->h, BULLET_WIDTH)) // re: bullet.bm
|
|
return;
|
|
|
|
bullet->active = FALSE;
|
|
}
|
|
|
|
|
|
void
|
|
detectCollisions(void)
|
|
{
|
|
Sprite *blueBullet = bullets_blue;
|
|
Sprite * const bullets_blue_end = bullets_blue + MAX_BULLETS_PER_PLANE;
|
|
Sprite *redBullet = bullets_red;
|
|
|
|
for ( ; blueBullet < bullets_blue_end; ++blueBullet, ++redBullet)
|
|
{
|
|
detectBulletOnPlane(&redBiplaneController, blueBullet, &blueScore);
|
|
detectBulletOnPlane(&blueBiplaneController, redBullet, &redScore);
|
|
detectBulletOnBalloon(blueBullet, &blueScore);
|
|
detectBulletOnBalloon(redBullet, &redScore);
|
|
detectBulletOnTower(blueBullet);
|
|
detectBulletOnTower(redBullet);
|
|
}
|
|
detectPlaneOnTower(&redBiplaneController, &blueScore);
|
|
detectPlaneOnTower(&blueBiplaneController, &redScore);
|
|
}
|
|
|
|
|
|
BOOL
|
|
isExplosionActive(void)
|
|
{
|
|
for (byte i = 0; i < MAX_EXPLOSIONS; ++i)
|
|
if (explosions[i].active)
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
__gcccall void
|
|
animateBullet(Sprite *bullet)
|
|
{
|
|
if (!bullet->active)
|
|
return;
|
|
|
|
if (bullet->timeToLive == 0)
|
|
{
|
|
bullet->active = FALSE; // time to live over
|
|
return;
|
|
}
|
|
--bullet->timeToLive;
|
|
|
|
sword newX = (sword) bullet->x + bullet->dx;
|
|
if (newX > COLS_PER_SCREEN - 2 - SPRITE_WIDTH) // if past rightmost allowed pos
|
|
newX = 2; // reposition at leftmost allowed pos
|
|
else if (newX < 2)
|
|
newX = COLS_PER_SCREEN - 2 - SPRITE_WIDTH;
|
|
|
|
sword newY = (sword) bullet->y + bullet->dy;
|
|
if (newY < 0 || newY + bullet_bm.height > ROWS_PER_SCREEN)
|
|
{
|
|
bullet->active = FALSE; // went out at top/bottom of screen
|
|
return;
|
|
}
|
|
|
|
bullet->x = (byte) newX;
|
|
bullet->y = (byte) newY;
|
|
}
|
|
|
|
|
|
void
|
|
animateBullets(void)
|
|
{
|
|
Sprite *redBullet = bullets_red;
|
|
Sprite *bullets_red_end = bullets_red + ARRAY_SIZE(bullets_red);
|
|
Sprite *blueBullet = bullets_blue;
|
|
for ( ; redBullet < bullets_red_end; ++redBullet, ++blueBullet)
|
|
{
|
|
animateBullet(redBullet);
|
|
animateBullet(blueBullet);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
animateExplosions(void)
|
|
{
|
|
byte bitmapIndex = (byte) numFrames & 1;
|
|
BOOL atLeastOneExplosion = FALSE;
|
|
|
|
for (byte i = 0; i < MAX_EXPLOSIONS; ++i)
|
|
{
|
|
Sprite *e = &explosions[i];
|
|
if (!e->active)
|
|
continue;
|
|
if (--e->timeToLive == 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;
|
|
}
|
|
|
|
atLeastOneExplosion = TRUE;
|
|
|
|
if (e->dy < 0) // if explosion moving up
|
|
e->y = (byte) (e->dy + signExtendYPos(e->y));
|
|
}
|
|
|
|
if (!atLeastOneExplosion)
|
|
noiseFuncPtr = silence; // stop playing explosion sound
|
|
}
|
|
|
|
|
|
void
|
|
initBalloon(void)
|
|
{
|
|
Sprite_init(&balloon, &balloon_bm);
|
|
balloon.x = (COLS_PER_SCREEN - SPRITE_WIDTH) / 2;
|
|
balloon.y = TOWER_TOP_Y - 1 - balloon_bm.height;
|
|
numFramesBeforeBalloonTakeOff = rnd(MIN_BALLOON_TAKE_OFF_TIME, MAX_BALLOON_TAKE_OFF_TIME);
|
|
numBalloonExplosionFramesLeft = 0;
|
|
}
|
|
|
|
|
|
enum { BALLOON_UP_AND_LEFT, BALLOON_UP_AND_RIGHT, BALLOON_UP };
|
|
byte prevBalloonDirection = BALLOON_UP;
|
|
byte numFramesBeforeBallonDirChange = FRAMES_PER_BALLON_DIR_CHANGE;
|
|
|
|
|
|
void
|
|
animateBalloon(void)
|
|
{
|
|
if (!balloon.active)
|
|
{
|
|
if (numBalloonExplosionFramesLeft > 0) // if balloon exploding
|
|
{
|
|
--numBalloonExplosionFramesLeft;
|
|
return; // left explosion continue
|
|
}
|
|
|
|
// Balloon explosion has finished, so create new one.
|
|
initBalloon();
|
|
return;
|
|
}
|
|
|
|
if (!gameStarted)
|
|
return;
|
|
|
|
if (numFramesBeforeBalloonTakeOff > 0)
|
|
{
|
|
--numFramesBeforeBalloonTakeOff;
|
|
return; // not time to take off yet
|
|
}
|
|
|
|
if ((byte) numFrames & 1)
|
|
return; // only move balloon every 2 frames, to make it slow
|
|
|
|
// Balloon is in flight. Move it up.
|
|
// balloon.y is allowed to go below 0, in signed terms, because
|
|
// drawSprite() will do the needed clipping.
|
|
//
|
|
--balloon.y;
|
|
if (balloon.y >= ROWS_PER_SCREEN && balloon.y <= (byte) -BALLOON_HEIGHT) // if entirely above screen
|
|
{
|
|
initBalloon(); // put balloon back on tower; reinit numFramesBeforeBalloonTakeOff
|
|
return;
|
|
}
|
|
byte direction; // BALLOON_*
|
|
if (numFramesBeforeBallonDirChange > 0) // if not time to change direction
|
|
{
|
|
--numFramesBeforeBallonDirChange;
|
|
direction = prevBalloonDirection; // reuse previous direction
|
|
}
|
|
else
|
|
{
|
|
direction = generateRandomTayste(); // get new direction randomly
|
|
if (direction == BALLOON_UP_AND_LEFT && prevBalloonDirection == BALLOON_UP_AND_RIGHT)
|
|
direction = BALLOON_UP; // avoid going right just after going left
|
|
else if (direction == BALLOON_UP_AND_RIGHT && prevBalloonDirection == BALLOON_UP_AND_LEFT)
|
|
direction = BALLOON_UP; // avoid going left just after going right
|
|
else if (direction == 3) // 4th value is also "up"
|
|
direction = BALLOON_UP;
|
|
numFramesBeforeBallonDirChange = FRAMES_PER_BALLON_DIR_CHANGE;
|
|
}
|
|
switch (direction)
|
|
{
|
|
case BALLOON_UP_AND_LEFT:
|
|
if (balloon.x > 2)
|
|
balloon.x -= 2;
|
|
break;
|
|
case BALLOON_UP_AND_RIGHT:
|
|
if (balloon.x < COLS_PER_SCREEN - 2 - SPRITE_WIDTH)
|
|
balloon.x += 2;
|
|
break;
|
|
}
|
|
prevBalloonDirection = direction;
|
|
}
|
|
|
|
|
|
void
|
|
initNumFramesBeforeCloudMove(void)
|
|
{
|
|
numFramesBeforeCloudMove = (byte) rnd(50, 100);
|
|
}
|
|
|
|
|
|
void
|
|
animateClouds(void)
|
|
{
|
|
if (numFramesBeforeCloudMove > 0)
|
|
{
|
|
--numFramesBeforeCloudMove;
|
|
return;
|
|
}
|
|
initNumFramesBeforeCloudMove();
|
|
|
|
for (byte i = 0; i < MAX_CLOUDS; ++i)
|
|
{
|
|
Sprite *lc = &leftClouds[i];
|
|
sword newX = (sword) lc->x + windDirection;
|
|
if (newX < 2)
|
|
newX = COLS_PER_SCREEN - 2 - SPRITE_WIDTH * 2;
|
|
else if (newX > COLS_PER_SCREEN - 2 - SPRITE_WIDTH * 2)
|
|
newX = 2;
|
|
assert(newX >= 2 && newX <= COLS_PER_SCREEN - 2 - SPRITE_WIDTH * 2);
|
|
lc->x = (byte) newX;
|
|
|
|
rightClouds[i].x = (byte) newX + SPRITE_WIDTH;
|
|
}
|
|
}
|
|
|
|
|
|
// Returns the index in bulletArray[] of the first inactive Sprite.
|
|
// Returns MAX_BULLETS_PER_PLANE if none is found.
|
|
//
|
|
byte
|
|
getFreeBulletSpotIndex(const Sprite bulletArray[MAX_BULLETS_PER_PLANE])
|
|
{
|
|
byte i;
|
|
for (i = 0; i < MAX_BULLETS_PER_PLANE; ++i)
|
|
if (!bulletArray[i].active)
|
|
break;
|
|
return i;
|
|
}
|
|
|
|
|
|
typedef struct SpeedVector
|
|
{
|
|
sbyte dx, dy;
|
|
} SpeedVector;
|
|
|
|
|
|
// Couples of the form 4 * cos(angle), 4 * -sin(angle).
|
|
// (Y axis points down.)
|
|
// The angle is the bitmap index (0..15) times 22.5 degrees (0, 22.5, 45, ..., 337.5).
|
|
// The horizontal speeds are rounded to the nearest even number.
|
|
// Allowing odd speeds would allow the sprite to be displayed starting at
|
|
// an odd horizontal position, which in PMODE 4 may change the sprite's colors
|
|
// because of that graphics mode's NTSC artifact colors.
|
|
//
|
|
const SpeedVector bulletSpeedVectors[NUM_BIPLANE_BITMAPS] =
|
|
{
|
|
{ 9, 0 }, // 0.0 degrees
|
|
{ 8, 3 }, // 22.5 degrees
|
|
{ 6, 6 }, // 45.0 degrees
|
|
{ 3, 8 }, // 67.5 degrees
|
|
{ -0, 9 }, // 90.0 degrees
|
|
{ -3, 8 }, // 112.5 degrees
|
|
{ -6, 6 }, // 135.0 degrees
|
|
{ -8, 3 }, // 157.5 degrees
|
|
{ -9, -0 }, // 180.0 degrees
|
|
{ -8, -3 }, // 202.5 degrees
|
|
{ -6, -6 }, // 225.0 degrees
|
|
{ -3, -8 }, // 247.5 degrees
|
|
{ 0, -9 }, // 270.0 degrees
|
|
{ 3, -8 }, // 292.5 degrees
|
|
{ 6, -6 }, // 315.0 degrees
|
|
{ 8, -3 }, // 337.5 degrees
|
|
};
|
|
|
|
|
|
static const byte bulletSound[] = { 0xFC, 0x04, 0xFC, 0x04 };
|
|
|
|
|
|
// Does nothing if 'biplane' is inactive or if no room in bulletArray[].
|
|
//
|
|
void
|
|
fireBullet(const Sprite *biplane, Sprite bulletArray[MAX_BULLETS_PER_PLANE])
|
|
{
|
|
assert(biplane);
|
|
|
|
if (!biplane->active)
|
|
return;
|
|
|
|
// Search for a free spot in the bullet array.
|
|
//
|
|
byte i = getFreeBulletSpotIndex(bulletArray);
|
|
if (i == MAX_BULLETS_PER_PLANE)
|
|
return; // no room
|
|
|
|
Sprite *bullet = &bulletArray[i];
|
|
|
|
const SpeedVector *speed = &bulletSpeedVectors[biplane->bitmapIndex];
|
|
|
|
Sprite_init(bullet, &bullet_bm);
|
|
|
|
// Put the bullet at the nose of the plane.
|
|
// The position of the nose depends on the 'speed' vector.
|
|
// The (x, y) position of the plane is the top-left pixel of
|
|
// the rectangle that encloses the plane bitmap.
|
|
// The minus 6 is because the bullet sprite is 16x2 but that
|
|
// bullet is a 4x2 subrectangle in the middle, and (16 - 4) / 2 = 6.
|
|
//
|
|
bullet->x = biplane->x + SPRITE_WIDTH / 2 + speed->dx - 6;
|
|
bullet->y = biplane->y + BIPLANE_HEIGHT / 2 - speed->dy;
|
|
|
|
bullet->dx = speed->dx;
|
|
bullet->dy = - speed->dy;
|
|
|
|
bullet->timeToLive = bulletTimeToLive;
|
|
|
|
if (soundAllowed)
|
|
playSoundSample(bulletSound, ARRAY_END(bulletSound), 20);
|
|
}
|
|
|
|
|
|
BOOL
|
|
checkForKey(byte probe, byte testBit)
|
|
{
|
|
if (!isKeyPressed(probe, testBit))
|
|
return FALSE;
|
|
while (isKeyPressed(probe, testBit))
|
|
;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void
|
|
checkForMute(void)
|
|
{
|
|
if (KeyState_update(&muteKeyState))
|
|
soundAllowed = !soundAllowed;
|
|
}
|
|
|
|
|
|
#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
|
|
|
|
|
|
BOOL inFailedAssert = FALSE;
|
|
|
|
|
|
void
|
|
onFailedAssert(const char *file, int lineno, const char *condition)
|
|
{
|
|
if (inFailedAssert)
|
|
return; // in case the following code asserts, avoid infinite loop
|
|
inFailedAssert = TRUE;
|
|
|
|
(*setColorSet)(0); // switch to green/black in case error msg not visible
|
|
|
|
moveCursor(0, 0); // cardgame library function
|
|
makeSpacesTransparent(FALSE);
|
|
printf("*** FAILED ASSERT: %s:%d: %s\n", file, lineno, condition);
|
|
flipDisplayedBuffer();
|
|
for (;;)
|
|
;
|
|
}
|
|
|
|
|
|
void
|
|
waitForKeyRelease(byte probe, byte testBit)
|
|
{
|
|
while (isKeyPressed(probe, testBit))
|
|
;
|
|
}
|
|
|
|
|
|
#if 0
|
|
void
|
|
waitForKeyPressAndRelease(byte probe, byte testBit)
|
|
{
|
|
while (! isKeyPressed(probe, testBit))
|
|
;
|
|
waitForKeyRelease(probe, testBit);
|
|
}
|
|
#endif
|
|
|
|
|
|
BOOL
|
|
isKeyPressedAndReleased(byte probe, byte testBit)
|
|
{
|
|
if (isKeyPressed(probe, testBit))
|
|
{
|
|
waitForKeyRelease(probe, testBit);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void updateJoystickButtons(void);
|
|
|
|
|
|
// Waits for a key that corresponds to the commands offered by the pause screen.
|
|
//
|
|
// allowResume: Allow resuming the game. Should be FALSE at first, and when
|
|
// a game has just finished.
|
|
//
|
|
// The next parameters are only used when allowResume is FALSE.
|
|
//
|
|
// (colNumPlayers, rowNumPlayers): Position on the text screen where '1' or '2'
|
|
// is displayed to indicate the number of players
|
|
// in the next game.
|
|
// (colNumPlayers, rowControlType): Position where 'K' or 'J' is displayed to indicate
|
|
// keyboard or joystick control.
|
|
// (colNumPlayers, rowBulletRange): Position where 'S' or 'L' is displayed to indicate
|
|
// short-range or long-range bullet.
|
|
// numPlayers: Must point to a byte that receives 1 or 2 (value, not character)
|
|
// when key 1 or 2 is pressed.
|
|
// controlType: Must point to a byte that receives JOYSTICK_CONTROLLER or
|
|
// KEYBOARD_CONTROLLER when key J or K is pressed.
|
|
//
|
|
// Modifies bulletTimeToLive if a bullet range key (S or L) is pressed.
|
|
//
|
|
// Returns ' ', 'R' or 'I'.
|
|
//
|
|
byte
|
|
waitForGamePauseKey(BOOL allowResume,
|
|
byte colNumPlayers,
|
|
byte rowNumPlayers, byte rowControlType, byte rowBulletRange,
|
|
byte *numPlayers, byte *controlType)
|
|
{
|
|
for (;;)
|
|
{
|
|
updateJoystickButtons();
|
|
|
|
if (allowResume && isKeyPressedAndReleased(KEY_PROBE_R, KEY_BIT_R))
|
|
{
|
|
return 'R';
|
|
}
|
|
if (isKeyPressedAndReleased(KEY_PROBE_SPACE, KEY_BIT_SPACE)
|
|
|| (~joystickButtonPreviousStates & joystickButtonStates))
|
|
// if space bar or joystick button clicked
|
|
{
|
|
return ' ';
|
|
}
|
|
if (!allowResume) // if presentation screen, or game over:
|
|
{
|
|
if (isKeyPressedAndReleased(KEY_PROBE_1, KEY_BIT_1))
|
|
{
|
|
moveCursor(colNumPlayers, rowNumPlayers);
|
|
drawChar('1');
|
|
*numPlayers = 1;
|
|
continue;
|
|
}
|
|
if (isKeyPressedAndReleased(KEY_PROBE_2, KEY_BIT_2))
|
|
{
|
|
moveCursor(colNumPlayers, rowNumPlayers);
|
|
drawChar('2');
|
|
*numPlayers = 2;
|
|
continue;
|
|
}
|
|
if (isKeyPressedAndReleased(KEY_PROBE_J, KEY_BIT_J))
|
|
{
|
|
moveCursor(colNumPlayers, rowControlType);
|
|
drawChar('J');
|
|
*controlType = JOYSTICK_CONTROLLER;
|
|
continue;
|
|
}
|
|
if (isKeyPressedAndReleased(KEY_PROBE_K, KEY_BIT_K))
|
|
{
|
|
moveCursor(colNumPlayers, rowControlType);
|
|
drawChar('K');
|
|
*controlType = KEYBOARD_CONTROLLER;
|
|
continue;
|
|
}
|
|
if (isKeyPressedAndReleased(KEY_PROBE_S, KEY_BIT_S))
|
|
{
|
|
moveCursor(colNumPlayers, rowBulletRange);
|
|
drawChar('S');
|
|
bulletTimeToLive = FRAMES_PER_SHORT_RANGE_BULLET;
|
|
continue;
|
|
}
|
|
if (isKeyPressedAndReleased(KEY_PROBE_L, KEY_BIT_L))
|
|
{
|
|
moveCursor(colNumPlayers, rowBulletRange);
|
|
drawChar('L');
|
|
bulletTimeToLive = FRAMES_PER_LONG_RANGE_BULLET;
|
|
continue;
|
|
}
|
|
}
|
|
if (isKeyPressedAndReleased(KEY_PROBE_I, KEY_BIT_I)) // show instructions
|
|
{
|
|
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]);
|
|
}
|
|
|
|
|
|
// Returns TRUE if the user wants to see the next page,
|
|
// or FALSE if the user wants to stop reading.
|
|
//
|
|
BOOL
|
|
pressSpaceToContinue(void)
|
|
{
|
|
printWrapped(
|
|
"\n"
|
|
"PRESS ^SPACE^ TO CONTINUE...\n");
|
|
|
|
BOOL cont = TRUE;
|
|
for (;;)
|
|
{
|
|
if (checkForKey(KEY_PROBE_SPACE, KEY_BIT_SPACE))
|
|
break;
|
|
if (checkForKey(KEY_PROBE_BREAK, KEY_BIT_BREAK))
|
|
{
|
|
cont = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
clearScreen(scrnBuffer);
|
|
moveCursor(0, 1);
|
|
return cont;
|
|
}
|
|
|
|
|
|
// Clears the screen first, and also clears it before returning.
|
|
//
|
|
void
|
|
showInstructionsScreen(void)
|
|
{
|
|
clearScreen(scrnBuffer);
|
|
printCentered(1, "INSTRUCTIONS");
|
|
moveCursor(0, 3);
|
|
printWrapped("The object is to score 15 points first by shooting down "
|
|
"your opponent's plane or the ascending balloon, "
|
|
"and by not crashing your own plane.\n"
|
|
"\n"
|
|
"Take off by pressing the joystick fire button, "
|
|
"then climb by pulling back the joystick.\n"
|
|
"\n"
|
|
"Get back to a horizontal position by pushing up the joystick.\n");
|
|
if (!pressSpaceToContinue())
|
|
return;
|
|
printWrapped("Don't make your plane climb too fast or it will stall and crash. "
|
|
"If it starts to lose altitude, pull back the joystick, "
|
|
"so the plain gains speed and stability.\n"
|
|
"\n"
|
|
"To fire at the ascending balloon or your opponent's plane, "
|
|
"aim at the target and press the fire button.\n"
|
|
"\n"
|
|
"A plane can do loops, dive and fly upside down.\n"
|
|
"\n"
|
|
"When a plane, a bullet or a cloud reaches a side of the screen, "
|
|
"it teleports to the other side instantly.\n");
|
|
if (!pressSpaceToContinue())
|
|
return;
|
|
printWrapped("The presentation screen allows choosing a 1 or 2 player game. "
|
|
"In a single-player game, the red plane is controlled by the computer, "
|
|
"and you control the blue plane.\n"
|
|
"\n"
|
|
"When playing with the keyboard, the red plane climbs with ^Z^, "
|
|
"dives with ^A^ and fires with ^S^, while the blue plane climbs "
|
|
"with ^.^, dives with ^;^ and fires with ^L^.\n"
|
|
"\n"
|
|
"A choice is also offered between short-range and long-range bullets.\n");
|
|
if (!pressSpaceToContinue())
|
|
return;
|
|
printWrapped("Pressing the Reset button quits the game and shows the "
|
|
"presentation screen again.\n"
|
|
"\n"
|
|
"This game is based on the biplanes game of the 1981 "
|
|
"Intellivision Triple Action cartridge.\n");
|
|
pressSpaceToContinue();
|
|
}
|
|
|
|
|
|
#if COMPUTE_CHECKSUM
|
|
|
|
void
|
|
computeAndShowCodeCheckSum(void)
|
|
{
|
|
void *program_start, *s_rwdata;
|
|
asm
|
|
{
|
|
program_start IMPORT
|
|
s_rwdata IMPORT
|
|
ldx #program_start
|
|
stx :program_start
|
|
ldx #s_rwdata
|
|
stx :s_rwdata
|
|
}
|
|
moveCursor(0, 0);
|
|
printf("program_start=%p\n""s_rwdata=%p.\n", program_start, s_rwdata);
|
|
uint16_t crc = crc16_block(CRC16_RESET, program_start, s_rwdata - program_start);
|
|
printf("crc=$%04x\n", crc);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
// Made with Verdana Bold 18 font in GIMP 2.10.
|
|
//
|
|
extern const uint32_t titleBitmap[14][8];
|
|
|
|
|
|
// Returns ' ' or 'R'.
|
|
//
|
|
byte
|
|
showPresentationScreen(byte *numPlayers, byte *controlType)
|
|
{
|
|
// Show empty screen while drawing presentation, which takes about a full second.
|
|
//
|
|
showGraphicsPage(writablePageIndex ? page0 : page1);
|
|
|
|
#if COMPUTE_CHECKSUM
|
|
computeAndShowCodeCheckSum();
|
|
#endif
|
|
|
|
for (;;)
|
|
{
|
|
// TODO: Draw some sprites above the title.
|
|
|
|
// Display the large, garish game title.
|
|
//
|
|
const byte numTitleRows = ARRAY_SIZE(titleBitmap); // in pixel rows
|
|
byte *screenPtr = getWritableBuffer() + (word) 1 * PIXEL_ROWS_PER_TEXT_ROW * BYTES_PER_ROW;
|
|
copyDoubleRowBitmap(screenPtr, titleBitmap, numTitleRows);
|
|
|
|
byte titleVertMargin = 4; // in pixel rows
|
|
byte *xoredRegion = screenPtr - titleVertMargin * BYTES_PER_ROW;
|
|
byte numXoredRows = numTitleRows * 2 + titleVertMargin * 2;
|
|
xorRegion(xoredRegion, numXoredRows, 0x55);
|
|
|
|
// N.B.: printWrapped() must be used if color inversion (^) is needed.
|
|
|
|
byte textRow = 6;
|
|
printCentered(textRow++, "VERSION " VERSION);
|
|
textRow++;
|
|
enableInvertedColorText(TRUE);
|
|
printCentered(textRow++, "UNFINISHED PROTOTYPE");
|
|
enableInvertedColorText(FALSE);
|
|
textRow++;
|
|
printCentered(textRow++, "(C) " COPYRIGHT_YEARS " PIERRE SARRAZIN");
|
|
printCentered(textRow++, "DISTRIBUTED UNDER");
|
|
printCentered(textRow++, "THE GNU GPL V3 OR LATER");
|
|
textRow++;
|
|
moveCursor(WRAPPED_TEXT_LEFT_MARGIN, textRow++);
|
|
printWrapped("PRESS ^I^ FOR INSTRUCTIONS.\n\n");
|
|
printWrapped("NUMBER OF PLAYERS (^1^ OR ^2^):");
|
|
drawChar(' ');
|
|
drawChar('0' + *numPlayers);
|
|
printWrapped("\n\nUSE ^J^OYSTICK OR ^K^EYBOARD:");
|
|
drawChars(" "); // printWrapped() would merge these 3 spaces into a single one
|
|
drawChar(*controlType == JOYSTICK_CONTROLLER ? 'J' : 'K');
|
|
printWrapped("\n\n^S^HORT/^L^ONG-RANGE BULLETS:");
|
|
drawChars(" ");
|
|
drawChar(bulletTimeToLive == FRAMES_PER_SHORT_RANGE_BULLET ? 'S' : 'L');
|
|
printWrapped("\n\nPRESS ^SPACE^ TO START THE GAME.");
|
|
|
|
// Show the screen that has just been drawn.
|
|
//
|
|
showGraphicsPage(writablePageIndex ? page1 : page0);
|
|
|
|
byte cursorX, cursorY;
|
|
getCursor(&cursorX, &cursorY);
|
|
|
|
byte key = waitForGamePauseKey(FALSE,
|
|
cursorX - 2,
|
|
cursorY - 6, cursorY - 4, cursorY - 2,
|
|
numPlayers, controlType);
|
|
assert(key == 'I' || key == ' ' || key == 'R');
|
|
if (key == 'I')
|
|
{
|
|
showInstructionsScreen();
|
|
showGraphicsPage(writablePageIndex ? page0 : page1); // show empty screen
|
|
continue;
|
|
}
|
|
return key;
|
|
}
|
|
}
|
|
|
|
|
|
byte
|
|
showGamePauseScreen(BOOL gameOver, byte *numPlayers, byte *controlType)
|
|
{
|
|
byte leftMargin = 1, indent = 6, row = 9;
|
|
moveCursor(leftMargin, 6);
|
|
if (gameOver)
|
|
{
|
|
putstr("GAME OVER", 9);
|
|
moveCursor(leftMargin, row);
|
|
putstr("PRESS ", 6);
|
|
}
|
|
else
|
|
{
|
|
putstr("GAME PAUSED", 11);
|
|
moveCursor(leftMargin, row);
|
|
++row;
|
|
++row;
|
|
printWrapped("PRESS ^R^ TO RESUME,");
|
|
moveCursor(leftMargin + indent, row);
|
|
}
|
|
printWrapped("^SPACE^ TO START");
|
|
++row;
|
|
moveCursor(leftMargin + indent + 6, row);
|
|
printWrapped("A NEW GAME,");
|
|
++row;
|
|
++row;
|
|
moveCursor(leftMargin + indent, row);
|
|
printWrapped("^I^ FOR INSTRUCTIONS.");
|
|
|
|
byte cursorX = 0, cursorY = 0;
|
|
if (gameOver)
|
|
{
|
|
++row;
|
|
++row;
|
|
moveCursor(leftMargin, row);
|
|
|
|
printWrapped("NUMBER OF PLAYERS (^1^ OR ^2^):");
|
|
drawChar(' ');
|
|
drawChar('0' + *numPlayers);
|
|
printWrapped("\n\nUSE ^J^OYSTICK OR ^K^EYBOARD:");
|
|
drawChars(" ");
|
|
drawChar(*controlType == JOYSTICK_CONTROLLER ? 'J' : 'K');
|
|
printWrapped("\n\n^S^HORT/^L^ONG-RANGE BULLETS:");
|
|
drawChars(" ");
|
|
drawChar(bulletTimeToLive == FRAMES_PER_SHORT_RANGE_BULLET ? 'S' : 'L');
|
|
|
|
getCursor(&cursorX, &cursorY);
|
|
}
|
|
|
|
return waitForGamePauseKey(!gameOver,
|
|
cursorX - 1,
|
|
cursorY - 4, cursorY - 2, cursorY,
|
|
numPlayers, controlType);
|
|
}
|
|
|
|
|
|
// Clears screen, show dialog, then clears screen again.
|
|
//
|
|
BOOL
|
|
showNewGameConfirmDialog(void)
|
|
{
|
|
byte *writableBuffer = getWritableBuffer();
|
|
assert(writableBuffer == scrnBuffer);
|
|
clearScreen(writableBuffer);
|
|
|
|
printCentered(9, "START A NEW GAME:");
|
|
printCentered(11, "ARE YOU SURE?");
|
|
moveCursor((32 - 10) / 2, 13);
|
|
printWrapped("^Y^ES or ^N^O?");
|
|
|
|
BOOL response = FALSE;
|
|
for (;;)
|
|
{
|
|
if (isKeyPressedAndReleased(KEY_PROBE_Y, KEY_BIT_Y))
|
|
{
|
|
response = TRUE;
|
|
break;
|
|
}
|
|
if (isKeyPressedAndReleased(KEY_PROBE_N, KEY_BIT_N))
|
|
break;
|
|
}
|
|
|
|
clearScreen(writableBuffer);
|
|
return response;
|
|
}
|
|
|
|
|
|
// redPlaneControlType: *_CONTROLLER value.
|
|
//
|
|
void
|
|
initRedBiplane(byte redPlaneControlType)
|
|
{
|
|
initBiplaneSprite(&biplane_red, biplane_red_bitmaps, 0 /* point right */, SPRITE_WIDTH / 2);
|
|
|
|
BiplaneDirectionFunctor dirFunctor;
|
|
switch (redPlaneControlType)
|
|
{
|
|
case KEYBOARD_CONTROLLER: dirFunctor = getRedKeyboardDirection; break;
|
|
case JOYSTICK_CONTROLLER: dirFunctor = getRedJoystickDirection; break;
|
|
case AUTOMATIC_CONTROLLER: dirFunctor = getRedAutomaticDirection; break;
|
|
default: assert(FALSE);
|
|
}
|
|
|
|
BiplaneMover_init(&redBiplaneMover,
|
|
&biplane_red, biplane_red_bitmaps, 1, NUM_BIPLANE_BITMAPS - 1,
|
|
dirFunctor);
|
|
Controller_init(&redBiplaneController,
|
|
redPlaneControlType,
|
|
&redBiplaneMover,
|
|
KEY_PROBE_S, KEY_BIT_S,
|
|
JOY_BUTTON_LEFT_MASK);
|
|
}
|
|
|
|
|
|
void
|
|
initBlueBiplane(BOOL bluePlaneUsesJoystick)
|
|
{
|
|
initBiplaneSprite(&biplane_blue, biplane_blue_bitmaps, 8 /* point left */,
|
|
(byte) (COLS_PER_SCREEN - SPRITE_WIDTH / 2 - SPRITE_WIDTH));
|
|
BiplaneMover_init(&blueBiplaneMover,
|
|
&biplane_blue, biplane_blue_bitmaps, NUM_BIPLANE_BITMAPS - 1, 1,
|
|
bluePlaneUsesJoystick
|
|
? getBlueJoystickDirection
|
|
: getBlueKeyboardDirection);
|
|
Controller_init(&blueBiplaneController,
|
|
bluePlaneUsesJoystick ? JOYSTICK_CONTROLLER : KEYBOARD_CONTROLLER,
|
|
&blueBiplaneMover,
|
|
KEY_PROBE_L, KEY_BIT_L,
|
|
JOY_BUTTON_RIGHT_MASK);
|
|
}
|
|
|
|
|
|
// A cloud is made of two sprites displayed side by side.
|
|
//
|
|
void
|
|
initCloud(Sprite *leftCloud, Sprite *rightCloud, BOOL onLeftHalfOfScreen)
|
|
{
|
|
// Choose a position that is above the 2 text lines where
|
|
// the start game prompt appears.
|
|
|
|
Sprite_init(leftCloud, &cloud_left_bm);
|
|
leftCloud->x = (byte) (onLeftHalfOfScreen
|
|
? rnd(2, COLS_PER_SCREEN / 2 - 2 - SPRITE_WIDTH * 2)
|
|
: rnd(COLS_PER_SCREEN / 2 + 2, COLS_PER_SCREEN - 2 - SPRITE_WIDTH * 2));
|
|
leftCloud->y = (byte) rnd(2, START_PROMPT_ROW * 8 - cloud_left_bm.height - 2);
|
|
|
|
assert(leftCloud->x >= 2 && leftCloud->x <= COLS_PER_SCREEN - 2 - SPRITE_WIDTH);
|
|
|
|
Sprite_init(rightCloud, &cloud_right_bm);
|
|
rightCloud->x = leftCloud->x + SPRITE_WIDTH;
|
|
rightCloud->y = leftCloud->y;
|
|
|
|
assert(rightCloud->x >= 2 && rightCloud->x <= COLS_PER_SCREEN - 2 - SPRITE_WIDTH);
|
|
}
|
|
|
|
|
|
void
|
|
initClouds(void)
|
|
{
|
|
for (byte i = 0; i < MAX_CLOUDS; ++i)
|
|
initCloud(&leftClouds[i], &rightClouds[i], i & 1);
|
|
|
|
switch (rand() % 7)
|
|
{
|
|
case 0: case 1: case 2:
|
|
windDirection = -2;
|
|
break;
|
|
case 3: case 4: case 5:
|
|
windDirection = +2;
|
|
break;
|
|
default:
|
|
windDirection = 0;
|
|
}
|
|
|
|
initNumFramesBeforeCloudMove();
|
|
}
|
|
|
|
|
|
// redPlaneControlType: *_CONTROLLER value.
|
|
// bluePlaneUsesJoystick: FALSE means keyboard control.
|
|
//
|
|
void
|
|
initNewGame(byte redPlaneControlType, BOOL bluePlaneUsesJoystick)
|
|
{
|
|
(*setColorSet)(1);
|
|
|
|
for (byte i = 0; i < MAX_EXPLOSIONS; ++i)
|
|
explosions[i].active = FALSE;
|
|
|
|
initBalloon();
|
|
|
|
initRedBiplane(redPlaneControlType);
|
|
initBlueBiplane(bluePlaneUsesJoystick);
|
|
|
|
initClouds();
|
|
|
|
grPageHasStartPrompt[0] = grPageHasStartPrompt[1] = FALSE;
|
|
|
|
Score_init(&redScore);
|
|
Score_init(&blueScore);
|
|
|
|
numVSyncsBeforeScreenFlip = 1;
|
|
numFrames = 0; // init frame counter
|
|
|
|
gameStarted = FALSE;
|
|
}
|
|
|
|
|
|
byte
|
|
getRedKeyboardDirection(void)
|
|
{
|
|
if (isKeyPressed(KEY_PROBE_Z, KEY_BIT_Z))
|
|
return DIR_CLIMB;
|
|
if (isKeyPressed(KEY_PROBE_A, KEY_BIT_A))
|
|
return DIR_DIVE;
|
|
return DIR_FORWARD;
|
|
}
|
|
|
|
|
|
byte
|
|
getBlueKeyboardDirection(void)
|
|
{
|
|
if (isKeyPressed(KEY_PROBE_PERIOD, KEY_BIT_PERIOD))
|
|
return DIR_CLIMB;
|
|
if (isKeyPressed(KEY_PROBE_SEMICOLON, KEY_BIT_SEMICOLON))
|
|
return DIR_DIVE;
|
|
return DIR_FORWARD;
|
|
}
|
|
|
|
|
|
__gcccall void
|
|
updateJoystickAxisPos(byte axis, sbyte *joystickVerticalPos)
|
|
{
|
|
Joystick_selectAnalogMuxInputs(axis); // vertical axis of the right joystick
|
|
BOOL atOrAboveLowThreshold = Joystick_compareAxis(JOY_AXIS_LOW_THR);
|
|
//printf("[L=%u]", atOrAboveLowThreshold);
|
|
if (!atOrAboveLowThreshold) // if axis value close to zero
|
|
{
|
|
*joystickVerticalPos = JOY_UP;
|
|
//printf("[...]");
|
|
}
|
|
else
|
|
{
|
|
BOOL atOrAboveHighThreshold = Joystick_compareAxis(JOY_AXIS_HIGH_THR);
|
|
//printf("[H=%u]", atOrAboveHighThreshold);
|
|
if (atOrAboveHighThreshold) // if close to max value
|
|
*joystickVerticalPos = JOY_DOWN;
|
|
else
|
|
*joystickVerticalPos = JOY_MIDDLE;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
updateJoystickButtons(void)
|
|
{
|
|
joystickButtonPreviousStates = joystickButtonStates;
|
|
joystickButtonStates = Joystick_getButtonStates2();
|
|
}
|
|
|
|
|
|
// Must be called periodically.
|
|
// Uses useRightJoystick and useLeftJoystick.
|
|
//
|
|
void
|
|
updateJoysticks(void)
|
|
{
|
|
disableInterrupts();
|
|
|
|
// Save the current state of the DAC, to restore it after reading
|
|
// the joystick, to avoid hearing clicks.
|
|
//
|
|
byte savedDACState = * (byte *) 0xFF20;
|
|
|
|
Joystick_disableSound(); // needed to avoid disrupting sound effects
|
|
|
|
if (blueBiplaneController.controlType == JOYSTICK_CONTROLLER)
|
|
updateJoystickAxisPos(JOY_RIGHT_Y_AXIS, &rightJoystickVerticalPos);
|
|
if (redBiplaneController.controlType == JOYSTICK_CONTROLLER)
|
|
updateJoystickAxisPos(JOY_LEFT_Y_AXIS, &leftJoystickVerticalPos);
|
|
|
|
updateJoystickButtons();
|
|
|
|
// Reconnect digitial-to-analog sound input to output of sound multiplexer.
|
|
// Basic's SOUND command does this at $A960, just before setting bit 3 of $FF23,
|
|
// which we do by calling Joystick_enableSound().
|
|
//
|
|
Joystick_selectAnalogMuxInputs(0);
|
|
|
|
* (byte *) 0xFF20 = savedDACState;
|
|
|
|
Joystick_enableSound();
|
|
|
|
enableInterrupts();
|
|
}
|
|
|
|
|
|
byte
|
|
getRedJoystickDirection(void)
|
|
{
|
|
if (leftJoystickVerticalPos == JOY_DOWN)
|
|
return DIR_CLIMB;
|
|
if (leftJoystickVerticalPos == JOY_UP)
|
|
return DIR_DIVE;
|
|
return DIR_FORWARD;
|
|
}
|
|
|
|
|
|
byte
|
|
getBlueJoystickDirection(void)
|
|
{
|
|
if (rightJoystickVerticalPos == JOY_DOWN)
|
|
return DIR_CLIMB;
|
|
if (rightJoystickVerticalPos == JOY_UP)
|
|
return DIR_DIVE;
|
|
return DIR_FORWARD;
|
|
}
|
|
|
|
|
|
BOOL
|
|
isSpriteNearInFront(const Sprite *shooter, const Sprite *target)
|
|
{
|
|
int8_t angleInBrads;
|
|
if (!computeAngleIfNotTooFar(shooter->x, shooter->y, shooter->bitmapIndex,
|
|
target->x, target->y,
|
|
128, 128 * 128,
|
|
&angleInBrads))
|
|
return FALSE;
|
|
return angleInBrads > -16 && angleInBrads < 16;
|
|
}
|
|
|
|
|
|
// Uses redBiplaneController.
|
|
//
|
|
byte
|
|
getRedAutomaticDirection(void)
|
|
{
|
|
assert(gameStarted);
|
|
int8_t bradsBetweenPlanes;
|
|
|
|
switch (redBiplaneController.state)
|
|
{
|
|
case STATE_READY_FOR_TAKE_OFF:
|
|
return DIR_FORWARD;
|
|
|
|
case STATE_ON_RUNWAY:
|
|
{
|
|
if (redBiplaneController.numFramesBeforeStateChange > 0)
|
|
{
|
|
--redBiplaneController.numFramesBeforeStateChange;
|
|
return DIR_FORWARD;
|
|
}
|
|
redBiplaneController.state = STATE_FIRST_CLIMB;
|
|
|
|
// Choose the duration of the first climb.
|
|
redBiplaneController.numFramesBeforeStateChange = rnd(1 * 20, 3 * 20);
|
|
return DIR_CLIMB;
|
|
}
|
|
|
|
case STATE_FIRST_CLIMB:
|
|
if (redBiplaneController.numFramesBeforeStateChange == 0) // if finished climbing
|
|
{
|
|
redBiplaneController.state = STATE_IN_FLIGHT;
|
|
return DIR_DIVE;
|
|
}
|
|
--redBiplaneController.numFramesBeforeStateChange;
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case STATE_IN_FLIGHT:
|
|
if (!biplane_blue.active // attacking plane currently exploding
|
|
|| !blueBiplaneController.mover->hasStarted) // has not taken off
|
|
return DIR_FORWARD;
|
|
|
|
// Check if Red should change orientation to point towards Blue.
|
|
//
|
|
if ((biplane_red.bitmapIndex == 0 || biplane_red.bitmapIndex == 8) // pointing right or left
|
|
&& computeAngleIfNotTooFar(biplane_red.x, biplane_red.y, biplane_red.bitmapIndex,
|
|
biplane_blue.x, biplane_blue.y,
|
|
128, 128 * 128,
|
|
&bradsBetweenPlanes)
|
|
&& bradsBetweenPlanes != 0 // not already pointing towards Blue
|
|
&& abs(bradsBetweenPlanes) <= 16)
|
|
{
|
|
byte newDir;
|
|
if (biplane_red.bitmapIndex == 0) // if Red is upright
|
|
newDir = bradsBetweenPlanes > 0 ? DIR_CLIMB : DIR_DIVE;
|
|
else
|
|
newDir = bradsBetweenPlanes > 0 ? DIR_DIVE : DIR_CLIMB; // b/c Red is upside down
|
|
|
|
redBiplaneController.state = (newDir == DIR_CLIMB
|
|
? STATE_ATTACK_CLIMB : STATE_ATTACK_DIVE);
|
|
redBiplaneController.numFramesBeforeStateChange = rnd(5, 10);
|
|
return newDir;
|
|
}
|
|
// Check if time for a defensive looping.
|
|
//
|
|
else if (isSpriteNearInFront(&biplane_blue, &biplane_red)) // red in danger
|
|
{
|
|
// Choose betweem climbing and diving.
|
|
//
|
|
byte dir;
|
|
if (biplane_red.bitmapIndex <= 4 || biplane_red.bitmapIndex >= 13) // if pointing right or up
|
|
{
|
|
if (biplane_red.y < ROWS_PER_SCREEN / 2) // if plane in upper half of screen
|
|
dir = DIR_DIVE; // dive toward ground
|
|
else
|
|
dir = DIR_CLIMB; // climb toward sky
|
|
}
|
|
else // pointing left (upside down) or down:
|
|
{
|
|
if (biplane_red.y < ROWS_PER_SCREEN / 2) // if plane in upper half of screen
|
|
dir = DIR_CLIMB; // "climb" toward ground
|
|
else
|
|
dir = DIR_DIVE; // "dive" toward sky
|
|
}
|
|
redBiplaneController.state = (dir == DIR_CLIMB ? STATE_LOOPING_CLIMB : STATE_LOOPING_DIVE);
|
|
return dir;
|
|
}
|
|
return DIR_FORWARD;
|
|
|
|
case STATE_LOOPING_CLIMB:
|
|
case STATE_LOOPING_DIVE:
|
|
if ( biplane_red.bitmapIndex == 0
|
|
|| biplane_red.bitmapIndex == 8) // if back to horizontal
|
|
{
|
|
redBiplaneController.state = STATE_IN_FLIGHT; // stop looping
|
|
return DIR_FORWARD;
|
|
}
|
|
// Keep looping.
|
|
return redBiplaneController.state == STATE_LOOPING_CLIMB ? DIR_CLIMB : DIR_DIVE;
|
|
|
|
case STATE_ATTACK_CLIMB:
|
|
case STATE_ATTACK_DIVE:
|
|
{
|
|
if (redBiplaneController.numFramesBeforeStateChange > 0)
|
|
{
|
|
--redBiplaneController.numFramesBeforeStateChange;
|
|
return DIR_FORWARD;
|
|
}
|
|
// Return to horizontal.
|
|
byte newDir = redBiplaneController.state == STATE_ATTACK_CLIMB
|
|
? DIR_DIVE : DIR_CLIMB;
|
|
redBiplaneController.state = STATE_IN_FLIGHT;
|
|
return newDir;
|
|
}
|
|
|
|
default:
|
|
assert(!"Unsupported state");
|
|
}
|
|
return DIR_FORWARD;
|
|
}
|
|
|
|
|
|
BOOL
|
|
tryToShootAtSprite(Sprite *target)
|
|
{
|
|
byte bulletIndex = getFreeBulletSpotIndex(bullets_red);
|
|
if (bulletIndex != MAX_BULLETS_PER_PLANE) // if free spot found
|
|
{
|
|
// If Red is attacking, shoot automatically.
|
|
if (redBiplaneController.state == STATE_ATTACK_CLIMB
|
|
|| redBiplaneController.state == STATE_ATTACK_DIVE)
|
|
return TRUE;
|
|
|
|
// If Blue appears in front of Red, shoot.
|
|
if (isSpriteNearInFront(&biplane_red, target))
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Uses bullets_red[].
|
|
//
|
|
BOOL
|
|
isPlaneFiringAuto(Controller *controller)
|
|
{
|
|
if (controller->state == STATE_READY_FOR_TAKE_OFF)
|
|
{
|
|
// Here, "firing" is used to launch the plane.
|
|
//
|
|
if (controller->numFramesBeforeStateChange > 0)
|
|
{
|
|
--controller->numFramesBeforeStateChange;
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
if (controller->state == STATE_ON_RUNWAY)
|
|
{
|
|
// Never fire while on runway.
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
// Here, the function is for actually firing a bullet.
|
|
|
|
byte bits = (byte) numFrames & 15;
|
|
if (bits == 0 // once in a while
|
|
&& biplane_blue.active // target plane not currently exploding
|
|
&& blueBiplaneController.mover->hasStarted) // has taken off
|
|
return tryToShootAtSprite(&biplane_blue);
|
|
|
|
if (bits == 14 // once in a while
|
|
&& balloon.active // balloon not currently exploding
|
|
&& numFramesBeforeBalloonTakeOff == 0) // balloon is in flight
|
|
return tryToShootAtSprite(&balloon);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
__gcccall void
|
|
spawnPlaneIfInactive(BiplaneMover *mover, BOOL isRed)
|
|
{
|
|
if (mover->biplane->active)
|
|
return; // nothing to do
|
|
if (mover->numFramesBeforeSpawn > 0) // if still exploding
|
|
{
|
|
--mover->numFramesBeforeSpawn;
|
|
return; // keep waiting
|
|
}
|
|
|
|
// Reinitiaze the plane with the control type that it already has.
|
|
// (It was initialized by initNewGame().)
|
|
//
|
|
if (isRed)
|
|
initRedBiplane(redBiplaneController.controlType);
|
|
else
|
|
initBlueBiplane(blueBiplaneController.controlType);
|
|
}
|
|
|
|
|
|
typedef BOOL (*FireButtonPressedFuncPtr)(Controller *controller);
|
|
|
|
|
|
BOOL
|
|
isPlaneFiring(Controller *controller)
|
|
{
|
|
if (controller->controlType == AUTOMATIC_CONTROLLER)
|
|
return isPlaneFiringAuto(controller);
|
|
if (controller->controlType == JOYSTICK_CONTROLLER)
|
|
return (joystickButtonPreviousStates & controller->joyButtonMask) != 0
|
|
&& (joystickButtonStates & controller->joyButtonMask) == 0;
|
|
return KeyState_update(&controller->fireKeyState);
|
|
}
|
|
|
|
|
|
// Returns true if the plane has just been started.
|
|
//
|
|
BOOL
|
|
checkIfStartingPlane(BiplaneMover *mover,
|
|
Controller *controller)
|
|
{
|
|
if (!mover->hasStarted && isPlaneFiring(controller))
|
|
{
|
|
mover->speed = MAX_SPEED_256THS;
|
|
mover->hasStarted = TRUE;
|
|
gameStarted = TRUE;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void
|
|
movePlane(Controller *controller, Score *otherPlane)
|
|
{
|
|
BiplaneMover *mover = controller->mover;
|
|
if (BiplaneMover_move(mover))
|
|
{
|
|
Controller_onBiplaneExplosion(controller);
|
|
startExplosion(mover->biplane);
|
|
mover->numFramesBeforeSpawn = FRAMES_PER_EXPLOSION;
|
|
Score_addPoint(otherPlane);
|
|
}
|
|
}
|
|
|
|
|
|
// Returns when the player has just lost the last life, or when
|
|
// the quit key has been pressed.
|
|
// Returns TRUE if the game is over, FALSE if the player requests a pause.
|
|
//
|
|
BOOL
|
|
doMainGameLoop(void)
|
|
{
|
|
for (;;) // main game loop
|
|
{
|
|
++numFrames;
|
|
|
|
cleanWritablePage();
|
|
drawInWritablePage();
|
|
flipDisplayedBuffer(); // waits for v-sync then changes visible graphics page
|
|
|
|
// Quit the game loop if a player has won the game, and the last explosion has finished.
|
|
//
|
|
if (!isExplosionActive()
|
|
&& (Score_isWinningScore(&redScore) || Score_isWinningScore(&blueScore)))
|
|
return TRUE;
|
|
|
|
if (blueBiplaneController.controlType == JOYSTICK_CONTROLLER
|
|
|| redBiplaneController.controlType == JOYSTICK_CONTROLLER)
|
|
updateJoysticks();
|
|
|
|
checkForMute();
|
|
|
|
// If a plane is inactive, its explosion is still going on.
|
|
// When that explosion has finished, i.e., when the numFramesBeforeSpawn field
|
|
// has gone to 0, respawn the plane.
|
|
//
|
|
spawnPlaneIfInactive(&redBiplaneMover, TRUE);
|
|
spawnPlaneIfInactive(&blueBiplaneMover, FALSE);
|
|
|
|
// Check if a plane has not started yet but its player wants to start it now.
|
|
//
|
|
BOOL redJustStarted = checkIfStartingPlane(&redBiplaneMover, &redBiplaneController);
|
|
BOOL blueJustStarted = checkIfStartingPlane(&blueBiplaneMover, &blueBiplaneController);
|
|
|
|
if (redJustStarted)
|
|
{
|
|
redBiplaneController.state = STATE_ON_RUNWAY;
|
|
redBiplaneController.numFramesBeforeStateChange = rnd(1, 10); // duration before first climb
|
|
}
|
|
|
|
if (redBiplaneMover.hasStarted || blueBiplaneMover.hasStarted)
|
|
{
|
|
assert(gameStarted);
|
|
|
|
detectCollisions();
|
|
|
|
if ((byte) numFrames & 1) // each plane is allowed to move every 2 frames
|
|
movePlane(&redBiplaneController, &blueScore);
|
|
else
|
|
movePlane(&blueBiplaneController, &redScore);
|
|
|
|
// Check if planes want to fire.
|
|
// Do not allow a plane to fire if it has just started.
|
|
// (Otherwise, plane would fire immediately as it starts.)
|
|
//
|
|
if (!redJustStarted && isPlaneFiring(&redBiplaneController))
|
|
fireBullet(&biplane_red, bullets_red);
|
|
if (!blueJustStarted && isPlaneFiring(&blueBiplaneController))
|
|
fireBullet(&biplane_blue, bullets_blue);
|
|
}
|
|
|
|
animateBullets();
|
|
animateExplosions();
|
|
animateBalloon();
|
|
animateClouds();
|
|
|
|
if (checkForKey(KEY_PROBE_BREAK, KEY_BIT_BREAK)) // if player requests pause
|
|
return FALSE; // pause now
|
|
}
|
|
}
|
|
|
|
|
|
#if SEED_FROM_USER
|
|
|
|
|
|
byte
|
|
pollKeyboard(void *)
|
|
{
|
|
return Keyboard_poll(&keyboard);
|
|
}
|
|
|
|
|
|
word
|
|
getTimerWord(void *)
|
|
{
|
|
return timer;
|
|
}
|
|
|
|
|
|
void
|
|
askForRNGSeed(void)
|
|
{
|
|
Keyboard_init(&keyboard);
|
|
moveCursor(0, 0);
|
|
printf("SEED? ");
|
|
char response[6];
|
|
readLineFromKeyboard(pollKeyboard, NULL, 30, getTimerWord, response, sizeof(response));
|
|
srand(response[0] == '\0' ? timer : (word) atoul(response));
|
|
}
|
|
|
|
|
|
#endif /* def SEED_FROM_USER */
|
|
|
|
|
|
enum
|
|
{
|
|
BLK = COCO3_FIRST_CODE_MMU_BLOCK, // abbreviation
|
|
};
|
|
|
|
|
|
// Routine that restore all-RAM mode, then reexecutes the program.
|
|
// This is to be run upon a Reset.
|
|
// See the code at $A017 in Color Basic.
|
|
// Will be copied to address WARM_START_ENTRY_POINT.
|
|
// Must end before address COCO12_INTR_VECTORS.
|
|
//
|
|
// The writes to $FFAx are for a CoCo 3 (see loader.c).
|
|
// They do nothing on a CoCo 1 and 2.
|
|
//
|
|
static byte warmStartRoutine[] =
|
|
{
|
|
0x12, // NOP: required for this to be a warm start routine
|
|
0x7F, 0xFF, 0xDF, // CLR >$FFDF (put CoCo in all-RAM mode)
|
|
0xCC, BLK+0, BLK+1, // LDD #$3031 (tune in the 6 MMU blocks that contain the code)
|
|
0xFD, 0xFF, 0xA2, // STD $FFA2
|
|
0xCC, BLK+2, BLK+3, // LDD #$3233
|
|
0xFD, 0xFF, 0xA4, // STD $FFA4
|
|
0xCC, BLK+4, BLK+5, // LDD #$3435
|
|
0xFD, 0xFF, 0xA6, // STD $FFA6
|
|
0x10, 0xCE, STACK_BOTTOM/256, STACK_BOTTOM%256, // LDS #STACK_BOTTOM
|
|
0x7E, 0x00, 0x00, // JMP >mainWithNewStackSpace (address to be determined at run time)
|
|
};
|
|
|
|
|
|
// Write a warm start routine in the first half of the 64k addressable space,
|
|
// since this half is always RAM.
|
|
// The second half gets reverted to ROM by the Reset button.
|
|
// See the code at $A017 in Color Basic.
|
|
//
|
|
void
|
|
prepareWarmStartRoutine(void)
|
|
{
|
|
// Don't override CoCo 1/2 interrupt vectors.
|
|
assert(WARM_START_ENTRY_POINT + ARRAY_SIZE(warmStartRoutine) <= COCO12_INTR_VECTORS);
|
|
|
|
* (byte *) RSTFLG = 0x55; // make Reset button do warm start instead of cold
|
|
* (void **) RSTVEC = (void *) WARM_START_ENTRY_POINT;
|
|
* (void **) (warmStartRoutine + (ARRAY_SIZE(warmStartRoutine) - 2)) =
|
|
(void *) APP_ENTRY; // replace 0x00, 0x00
|
|
memcpy(WARM_START_ENTRY_POINT, warmStartRoutine, ARRAY_SIZE(warmStartRoutine));
|
|
}
|
|
|
|
|
|
// Interrupts must be masked upon entry to this function.
|
|
//
|
|
void
|
|
mainWithNewStackSpace(void)
|
|
{
|
|
// Turn the disk motors off.
|
|
* (byte *) 0xFF40 = 0;
|
|
|
|
prepareWarmStartRoutine();
|
|
|
|
// Make 32x16 screen black in case of Reset.
|
|
// This avoids showing the screen that was left by the loader.
|
|
memset16(VIDRAM, 0x8080, 512 / 2);
|
|
|
|
// Initializations that depend on the type of CoCo (1/2 vs 3).
|
|
emulatingPMode4OnCoCo3 = (* (word *) 0xFFF8 == 0xFEF7); // using global from cardgame library
|
|
if (emulatingPMode4OnCoCo3)
|
|
{
|
|
rgb(); // Assume RGB monitor on a CoCo 3.
|
|
setColorSet = setCoCo3ColorSet;
|
|
}
|
|
else
|
|
{
|
|
setColorSet = setCoCo12ColorSet;
|
|
}
|
|
|
|
setupIRQService();
|
|
|
|
// Enable the V-Sync IRQ interrupt.
|
|
// This is not necessary on the first execution of this program,
|
|
// but it is necessary after a Reset.
|
|
//
|
|
* (byte *) 0xFF03 |= 1;
|
|
|
|
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); // make printf() et al. write to screen at scrnBuffer
|
|
setInvertedColorsParameters(TRUE, TRUE);
|
|
makeSpacesTransparent(TRUE);
|
|
|
|
setWrappedPrinting(WRAPPED_TEXT_LEFT_MARGIN, BYTES_PER_SCREEN_ROW - 2); // required to use printWrapped()
|
|
|
|
#if SEED_FROM_USER
|
|
askForRNGSeed();
|
|
clearScreen(grbuf1);
|
|
#endif
|
|
|
|
writablePageIndex = 1; // for printBitmap() calls in showPresentationScreen()
|
|
|
|
byte numPlayers = 1;
|
|
byte controlType = JOYSTICK_CONTROLLER;
|
|
|
|
// Restore default value of some globals. (Needed in case of a Reset.)
|
|
gameStarted = FALSE;
|
|
bulletTimeToLive = FRAMES_PER_SHORT_RANGE_BULLET;
|
|
grPageHasStartPrompt[0] = grPageHasStartPrompt[1] = FALSE;
|
|
|
|
byte startKey = showPresentationScreen(&numPlayers, &controlType);
|
|
|
|
#if !SEED_FROM_USER
|
|
srand(timer);
|
|
#endif
|
|
|
|
writablePageIndex = 0;
|
|
setScreenBuffer2(getWritableBuffer()); // for drawChar(), printf() et al.
|
|
assert(getWritableBuffer() == scrnBuffer);
|
|
|
|
//setConsoleOutHook(beckerPortConsoleOutHook); // to debug after presentation screen
|
|
|
|
clearScreen(grbuf1);
|
|
|
|
for (;;)
|
|
{
|
|
if (startKey == ' ') // if starting game
|
|
initNewGame(numPlayers == 1 ? AUTOMATIC_CONTROLLER : controlType, controlType);
|
|
else
|
|
assert(startKey == 'R'); // resume paused game
|
|
|
|
// Useful to get stats on IRQs per flip. See also irqService().
|
|
//extern BOOL enableTraces;
|
|
//enableTraces = TRUE;
|
|
|
|
BOOL gameOver = doMainGameLoop();
|
|
|
|
// Temporarily switch writablePageIndex so that the drawSprite() call
|
|
// in printBitmap(), printf(), etc., will write to the displayed page.
|
|
//
|
|
writablePageIndex ^= 1;
|
|
setScreenBuffer2(getWritableBuffer()); // for cardgame lib
|
|
|
|
// Erase the start prompt, if any, during the pause.
|
|
//
|
|
assert(getWritableBuffer() == scrnBuffer);
|
|
|
|
if (!gameStarted && grPageHasStartPrompt[writablePageIndex])
|
|
{
|
|
eraseStartPrompt();
|
|
|
|
// grPageHasStartPrompt[writablePageIndex] is not set to FALSE here
|
|
// because both entries of that array will be set to FALSE below,
|
|
// after clearing both screens.
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
startKey = showGamePauseScreen(gameOver, &numPlayers, &controlType);
|
|
|
|
assert(startKey == 'I' || startKey == ' ' || startKey == 'R');
|
|
if (startKey == ' ')
|
|
{
|
|
if (gameOver || showNewGameConfirmDialog())
|
|
break; // confirmed
|
|
continue; // cancelled, so show pause screen again
|
|
}
|
|
if (startKey != 'I')
|
|
break;
|
|
|
|
showInstructionsScreen();
|
|
}
|
|
|
|
assert(getWritableBuffer() == scrnBuffer);
|
|
|
|
writablePageIndex ^= 1; // switch back to original page
|
|
setScreenBuffer2(getWritableBuffer()); // for cardgame lib
|
|
assert(getWritableBuffer() == scrnBuffer);
|
|
|
|
clearScreen(grbuf0);
|
|
clearScreen(grbuf1);
|
|
|
|
// Set both entries of grPageHasStartPrompt[] to FALSE
|
|
// to reflect that both screens have just been cleared.
|
|
//
|
|
grPageHasStartPrompt[0] = grPageHasStartPrompt[1] = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
// 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.
|
|
// The Basic interpreter must be assumed to be totally absent.
|
|
//
|
|
int
|
|
main()
|
|
{
|
|
asm
|
|
{
|
|
lds #STACK_BOTTOM ; put stack space below 1st graphics buffer
|
|
lbra mainWithNewStackSpace
|
|
}
|
|
}
|