Apple-2-SW/BuGS
1
0
Fork 0
mirror of https://github.com/jeremysrand/BuGS.git synced 2025-02-07 13:30:56 +00:00
Code Issues Projects Releases Wiki Activity

Change from an array of structs to a series of individual arrays for the tile information. This makes it easier to index into the arrays because the tile number * 2 is the offset, rather than tile number * 16.

Browse Source
This commit is contained in:
Jeremy Rand 2020-09-02 00:15:53 -04:00
parent df56cdecf1
commit b07221c363
11 changed files with 247 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
BuGS/game.s
View File

@ -31,11 +31,22 @@ game start
gameLoop anop
jsl drawDirtyGameTiles
short i,m
lda >BORDER_COLOUR_REGISTER
and #$f7
sta >BORDER_COLOUR_REGISTER
long i,m
jsl drawSpider
short i,m
lda >BORDER_COLOUR_REGISTER
and #$f3
sta >BORDER_COLOUR_REGISTER
long i,m
jsl drawScorpion
jsl drawFlea
jsl drawSegments
jsl drawDirtyNonGameTiles
short i,m
lda >BORDER_COLOUR_REGISTER
@ -43,6 +54,30 @@ gameLoop anop
sta >BORDER_COLOUR_REGISTER
long i,m
jsl drawFlea
short i,m
lda >BORDER_COLOUR_REGISTER
ora #$08
sta >BORDER_COLOUR_REGISTER
long i,m
jsl drawSegments
short i,m
lda >BORDER_COLOUR_REGISTER
ora #$04
sta >BORDER_COLOUR_REGISTER
long i,m
jsl drawDirtyNonGameTiles
short i,m
lda >BORDER_COLOUR_REGISTER
ora #$02
sta >BORDER_COLOUR_REGISTER
long i,m
jsl updateScorpion
jsl updateSpider
jsl updateFlea
@ -52,8 +87,10 @@ gameLoop anop
jsl waitForVbl
lda shouldQuit
bne gameLoop
beq gameDone
jmp gameLoop
gameDone anop
short i,m
lda >BORDER_COLOUR_REGISTER
and #$f0
@ -73,9 +110,9 @@ dirtyTileLoop anop
phy
ldx dirtyGameTiles,y
stz tiles+TILE_DIRTY_OFFSET,x
ldy tiles+TILE_SCREEN_OFFSET_OFFSET,x
lda tiles+TILE_TYPE_OFFSET,x
stz tileDirty,x
ldy tileOffset,x
lda tileType,x
jsl drawTile
@ -95,9 +132,9 @@ dirtyTileLoop2 anop
phy
ldx dirtyNonGameTiles,y
stz tiles+TILE_DIRTY_OFFSET,x
ldy tiles+TILE_SCREEN_OFFSET_OFFSET,x
lda tiles+TILE_TYPE_OFFSET,x
stz tileDirty,x
ldy tileOffset,x
lda tileType,x
jsl drawTile

15
BuGS/gameFlea.s
View File

@ -117,25 +117,25 @@ updateFlea_nextTile anop
ldx fleaTileOffsets
stx fleaTileOffsets+4
lda tiles+TILE_BELOW_OFFSET,x
lda tileBelow,x
cmp #INVALID_TILE_NUM
beq updateFlea_bottom
sta fleaTileOffsets
ldx fleaTileOffsets+2
stx fleaTileOffsets+6
lda tiles+TILE_BELOW_OFFSET,x
lda tileBelow,x
sta fleaTileOffsets+2
ldx fleaTileOffsets+4
lda tiles+TILE_TYPE_OFFSET,x
lda tileType,x
bne updateFlea_nextAction
jsl rand0_to_65534
and #$3
bne updateFlea_nextAction
lda #TILE_MUSHROOM4
sta tiles+TILE_TYPE_OFFSET,x
sta tileType,x
bra updateFlea_nextAction
@ -174,18 +174,15 @@ addFlea entry
jsl rand25
asl a
asl a
asl a
asl a
sta fleaTileOffsets
sta fleaTileOffsets+4
tax
lda tiles+TILE_LEFT_OFFSET,x
lda tileLeft,x
sta fleaTileOffsets+2
sta fleaTileOffsets+6
lda tiles+TILE_SCREEN_OFFSET_OFFSET,x
lda tileOffset,x
sec
sbc #6*SCREEN_BYTES_PER_ROW+3
sta fleaScreenOffset

