369 lines
No EOL
12 KiB
C
369 lines
No EOL
12 KiB
C
#define MAP_I 512
|
|
#define MAP_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I)
|
|
#define MAP_PLAYER_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 1)
|
|
#define MAP_ENEMY_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 2)
|
|
#define MAP_TREASURE_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 3)
|
|
#define MAP_BORDER_X_TILE TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 4)
|
|
|
|
#define FONT_BIG_I 256
|
|
|
|
void bigText(char* str, u16 x, u16 y, bool shadow){
|
|
for(u8 i = 0; i < strlen(str); i++){
|
|
if(str[i] >= 48){
|
|
VDP_setTileMapXY(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, (shadow ? 32 : 0) + FONT_BIG_I + str[i] - 48), x + i, y);
|
|
VDP_setTileMapXY(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, (shadow ? 32 : 0) + FONT_BIG_I + 16 + str[i] - 48), x + i, y + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
char scoreStr[SCORE_LENGTH];
|
|
u32 lastScore;
|
|
s16 scoreLength;
|
|
|
|
#define SCORE_X 1
|
|
#define SCORE_Y 5
|
|
|
|
#define LIFE_I (FONT_BIG_I + 64)
|
|
#define LIVES_X 38
|
|
#define LIVES_Y 5
|
|
s16 lastLives;
|
|
|
|
static void drawLives(){
|
|
VDP_clearTileMapRect(BG_A, LIVES_X, LIVES_Y, 1, 16);
|
|
for(u8 i = 0; i < (player.lives - 1); i++)
|
|
VDP_fillTileMapRectInc(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, LIFE_I + (i > 0 ? 2 : 0)), LIVES_X, LIVES_Y + i, 1, 2);
|
|
lastLives = player.lives;
|
|
}
|
|
|
|
// previous map positions: -1 means not drawn
|
|
s16 mapEnemyCol[ENEMY_COUNT], mapEnemyRow[ENEMY_COUNT];
|
|
s16 mapTreasureCol[TREASURE_COUNT], mapTreasureRow[TREASURE_COUNT];
|
|
s16 mapPlayerRow;
|
|
|
|
static void drawScore(){
|
|
if(lastScore < 10) scoreLength = 1;
|
|
else if(lastScore < 100) scoreLength = 2;
|
|
else if(lastScore < 1000) scoreLength = 3;
|
|
else if(lastScore < 10000) scoreLength = 4;
|
|
else if(lastScore < 100000) scoreLength = 5;
|
|
else if(lastScore < 1000000) scoreLength = 6;
|
|
else if(lastScore < 10000000) scoreLength = 7;
|
|
else scoreLength = 8;
|
|
uintToStr(lastScore, scoreStr, scoreLength);
|
|
bigText(scoreStr, SCORE_X, SCORE_Y, FALSE);
|
|
}
|
|
|
|
// load map when stage does so we have all enemies + player
|
|
void loadMap(){
|
|
VDP_fillTileMapRect(BG_A, MAP_TILE, MAP_X, MAP_Y, MAP_W, MAP_H);
|
|
|
|
VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 4), MAP_X, MAP_Y - 1, MAP_W, 1);
|
|
VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 5), MAP_X, MAP_Y + MAP_H, MAP_W, 1);
|
|
|
|
VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 6), MAP_X - 1, MAP_Y, 1, MAP_H);
|
|
VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 1, MAP_I + 6), MAP_X + MAP_W, MAP_Y, 1, MAP_H);
|
|
|
|
VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 7), MAP_X - 1, MAP_Y + MAP_H, 1, 1);
|
|
VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 1, MAP_I + 7), MAP_X + MAP_W, MAP_Y + MAP_H, 1, 1);
|
|
|
|
VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 0, MAP_I + 8), MAP_X - 1, MAP_Y - 1, 1, 1);
|
|
VDP_fillTileMapRect(BG_A, TILE_ATTR_FULL(PAL0, 1, 0, 1, MAP_I + 8), MAP_X + MAP_W, MAP_Y - 1, 1, 1);
|
|
|
|
for(s16 i = 0; i < ENEMY_COUNT; i++){
|
|
mapEnemyCol[i] = -1;
|
|
mapEnemyRow[i] = -1;
|
|
}
|
|
for(s16 i = 0; i < TREASURE_COUNT; i++){
|
|
mapTreasureCol[i] = -1;
|
|
mapTreasureRow[i] = -1;
|
|
}
|
|
mapPlayerRow = -1;
|
|
}
|
|
|
|
// temp arrays for new positions
|
|
s16 mapNewCol[ENEMY_COUNT], mapNewRow[ENEMY_COUNT];
|
|
s16 mapNewTreasureCol[TREASURE_COUNT], mapNewTreasureRow[TREASURE_COUNT];
|
|
|
|
static bool mapTileOccupied(s16 col, s16 row, s16 pRow){
|
|
// player always at center column
|
|
if(col == MAP_W / 2 && row == pRow) return TRUE;
|
|
for(s16 i = 0; i < ENEMY_COUNT; i++)
|
|
if(mapNewCol[i] == col && mapNewRow[i] == row) return TRUE;
|
|
for(s16 i = 0; i < TREASURE_COUNT; i++)
|
|
if(mapNewTreasureCol[i] == col && mapNewTreasureRow[i] == row) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
static void updateMap(){
|
|
// compute new player row
|
|
s16 pRow = fix32ToInt(player.pos.y) / 75;
|
|
if(pRow < 0) pRow = 0;
|
|
if(pRow >= MAP_H) pRow = MAP_H - 1;
|
|
|
|
// compute new enemy positions
|
|
for(s16 i = 0; i < ENEMY_COUNT; i++){
|
|
if(!enemies[i].active || enemies[i].image == NULL
|
|
|| enemies[i].pos.y < FIX32(0) || enemies[i].pos.y > GAME_H_F){
|
|
mapNewCol[i] = -1;
|
|
mapNewRow[i] = -1;
|
|
continue;
|
|
}
|
|
fix32 dx = getWrappedDelta(enemies[i].pos.x, player.pos.x);
|
|
s16 col = fix32ToInt(dx) / 54 + MAP_W / 2;
|
|
if(col < 0) col = 0;
|
|
if(col >= MAP_W) col = MAP_W - 1;
|
|
s16 row = fix32ToInt(enemies[i].pos.y) / 75;
|
|
if(row < 0) row = 0;
|
|
if(row >= MAP_H) row = MAP_H - 1;
|
|
mapNewCol[i] = col;
|
|
mapNewRow[i] = row;
|
|
}
|
|
|
|
// compute new treasure positions
|
|
for(s16 i = 0; i < TREASURE_COUNT; i++){
|
|
if(!treasures[i].active || treasures[i].image == NULL || treasures[i].state == TREASURE_COLLECTED){
|
|
mapNewTreasureCol[i] = -1;
|
|
mapNewTreasureRow[i] = -1;
|
|
continue;
|
|
}
|
|
fix32 dx = getWrappedDelta(treasures[i].pos.x, player.pos.x);
|
|
s16 col = fix32ToInt(dx) / 54 + MAP_W / 2;
|
|
if(col < 0) col = 0;
|
|
if(col >= MAP_W) col = MAP_W - 1;
|
|
s16 row = fix32ToInt(treasures[i].pos.y) / 75;
|
|
if(row < 0) row = 0;
|
|
if(row >= MAP_H) row = MAP_H - 1;
|
|
mapNewTreasureCol[i] = col;
|
|
mapNewTreasureRow[i] = row;
|
|
}
|
|
|
|
// clear old player tile if it moved and nothing new occupies it
|
|
if(mapPlayerRow >= 0 && mapPlayerRow != pRow)
|
|
if(!mapTileOccupied(MAP_W / 2, mapPlayerRow, pRow))
|
|
VDP_setTileMapXY(BG_A, MAP_TILE, MAP_X + MAP_W / 2, MAP_Y + mapPlayerRow);
|
|
|
|
// clear old enemy tiles that moved or disappeared
|
|
for(s16 i = 0; i < ENEMY_COUNT; i++){
|
|
if(mapEnemyCol[i] < 0) continue;
|
|
if(mapEnemyCol[i] == mapNewCol[i] && mapEnemyRow[i] == mapNewRow[i]) continue;
|
|
if(!mapTileOccupied(mapEnemyCol[i], mapEnemyRow[i], pRow))
|
|
VDP_setTileMapXY(BG_A, MAP_TILE, MAP_X + mapEnemyCol[i], MAP_Y + mapEnemyRow[i]);
|
|
}
|
|
|
|
// clear old treasure tiles that moved or disappeared
|
|
for(s16 i = 0; i < TREASURE_COUNT; i++){
|
|
if(mapTreasureCol[i] < 0) continue;
|
|
if(mapTreasureCol[i] == mapNewTreasureCol[i] && mapTreasureRow[i] == mapNewTreasureRow[i]) continue;
|
|
if(!mapTileOccupied(mapTreasureCol[i], mapTreasureRow[i], pRow))
|
|
VDP_setTileMapXY(BG_A, MAP_TILE, MAP_X + mapTreasureCol[i], MAP_Y + mapTreasureRow[i]);
|
|
}
|
|
|
|
// draw treasure dots (skip if player occupies same tile)
|
|
for(s16 i = 0; i < TREASURE_COUNT; i++){
|
|
mapTreasureCol[i] = mapNewTreasureCol[i];
|
|
mapTreasureRow[i] = mapNewTreasureRow[i];
|
|
if(mapNewTreasureCol[i] < 0) continue;
|
|
if(mapNewTreasureCol[i] == MAP_W / 2 && mapNewTreasureRow[i] == pRow) continue;
|
|
VDP_setTileMapXY(BG_A, MAP_TREASURE_TILE, MAP_X + mapNewTreasureCol[i], MAP_Y + mapNewTreasureRow[i]);
|
|
}
|
|
|
|
// draw enemy dots (skip if player occupies same tile)
|
|
for(s16 i = 0; i < ENEMY_COUNT; i++){
|
|
mapEnemyCol[i] = mapNewCol[i];
|
|
mapEnemyRow[i] = mapNewRow[i];
|
|
if(mapNewCol[i] < 0) continue;
|
|
if(mapNewCol[i] == MAP_W / 2 && mapNewRow[i] == pRow) continue;
|
|
VDP_setTileMapXY(BG_A, MAP_ENEMY_TILE, MAP_X + mapNewCol[i], MAP_Y + mapNewRow[i]);
|
|
}
|
|
|
|
// draw player dot on top
|
|
mapPlayerRow = pRow;
|
|
VDP_setTileMapXY(BG_A, MAP_PLAYER_TILE, MAP_X + MAP_W / 2, MAP_Y + pRow);
|
|
}
|
|
|
|
u8 phraseIndex[4];
|
|
|
|
s16 lastLevel;
|
|
static void drawLevel(){
|
|
char lvlStr[4];
|
|
uintToStr(level + 1, lvlStr, 1);
|
|
VDP_drawText("LVL", 1, 8);
|
|
VDP_drawText(lvlStr, 4, 8);
|
|
lastLevel = level;
|
|
}
|
|
|
|
void loadChrome(){
|
|
VDP_loadTileSet(imageFontBig.tileset, FONT_BIG_I, DMA);
|
|
VDP_loadTileSet(imageFontBigShadow.tileset, FONT_BIG_I + 32, DMA);
|
|
VDP_loadTileSet(imageChromeLife.tileset, LIFE_I, DMA);
|
|
VDP_loadTileSet(imageChromeLife2.tileset, LIFE_I + 2, DMA);
|
|
VDP_loadTileSet(mapIndicator.tileset, MAP_I, DMA);
|
|
lastScore = 1;
|
|
drawScore();
|
|
drawLives();
|
|
drawLevel();
|
|
}
|
|
|
|
bool didGameOver;
|
|
u32 gameOverClock;
|
|
static void doGameOver(){
|
|
didGameOver = TRUE;
|
|
for(s16 i = 0; i < BULLET_COUNT; i++) if(bullets[i].active) SPR_setPalette(bullets[i].image, PAL1);
|
|
for(s16 i = 0; i < ENEMY_COUNT; i++) if(enemies[i].active) SPR_setPalette(enemies[i].image, PAL1);
|
|
for(s16 i = 0; i < TREASURE_COUNT; i++) if(treasures[i].active){
|
|
if(treasures[i].state == TREASURE_COLLECTED){
|
|
// spawn player bullet explosion at carried treasure position
|
|
struct bulletSpawner spawner = {
|
|
.x = treasures[i].pos.x, .y = treasures[i].pos.y,
|
|
.anim = 0, .speed = 0, .angle = 0, .player = TRUE
|
|
};
|
|
void noop(s16 j){ (void)j; }
|
|
spawnBullet(spawner, noop);
|
|
for(s16 j = BULLET_COUNT - 1; j >= 0; j--){
|
|
if(bullets[j].active && !bullets[j].explosion
|
|
&& bullets[j].pos.x == treasures[i].pos.x && bullets[j].pos.y == treasures[i].pos.y){
|
|
killBullet(j, TRUE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
killTreasure(i);
|
|
}
|
|
SPR_releaseSprite(player.image);
|
|
|
|
// clear lives
|
|
VDP_clearTileMapRect(BG_A, LIVES_X, LIVES_Y, 1, 16);
|
|
|
|
// clear messages
|
|
treasureCollectedClock = 0;
|
|
allTreasureCollected = FALSE;
|
|
hitMessageClock = 0;
|
|
VDP_clearText(9, 5, 22);
|
|
|
|
VDP_drawText("GAME OVER", 15, 13);
|
|
VDP_drawText("PRESS ANY BUTTON", 12, 14);
|
|
}
|
|
|
|
static void showPause(){
|
|
for(s16 i = 0; i < BULLET_COUNT; i++) if(bullets[i].active) SPR_setPalette(bullets[i].image, PAL1);
|
|
for(s16 i = 0; i < ENEMY_COUNT; i++) if(enemies[i].active) SPR_setPalette(enemies[i].image, PAL1);
|
|
for(s16 i = 0; i < TREASURE_COUNT; i++) if(treasures[i].active) SPR_setPalette(treasures[i].image, PAL1);
|
|
SPR_setPalette(player.image, PAL1);
|
|
XGM2_pause();
|
|
VDP_drawText("PAUSE", 17, 13);
|
|
}
|
|
|
|
static void clearPause(){
|
|
for(s16 i = 0; i < BULLET_COUNT; i++) if(bullets[i].active) SPR_setPalette(bullets[i].image, PAL0);
|
|
for(s16 i = 0; i < ENEMY_COUNT; i++) if(enemies[i].active) SPR_setPalette(enemies[i].image, PAL0);
|
|
for(s16 i = 0; i < TREASURE_COUNT; i++) if(treasures[i].active) SPR_setPalette(treasures[i].image, PAL0);
|
|
SPR_setPalette(player.image, PAL0);
|
|
XGM2_resume();
|
|
VDP_clearText(17, 13, 5);
|
|
}
|
|
|
|
u32 pauseClock;
|
|
static void updatePause(){
|
|
if(gameOver) return;
|
|
if(ctrl.start){
|
|
if(!isPausing){
|
|
isPausing = TRUE;
|
|
if(!paused){
|
|
pauseClock = 0;
|
|
paused = TRUE;
|
|
showPause();
|
|
} else {
|
|
paused = FALSE;
|
|
clearPause();
|
|
}
|
|
}
|
|
} else {
|
|
isPausing = FALSE;
|
|
}
|
|
if(paused){
|
|
if(pauseClock % 60 < 30)
|
|
VDP_drawText("PAUSE", 17, 13);
|
|
else
|
|
VDP_clearText(17, 13, 5);
|
|
pauseClock++;
|
|
if(pauseClock >= 240) pauseClock = 0;
|
|
}
|
|
}
|
|
|
|
void updateChrome(){
|
|
updatePause();
|
|
if(gameOver && !didGameOver) doGameOver();
|
|
if(didGameOver){
|
|
gameOverClock++;
|
|
if((gameOverClock > 120 && (ctrl.a || ctrl.b || ctrl.c || ctrl.start)) || gameOverClock > 900)
|
|
SYS_hardReset();
|
|
return;
|
|
}
|
|
// level transition overlay
|
|
if(levelClearing){
|
|
if(levelClearClock == 2){
|
|
char lvlStr[4];
|
|
uintToStr(level + 2, lvlStr, 1);
|
|
VDP_drawText("LEVEL ", 15, 13);
|
|
VDP_drawText(lvlStr, 21, 13);
|
|
}
|
|
if(levelClearClock >= 110){
|
|
VDP_clearText(15, 13, 10);
|
|
}
|
|
return;
|
|
}
|
|
if(lastScore != score){
|
|
lastScore = score;
|
|
drawScore();
|
|
}
|
|
if(lastLives != player.lives) drawLives();
|
|
if(lastLevel != level) drawLevel();
|
|
if(treasureCollectedClock > 0 && levelWaitClock == 0){
|
|
if(treasureCollectedClock == 120){
|
|
VDP_clearText(10, 5, 22);
|
|
const char* mirrorPhrases[] = {"REFLECT THE DEPTHS", "DIG DEEPER WITHIN", "SEE WHAT SHINES BELOW", "MIRROR OF THE MINE", "LOOK BACK STRIKE BACK"};
|
|
const char* lampPhrases[] = {"STRIKE LIGHT", "LET THERE BE LODE", "BRIGHT IDEA DEEP DOWN", "ILLUMINATE THE VEIN", "GLOW FROM BELOW"};
|
|
const char* scarfPhrases[] = {"COZY IN THE CAVES", "WRAP THE UNDERWORLD", "SNUG AS BEDROCK", "STYLE FROM THE STRATA", "WARM THE DEPTHS"};
|
|
const char* swordPhrases[] = {"ORE YOU READY", "MINED YOUR STEP", "CUTTING EDGE GEOLOGY", "STRIKE THE VEIN", "SPIRIT STEEL"};
|
|
const char** sets[] = {mirrorPhrases, lampPhrases, scarfPhrases, swordPhrases};
|
|
const char* phrase = sets[treasureCollectedType][phraseIndex[treasureCollectedType]];
|
|
phraseIndex[treasureCollectedType] = (phraseIndex[treasureCollectedType] + 1) % 5;
|
|
u8 len = strlen(phrase);
|
|
VDP_drawText(phrase, 20 - len / 2, 5);
|
|
}
|
|
treasureCollectedClock--;
|
|
if(treasureCollectedClock == 0){
|
|
VDP_clearText(10, 5, 22);
|
|
// check if all treasures are collected or gone
|
|
bool allDone = TRUE;
|
|
for(s16 j = 0; j < TREASURE_COUNT; j++){
|
|
if(treasures[j].active && treasures[j].state != TREASURE_COLLECTED){
|
|
allDone = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
if(allDone && collectedCount > 0){
|
|
allTreasureCollected = TRUE;
|
|
VDP_drawText("ALL TREASURE COLLECTED", 9, 5);
|
|
}
|
|
}
|
|
}
|
|
if(hitMessageClock > 0){
|
|
if(hitMessageClock == 120){
|
|
VDP_clearText(9, 5, 22);
|
|
treasureCollectedClock = 0;
|
|
allTreasureCollected = FALSE;
|
|
VDP_drawText(hitMessageBullet ? "BLASTED" : "SMASHED", hitMessageBullet ? 16 : 16, 5);
|
|
}
|
|
hitMessageClock--;
|
|
if(hitMessageClock == 0)
|
|
VDP_clearText(9, 5, 22);
|
|
}
|
|
if(levelWaitClock == 240){
|
|
VDP_clearText(9, 5, 22);
|
|
treasureCollectedClock = 0;
|
|
allTreasureCollected = FALSE;
|
|
VDP_drawText("ALL ENEMIES DESTROYED", 9, 5);
|
|
}
|
|
if(clock % 4 == 0) updateMap();
|
|
} |