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.

BuGS/game.s

@@ -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
+        stz tileDirty,x
-        ldy tiles+TILE_SCREEN_OFFSET_OFFSET,x
+        ldy tileOffset,x
-        lda tiles+TILE_TYPE_OFFSET,x
+        lda tileType,x
         
         jsl drawTile
         
@@ -95,9 +132,9 @@ dirtyTileLoop2 anop
         phy
         
         ldx dirtyNonGameTiles,y
-        stz tiles+TILE_DIRTY_OFFSET,x
+        stz tileDirty,x
-        ldy tiles+TILE_SCREEN_OFFSET_OFFSET,x
+        ldy tileOffset,x
-        lda tiles+TILE_TYPE_OFFSET,x
+        lda tileType,x
         
         jsl drawTile
         

BuGS/gameFlea.s

@@ -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

BuGS/gameScorpion.s

@@ -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

BuGS/gameSegments.s

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

BuGS/gameSpider.s

@@ -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

BuGS/global.macros

@@ -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

BuGS/globals.s

@@ -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

BuGS/sprites/fleas.s

@@ -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
+        lda $0,s            ; 5
-        and #$00ff
+        and #$00ff          ; 3
-        ora #$8800
+        ora #$8800          ; 3
-        sta $0,s
+        sta $0,s            ; 5
-        
+; 46
-        lda $2,s
+        lda $2,s            ; 5
-        and #$ff0f
+        and #$ff0f          ; 3
-        ora #$0080
+        ora #$0080          ; 3
-        sta $2,s
+        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
-        
+; 94
-        tsc
+        tsc                 ; 2
-        adc #$0141
+        adc #$0141          ; 3
-        tcs
+        tcs                 ; 2
-        
+; 101
-        pea $8844
+        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

BuGS/sprites/sprites.macros

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

BuGS/tiles.c

@@ -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) {                                            \
+    if (!tileDirty[tileNum]) {                                              \
-        tiles[tileNum].dirty = 1;                                           \
+        tileDirty[tileNum] = 1;                                             \
-        dirtyGameTiles[numDirtyGameTiles / 2] = ((tileNum) * sizeof(tTile));    \
+        dirtyGameTiles[numDirtyGameTiles / 2] = ((tileNum) * sizeof(word)); \
         numDirtyGameTiles += 2;                                             \
     }
 
-#define ADD_DIRTY_NON_GAME_TILE(tileNum)                                        \
+#define ADD_DIRTY_NON_GAME_TILE(tileNum)                                          \
-    if (!tiles[tileNum].dirty) {                                                \
+    if (!tileDirty[tileNum]) {                                                    \
-        tiles[tileNum].dirty = 1;                                               \
+        tileDirty[tileNum] = 1;                                                   \
-        dirtyNonGameTiles[numDirtyNonGameTiles / 2] = ((tileNum) * sizeof(tTile));  \
+        dirtyNonGameTiles[numDirtyNonGameTiles / 2] = ((tileNum) * sizeof(word)); \
-        numDirtyNonGameTiles += 2;                                              \
+        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]);
+    word tileIndex = 0;
-    tTile * rhsTilePtr = &(tiles[RHS_FIRST_TILE]);
+    word rhsTileIndex = RHS_FIRST_TILE;
-    tTile * lhsTilePtr = &(tiles[LHS_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;
+            tileDirty[lhsTileIndex] = 0;
-            lhsTilePtr->offset = lastOffset;
+            tileOffset[lhsTileIndex] = lastOffset;
-            lhsTilePtr->type = TILE_EMPTY;
+            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);
+                tileRight[lhsTileIndex] = LHS_X_Y_TO_TILE_OFFSET(tileX + 1, tileY);
-
-            lhsTilePtr->dummy = 0;
             
-            lhsTilePtr++;
+            lhsTileIndex++;
                 
             lastOffset += 4;
         }
         
         for (tileX = 0; tileX < GAME_NUM_TILES_WIDE; tileX++)
         {
-            tilePtr->dirty = 0;
+            tileDirty[tileIndex] = 0;
-            tilePtr->offset = lastOffset;
+            tileOffset[tileIndex] = lastOffset;
-            tilePtr->type = TILE_EMPTY;
+            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;
+            tileIndex++;
-            tilePtr++;
             
             lastOffset += 4;
         }
         
         for (tileX = 0; tileX < RHS_NUM_TILES_WIDE; tileX++)
         {
-            rhsTilePtr->dirty = 0;
+            tileDirty[rhsTileIndex] = 0;
-            rhsTilePtr->offset = lastOffset;
+            tileOffset[rhsTileIndex] = lastOffset;
-            rhsTilePtr->type = TILE_EMPTY;
+            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;
+            rhsTileIndex++;
-            rhsTilePtr++;
             
             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++;
     }

BuGS/tiles.h

@@ -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];