20
BuGS/gameScorpion.s
View File

@ -149,7 +149,7 @@ updateScorpionLeft_nextTile anop
stx scorpionTileOffsets+4
ldx scorpionTileOffsets
stx scorpionTileOffsets+2
lda tiles+TILE_LEFT_OFFSET,x
lda tileLeft,x
sta scorpionTileOffsets
bra updateScorpion_maybePoison
@ -157,17 +157,17 @@ updateScorpionRight_notOffScreen anop
stx scorpionTileOffsets+4
ldx scorpionTileOffsets
stx scorpionTileOffsets+2
lda tiles+TILE_RIGHT_OFFSET,x
lda tileRight,x
sta scorpionTileOffsets
updateScorpion_maybePoison anop
lda tiles+TILE_TYPE_OFFSET,x
lda tileType,x
beq updateScorpion_done
cmp #TILE_MUSHROOM4+1
bge updateScorpion_done
ora #TILE_POISON_A_MUSHROOM
sta tiles+TILE_TYPE_OFFSET,x
sta tileType,x
updateScorpion_done anop
rtl
@ -253,15 +253,15 @@ addScorpion_doit anop
ldx scorpionLeftTileOffset,y
stx scorpionTileOffsets
lda tiles+TILE_SCREEN_OFFSET_OFFSET,x
lda tileOffset,x
dec a
sta scorpionScreenOffset
lda tiles+TILE_RIGHT_OFFSET,x
lda tileRight,x
sta scorpionTileOffsets+2
tax
lda tiles+TILE_RIGHT_OFFSET,x
lda tileRight,x
sta scorpionTileOffsets+4
bra addScorpion_common
@ -274,15 +274,15 @@ addScorpion_right anop
ldx scorpionRightTileOffset,y
stx scorpionTileOffsets
lda tiles+TILE_LEFT_OFFSET,x
lda tileLeft,x
sta scorpionTileOffsets+2
tax
lda tiles+TILE_LEFT_OFFSET,x
lda tileLeft,x
sta scorpionTileOffsets+4
tax
lda tiles+TILE_SCREEN_OFFSET_OFFSET,x
lda tileOffset,x
dec a
dec a
sta scorpionScreenOffset

40
BuGS/gameSegments.s
View File

@ -161,13 +161,7 @@ addBodySegment entry
lda #SEGMENT_FACING_LEFT
sta segmentFacing,x
txa
asl a
asl a
asl a
tay
lda tiles+TILE_SCREEN_OFFSET_OFFSET,y
lda tileOffset,x
sec
sbc #3
sta segmentScreenOffsets,x
@ -177,13 +171,13 @@ addBodySegment entry
txa
asl a
asl a
tax
tay
tya
sta segmentTileOffsets,x
sta segmentTileOffsets+2,x
sta segmentTileOffsets+4,x
sta segmentTileOffsets+6,x
txa
sta segmentTileOffsets,y
sta segmentTileOffsets+2,y
sta segmentTileOffsets+4,y
sta segmentTileOffsets+6,y
inc numSegments
@ -204,13 +198,7 @@ addHeadSegment entry
lda #SEGMENT_FACING_LEFT
sta segmentFacing,x
txa
asl a
asl a
asl a
tay
lda tiles+TILE_SCREEN_OFFSET_OFFSET,y
lda tileOffset,x
sec
sbc #3
sta segmentScreenOffsets,x
@ -220,13 +208,13 @@ addHeadSegment entry
txa
asl a
asl a
tax
tay
tya
sta segmentTileOffsets,x
sta segmentTileOffsets+2,x
sta segmentTileOffsets+4,x
sta segmentTileOffsets+6,x
txa
sta segmentTileOffsets,y
sta segmentTileOffsets+2,y
sta segmentTileOffsets+4,y
sta segmentTileOffsets+6,y
inc numSegments

52
BuGS/gameSpider.s
View File

@ -337,12 +337,12 @@ updateSpider_tilesRight_cont anop
ldx spiderTileOffsets+2
stx spiderTileOffsets+6
lda tiles+TILE_RIGHT_OFFSET,x
lda tileRight,x
sta spiderTileOffsets+2
ldx spiderTileOffsets
stx spiderTileOffsets+4
lda tiles+TILE_RIGHT_OFFSET,x
lda tileRight,x
sta spiderTileOffsets
rtl
@ -359,12 +359,12 @@ updateSpider_tilesLeft_cont anop
ldx spiderTileOffsets+10
stx spiderTileOffsets+6
lda tiles+TILE_LEFT_OFFSET,x
lda tileLeft,x
sta spiderTileOffsets+10
ldx spiderTileOffsets+8
stx spiderTileOffsets+4
lda tiles+TILE_LEFT_OFFSET,x
lda tileLeft,x
sta spiderTileOffsets+8
rtl
@ -381,26 +381,26 @@ updateSpider_tilesUp anop
ldx spiderTileOffsets+2
stx spiderTileOffsets
lda tiles+TILE_ABOVE_OFFSET,x
lda tileAbove,x
sta spiderTileOffsets+2
ldx spiderTileOffsets+6
stx spiderTileOffsets+4
lda tiles+TILE_ABOVE_OFFSET,x
lda tileAbove,x
sta spiderTileOffsets+6
; As per the below, clear any mushroom if present
cpx #RHS_FIRST_TILE_OFFSET
bge updateSpider_tilesUpCont
lda tiles+TILE_TYPE_OFFSET,x
lda tileType,x
beq updateSpider_tilesUpCont
lda #TILE_EMPTY
sta tiles+TILE_TYPE_OFFSET,x
sta tileType,x
updateSpider_tilesUpCont anop
ldx spiderTileOffsets+10
stx spiderTileOffsets+8
lda tiles+TILE_ABOVE_OFFSET,x
lda tileAbove,x
sta spiderTileOffsets+10
rtl
@ -452,27 +452,27 @@ updateSpider_tilesDown anop
ldx spiderTileOffsets
stx spiderTileOffsets+2
lda tiles+TILE_BELOW_OFFSET,x
lda tileBelow,x
sta spiderTileOffsets
ldx spiderTileOffsets+4
stx spiderTileOffsets+6
lda tiles+TILE_BELOW_OFFSET,x
lda tileBelow,x
sta spiderTileOffsets+4
; If the middle tile is a game time and it isn't empty, then
; empty it. Spiders "consume" mushrooms as they pass over them.
cpx #RHS_FIRST_TILE_OFFSET
bge updateSpider_tilesDownCont
lda tiles+TILE_TYPE_OFFSET,x
lda tileType,x
beq updateSpider_tilesDownCont
lda #TILE_EMPTY
sta tiles+TILE_TYPE_OFFSET,x
sta tileType,x
updateSpider_tilesDownCont anop
ldx spiderTileOffsets+8
stx spiderTileOffsets+10
lda tiles+TILE_BELOW_OFFSET,x
lda tileBelow,x
sta spiderTileOffsets+8
rtl
@ -556,26 +556,26 @@ addSpider_left anop
ldx #SPIDER_RHS_TILE_OFFSET
stx spiderTileOffsets+8
lda tiles+TILE_ABOVE_OFFSET,x
lda tileAbove,x
sta spiderTileOffsets+10
lda tiles+TILE_RIGHT_OFFSET,x
lda tileRight,x
sta spiderTileOffsets+4
tax
lda tiles+TILE_SCREEN_OFFSET_OFFSET,x
lda tileOffset,x
sec
sbc #SPIDER_RHS_STARTING_SCREEN_OFFSET
sta spiderScreenOffset
lda tiles+TILE_ABOVE_OFFSET,x
lda tileAbove,x
sta spiderTileOffsets+6
lda tiles+TILE_RIGHT_OFFSET,x
lda tileRight,x
sta spiderTileOffsets
tax
lda tiles+TILE_ABOVE_OFFSET,x
lda tileAbove,x
sta spiderTileOffsets+2
rtl
@ -590,26 +590,26 @@ addSpider_right anop
ldx #SPIDER_LHS_TILE_OFFSET
stx spiderTileOffsets
lda tiles+TILE_ABOVE_OFFSET,x
lda tileAbove,x
sta spiderTileOffsets+2
lda tiles+TILE_LEFT_OFFSET,x
lda tileLeft,x
sta spiderTileOffsets+4
tax
lda tiles+TILE_SCREEN_OFFSET_OFFSET,x
lda tileOffset,x
sec
sbc #SPIDER_LHS_STARTING_SCREEN_OFFSET
sta spiderScreenOffset
lda tiles+TILE_ABOVE_OFFSET,x
lda tileAbove,x
sta spiderTileOffsets+6
lda tiles+TILE_LEFT_OFFSET,x
lda tileLeft,x
sta spiderTileOffsets+8
tax
lda tiles+TILE_ABOVE_OFFSET,x
lda tileAbove,x
sta spiderTileOffsets+10
rtl

12
BuGS/global.macros
View File

@ -13,10 +13,10 @@
_dirtyGameTile &tileOffset
ldx &tileOffset,y
lda tiles+TILE_DIRTY_OFFSET,x
lda tileDirty,x
bne _dirtyGameTile_skip&SYSCNT
lda #TILE_STATE_DIRTY
sta tiles+TILE_DIRTY_OFFSET,x
sta tileDirty,x
txa
ldx numDirtyGameTiles
sta dirtyGameTiles,x
@ -35,10 +35,10 @@ _dirtyGameTile_skip&SYSCNT anop
_dirtyGameTileWithY &tileOffset
ldx &tileOffset
lda tiles+TILE_DIRTY_OFFSET,x
lda tileDirty,x
bne _dirtyGameTileWithY_skip&SYSCNT
lda #TILE_STATE_DIRTY
sta tiles+TILE_DIRTY_OFFSET,x
sta tileDirty,x
txa
sta dirtyGameTiles,y
iny
@ -52,10 +52,10 @@ _dirtyGameTileWithY_skip&SYSCNT anop
_dirtyGameOrNonGameTile &tileOffset
ldx &tileOffset
lda tiles+TILE_DIRTY_OFFSET,x
lda tileDirty,x
bne _dirtyGameTile_skip&SYSCNT
lda #TILE_STATE_DIRTY
sta tiles+TILE_DIRTY_OFFSET,x
sta tileDirty,x
txa
cmp #RHS_FIRST_TILE_OFFSET
bge _dirtyGameTile_nonGame&SYSCNT

10
BuGS/globals.s
View File

@ -18,7 +18,7 @@ globalData data
SCREEN_BYTES_PER_ROW gequ 160
SIZEOF_TILE_INFO gequ 16
SIZEOF_TILE_INFO gequ 2
TILE_PIXEL_WIDTH gequ 8
TILE_PIXEL_HEIGHT gequ 8
@ -110,14 +110,6 @@ TILE_PLAYER gequ 52*4
TILE_POISON_A_MUSHROOM gequ TILE_POISON_MUSHROOM4-TILE_MUSHROOM4
TILE_DIRTY_OFFSET gequ 0
TILE_SCREEN_OFFSET_OFFSET gequ 2
TILE_TYPE_OFFSET gequ 4
TILE_ABOVE_OFFSET gequ 6
TILE_BELOW_OFFSET gequ 8
TILE_LEFT_OFFSET gequ 10
TILE_RIGHT_OFFSET gequ 12
NUM_COLOUR_PALETTES gequ 14
SPRITE_SPEED_SLOW gequ 0

65
BuGS/sprites/fleas.s
View File

@ -15,7 +15,7 @@ fleas start
flea1 entry
_spriteHeader
_spriteHeader ; 30
; $c - Green
; $4 - Red
@ -31,94 +31,95 @@ flea1 entry
; ....|.G.G|...G
;
lda $0,s
and #$00ff
ora #$8800
sta $0,s
lda $2,s
and #$ff0f
ora #$0080
sta $2,s
lda $0,s ; 5
and #$00ff ; 3
ora #$8800 ; 3
sta $0,s ; 5
; 46
lda $2,s ; 5
and #$ff0f ; 3
ora #$0080 ; 3
sta $2,s ; 5
; 62
lda $a0,s
and #$00f0
ora #$8804
sta $a0,s
; 78
lda $a2,s
and #$ff00
ora #$0088
sta $a2,s
tsc
adc #$0141
tcs
pea $8844
; 94
tsc ; 2
adc #$0141 ; 3
tcs ; 2
; 101
pea $8844 ; 5
lda $3,s
and #$0f00
ora #$8088
sta $3,s
; 122
lda $9f,s
and #$f0ff
ora #$0800
sta $9f,s
; 138
tsc
adc #$00a4
tcs
pea $8888
pea $8888
; 155
lda $9f,s
and #$f0ff
ora #$0800
sta $9f,s
; 171
lda $a1,s
and #$0f00
ora #$c088
sta $a1,s
; 187
tsc
adc #$00a4
tcs
pea $88c8
; 199
lda $9f,s
ora #$c000
sta $9f,s
; 212
lda $a1,s
and #$000f
ora #$88c0
sta $a1,s
; 228
tsc
adc #$013e
tcs
; 235
lda $1,s
ora #$c000
sta $1,s
; 248
lda $3,s
ora #$c0c0
sta $3,s
; 261
lda $a1,s
ora #$0c0c
sta $a1,s
; 274
lda $a3,s
ora #$0c00
sta $a3,s
; 287
_spriteFooter
; 311 cycles
rtl
flea2 entry
_spriteHeader

36
BuGS/sprites/sprites.macros
View File

@ -8,28 +8,28 @@
macro
_spriteHeader
sei
tsc
sta backupStack
lda >STATE_REGISTER ; Direct Page and Stack in Bank 01/
ora #$0030
sta >STATE_REGISTER
clc
tya
tcs
mend
sei ; 2
tsc ; 2
sta backupStack ; 5
lda >STATE_REGISTER ; 6 - Direct Page and Stack in Bank 01/
ora #$0030 ; 3
sta >STATE_REGISTER ; 6
clc ; 2
tya ; 2
tcs ; 2
mend ; 30
macro
_spriteFooter
lda >STATE_REGISTER
and #$ffcf
sta >STATE_REGISTER
lda backupStack
tcs
cli
mend
lda >STATE_REGISTER ; 6
and #$ffcf ; 3
sta >STATE_REGISTER ; 6
lda backupStack ; 5
tcs ; 2
cli ; 2
mend ; 24
macro
_leftHead

154
BuGS/tiles.c
View File

@ -23,13 +23,13 @@
#define GAME_TOP_MOST_Y_POS (0 * TILE_HEIGHT)
#define GAME_X_Y_TO_TILE_OFFSET(X, Y) \
((((Y) * GAME_NUM_TILES_WIDE) + (X)) * sizeof(tTile))
((((Y) * GAME_NUM_TILES_WIDE) + (X)) * sizeof(word))
#define RHS_X_Y_TO_TILE_OFFSET(X, Y) \
((RHS_FIRST_TILE + ((Y) * RHS_NUM_TILES_WIDE) + (X)) * sizeof(tTile))
((RHS_FIRST_TILE + ((Y) * RHS_NUM_TILES_WIDE) + (X)) * sizeof(word))
#define LHS_X_Y_TO_TILE_OFFSET(X, Y) \
((LHS_FIRST_TILE + ((Y) * LHS_NUM_TILES_WIDE) + (X)) * sizeof(tTile))
((LHS_FIRST_TILE + ((Y) * LHS_NUM_TILES_WIDE) + (X)) * sizeof(word))
#define SCREEN_ADDRESS_FOR_TILE_AT_X_Y(X, Y) \
(0x2000 + (0xa0 * (Y)) + ((X) / 2) + 3)
@ -38,22 +38,28 @@
#define STARTING_NUM_PLAYERS 3
#define ADD_DIRTY_GAME_TILE(tileNum) \
if (!tiles[tileNum].dirty) { \
tiles[tileNum].dirty = 1; \
dirtyGameTiles[numDirtyGameTiles / 2] = ((tileNum) * sizeof(tTile)); \
if (!tileDirty[tileNum]) { \
tileDirty[tileNum] = 1; \
dirtyGameTiles[numDirtyGameTiles / 2] = ((tileNum) * sizeof(word)); \
numDirtyGameTiles += 2; \
}
#define ADD_DIRTY_NON_GAME_TILE(tileNum) \
if (!tiles[tileNum].dirty) { \
tiles[tileNum].dirty = 1; \
dirtyNonGameTiles[numDirtyNonGameTiles / 2] = ((tileNum) * sizeof(tTile)); \
numDirtyNonGameTiles += 2; \
#define ADD_DIRTY_NON_GAME_TILE(tileNum) \
if (!tileDirty[tileNum]) { \
tileDirty[tileNum] = 1; \
dirtyNonGameTiles[numDirtyNonGameTiles / 2] = ((tileNum) * sizeof(word)); \
numDirtyNonGameTiles += 2; \
}
/* Globals */
tTile tiles[TOTAL_NUM_TILES];
word tileDirty[TOTAL_NUM_TILES];
word tileOffset[TOTAL_NUM_TILES];
tTileType tileType[TOTAL_NUM_TILES];
tTileOffset tileAbove[TOTAL_NUM_TILES];
tTileOffset tileBelow[TOTAL_NUM_TILES];
tTileOffset tileLeft[TOTAL_NUM_TILES];
tTileOffset tileRight[TOTAL_NUM_TILES];
tTileOffset dirtyGameTiles[NUM_GAME_TILES + GAME_NUM_TILES_TALL];
word numDirtyGameTiles;
@ -71,9 +77,9 @@ void initTiles(void)
word tileX;
word tileY;
word lastOffset;
tTile * tilePtr = &(tiles[0]);
tTile * rhsTilePtr = &(tiles[RHS_FIRST_TILE]);
tTile * lhsTilePtr = &(tiles[LHS_FIRST_TILE]);
word tileIndex = 0;
word rhsTileIndex = RHS_FIRST_TILE;
word lhsTileIndex = LHS_FIRST_TILE;
for (tileY = 0; tileY < GAME_NUM_TILES_TALL; tileY++)
{
@ -81,97 +87,93 @@ void initTiles(void)
for (tileX = 0; tileX < LHS_NUM_TILES_WIDE; tileX++)
{
lhsTilePtr->dirty = 0;
lhsTilePtr->offset = lastOffset;
lhsTilePtr->type = TILE_EMPTY;
tileDirty[lhsTileIndex] = 0;
tileOffset[lhsTileIndex] = lastOffset;
tileType[lhsTileIndex] = TILE_EMPTY;
if (tileY == 0)
lhsTilePtr->tileAbove = INVALID_TILE_NUM;
tileAbove[lhsTileIndex] = INVALID_TILE_NUM;
else
lhsTilePtr->tileAbove = LHS_X_Y_TO_TILE_OFFSET(tileX, tileY - 1);
tileAbove[lhsTileIndex] = LHS_X_Y_TO_TILE_OFFSET(tileX, tileY - 1);
if (tileY == GAME_NUM_TILES_TALL - 1)
lhsTilePtr->tileBelow = INVALID_TILE_NUM;
tileBelow[lhsTileIndex] = INVALID_TILE_NUM;
else
lhsTilePtr->tileBelow = LHS_X_Y_TO_TILE_OFFSET(tileX, tileY + 1);
tileBelow[lhsTileIndex] = LHS_X_Y_TO_TILE_OFFSET(tileX, tileY + 1);
if (tileX == 0)
lhsTilePtr->tileLeft = INVALID_TILE_NUM;
tileLeft[lhsTileIndex] = INVALID_TILE_NUM;
else
lhsTilePtr->tileLeft = LHS_X_Y_TO_TILE_OFFSET(tileX - 1, tileY);
tileLeft[lhsTileIndex] = LHS_X_Y_TO_TILE_OFFSET(tileX - 1, tileY);
if (tileX == LHS_NUM_TILES_WIDE - 1)
lhsTilePtr->tileRight = GAME_X_Y_TO_TILE_OFFSET(0, tileY);
tileRight[lhsTileIndex] = GAME_X_Y_TO_TILE_OFFSET(0, tileY);
else
lhsTilePtr->tileRight = LHS_X_Y_TO_TILE_OFFSET(tileX + 1, tileY);
lhsTilePtr->dummy = 0;
tileRight[lhsTileIndex] = LHS_X_Y_TO_TILE_OFFSET(tileX + 1, tileY);
lhsTilePtr++;
lhsTileIndex++;
lastOffset += 4;
}
for (tileX = 0; tileX < GAME_NUM_TILES_WIDE; tileX++)
{
tilePtr->dirty = 0;
tilePtr->offset = lastOffset;
tilePtr->type = TILE_EMPTY;
tileDirty[tileIndex] = 0;
tileOffset[tileIndex] = lastOffset;
tileType[tileIndex] = TILE_EMPTY;
if (tileY == 0)
tilePtr->tileAbove = INVALID_TILE_NUM;
tileAbove[tileIndex] = INVALID_TILE_NUM;
else
tilePtr->tileAbove = GAME_X_Y_TO_TILE_OFFSET(tileX, tileY - 1);
tileAbove[tileIndex] = GAME_X_Y_TO_TILE_OFFSET(tileX, tileY - 1);
if (tileY == GAME_NUM_TILES_TALL - 1)
tilePtr->tileBelow = INVALID_TILE_NUM;
tileBelow[tileIndex] = INVALID_TILE_NUM;
else
tilePtr->tileBelow = GAME_X_Y_TO_TILE_OFFSET(tileX, tileY + 1);
tileBelow[tileIndex] = GAME_X_Y_TO_TILE_OFFSET(tileX, tileY + 1);
if (tileX == 0)
tilePtr->tileLeft = LHS_X_Y_TO_TILE_OFFSET(LHS_NUM_TILES_WIDE - 1, tileY);
tileLeft[tileIndex] = LHS_X_Y_TO_TILE_OFFSET(LHS_NUM_TILES_WIDE - 1, tileY);
else
tilePtr->tileLeft = GAME_X_Y_TO_TILE_OFFSET(tileX - 1, tileY);
tileLeft[tileIndex] = GAME_X_Y_TO_TILE_OFFSET(tileX - 1, tileY);
if (tileX == GAME_NUM_TILES_WIDE - 1)
tilePtr->tileRight = RHS_X_Y_TO_TILE_OFFSET(0, tileY);
tileRight[tileIndex] = RHS_X_Y_TO_TILE_OFFSET(0, tileY);
else
tilePtr->tileRight = GAME_X_Y_TO_TILE_OFFSET(tileX + 1, tileY);
tileRight[tileIndex] = GAME_X_Y_TO_TILE_OFFSET(tileX + 1, tileY);
tilePtr->dummy = 0;
tilePtr++;
tileIndex++;
lastOffset += 4;
}
for (tileX = 0; tileX < RHS_NUM_TILES_WIDE; tileX++)
{
rhsTilePtr->dirty = 0;
rhsTilePtr->offset = lastOffset;
rhsTilePtr->type = TILE_EMPTY;
tileDirty[rhsTileIndex] = 0;
tileOffset[rhsTileIndex] = lastOffset;
tileType[rhsTileIndex] = TILE_EMPTY;
if (tileY == 0)
rhsTilePtr->tileAbove = INVALID_TILE_NUM;
tileAbove[rhsTileIndex] = INVALID_TILE_NUM;
else
rhsTilePtr->tileAbove = RHS_X_Y_TO_TILE_OFFSET(tileX, tileY - 1);
tileAbove[rhsTileIndex] = RHS_X_Y_TO_TILE_OFFSET(tileX, tileY - 1);
if (tileY == GAME_NUM_TILES_TALL - 1)
rhsTilePtr->tileBelow = INVALID_TILE_NUM;
tileBelow[rhsTileIndex] = INVALID_TILE_NUM;
else
rhsTilePtr->tileBelow = RHS_X_Y_TO_TILE_OFFSET(tileX, tileY + 1);
tileBelow[rhsTileIndex] = RHS_X_Y_TO_TILE_OFFSET(tileX, tileY + 1);
if (tileX == 0)
rhsTilePtr->tileLeft = GAME_X_Y_TO_TILE_OFFSET(GAME_NUM_TILES_WIDE - 1, tileY);
tileLeft[rhsTileIndex] = GAME_X_Y_TO_TILE_OFFSET(GAME_NUM_TILES_WIDE - 1, tileY);
else
rhsTilePtr->tileLeft = RHS_X_Y_TO_TILE_OFFSET(tileX - 1, tileY);
tileLeft[rhsTileIndex] = RHS_X_Y_TO_TILE_OFFSET(tileX - 1, tileY);
if (tileX == RHS_NUM_TILES_WIDE - 1)
rhsTilePtr->tileRight = INVALID_TILE_NUM;
tileRight[rhsTileIndex] = INVALID_TILE_NUM;
else
rhsTilePtr->tileRight = RHS_X_Y_TO_TILE_OFFSET(tileX + 1, tileY);
tileRight[rhsTileIndex] = RHS_X_Y_TO_TILE_OFFSET(tileX + 1, tileY);
rhsTilePtr->dummy = 0;
rhsTilePtr++;
rhsTileIndex++;
lastOffset += 4;
}
@ -190,81 +192,81 @@ void initNonGameTiles(void)
for (i = 0; i < numPlayers; i++)
{
tileNum = RHS_FIRST_TILE + i;
tiles[tileNum].type = TILE_PLAYER;
tileType[tileNum] = TILE_PLAYER;
ADD_DIRTY_NON_GAME_TILE(tileNum);
}
tileNum = LHS_FIRST_TILE + (1 * LHS_NUM_TILES_WIDE) + 6;
tiles[tileNum].type = TILE_LETTER_S;
tileType[tileNum] = TILE_LETTER_S;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_C;
tileType[tileNum] = TILE_LETTER_C;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_O;
tileType[tileNum] = TILE_LETTER_O;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_R;
tileType[tileNum] = TILE_LETTER_R;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_E;
tileType[tileNum] = TILE_LETTER_E;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_SYMBOL_COLON;
tileType[tileNum] = TILE_SYMBOL_COLON;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum = LHS_FIRST_TILE + (4 * LHS_NUM_TILES_WIDE) - 2;
tiles[tileNum].type = TILE_NUMBER_0;
tileType[tileNum] = TILE_NUMBER_0;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum = LHS_FIRST_TILE + (12 * LHS_NUM_TILES_WIDE) + 1;
tiles[tileNum].type = TILE_LETTER_H;
tileType[tileNum] = TILE_LETTER_H;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_I;
tileType[tileNum] = TILE_LETTER_I;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_G;
tileType[tileNum] = TILE_LETTER_G;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_H;
tileType[tileNum] = TILE_LETTER_H;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tileNum++;
tiles[tileNum].type = TILE_LETTER_S;
tileType[tileNum] = TILE_LETTER_S;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_C;
tileType[tileNum] = TILE_LETTER_C;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_O;
tileType[tileNum] = TILE_LETTER_O;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_R;
tileType[tileNum] = TILE_LETTER_R;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_LETTER_E;
tileType[tileNum] = TILE_LETTER_E;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum++;
tiles[tileNum].type = TILE_SYMBOL_COLON;
tileType[tileNum] = TILE_SYMBOL_COLON;
ADD_DIRTY_NON_GAME_TILE(tileNum);
tileNum = LHS_FIRST_TILE + (15 * LHS_NUM_TILES_WIDE) - 2;
tiles[tileNum].type = TILE_NUMBER_0;
tileType[tileNum] = TILE_NUMBER_0;
ADD_DIRTY_NON_GAME_TILE(tileNum);
}
@ -279,10 +281,10 @@ void addStartingMushrooms(void)
/* We do not put mushrooms in the bottom tile so we subtract the width here to find
a tile number above that last line */
tileNum = rand() % (NUM_GAME_TILES - GAME_NUM_TILES_WIDE);
if (tiles[tileNum].type != TILE_EMPTY)
if (tileType[tileNum] != TILE_EMPTY)
continue;
tiles[tileNum].type = TILE_MUSHROOM4;
tileType[tileNum] = TILE_MUSHROOM4;
ADD_DIRTY_GAME_TILE(tileNum);
numMushrooms++;
}

23
BuGS/tiles.h
View File

@ -103,23 +103,16 @@ typedef enum {
} tTileType;
typedef struct
{
word dirty;
word offset;
tTileType type;
tTileOffset tileAbove;
tTileOffset tileBelow;
tTileOffset tileLeft;
tTileOffset tileRight;
word dummy; /* I want a size which is a multiple of 2 */
} tTile;
/* Globals */
extern tTile tiles[TOTAL_NUM_TILES];
extern word tileDirty[TOTAL_NUM_TILES];
extern word tileOffset[TOTAL_NUM_TILES];
extern tTileType tileType[TOTAL_NUM_TILES];
extern tTileOffset tileAbove[TOTAL_NUM_TILES];
extern tTileOffset tileBelow[TOTAL_NUM_TILES];
extern tTileOffset tileLeft[TOTAL_NUM_TILES];
extern tTileOffset tileRight[TOTAL_NUM_TILES];
extern tTileOffset dirtyGameTiles[NUM_GAME_TILES + GAME_NUM_TILES_TALL];
extern word numDirtyGameTiles;
extern tTileOffset dirtyNonGameTiles[NUM_NON_GAME_TILES];