| |
mhindsbo
Registered: Dec 2014
Posts: 51 |
Code optimization
I thought I would tap into the creativity here to see if you have optimization suggestions for the following.
For my game I have a list of objects. When an object spawns I set bit 7 in the first byte of the table so I dont spawn it again while it is active (or if it is destroyed). If the object leaves the screen without being destroyed I flip the bit back again.
Each active objects stores the address of its location in the spawn table and uses the following code to 'reactivate' itself if/when it leaves the screen.
lda object_d6,x ; lo byte of address
sta tempz+0 ; location in zero page
lda object_d7,x ; hi byte of address
sta tempz+1
ldy #0
lda (tempz),y
and #%01111111 ; clear bit 7
sta (tempz),y
That is 29 cycles +3 if page boundary is crossed. Any optimization ideas?
I could of course just add another byte in the object table so I dont have to set/clear a bit, but that adds potentially hundreds of bytes ekstra for a given level. |
|
... 13 posts hidden. Click here to view all posts....
|
| |
ChristopherJam
Registered: Aug 2004
Posts: 1409 |
I'm a bit confused about the number of objects thing.
Surely even the original question presupposes no more than 256 objects, as their addresses are stored in the object_d6/object_d7 tables, which are just indexed by X?
And I'm not seeing how Copyfault's suggestion gets past that, unless the upperbitlist table is used to dynamically select for each object ID which of two possible objects it might refer to.
In either case, moving past 256 objects while still storing object ID in X is going to need some kind of system for managing a smaller subset of potentially active ones.. |
| |
cadaver
Registered: Feb 2002
Posts: 1160 |
In the original code, the X indexed variables are for currently active (onscreen) objects, of which there are much less than 256. The d6 / d7 variables point into an arbitrarily sized object spawn data. |
| |
Oswald
Registered: Apr 2002
Posts: 5095 |
btw its hard to imagine a c64 game with hundreds (>256) npcs.. :) |
| |
mhindsbo
Registered: Dec 2014
Posts: 51 |
The x indexed is active object data tables (x, y, image, ...) that are sorted etc. for sprite multiplexor.
hundreds of objects is easy ;-) Aviator Arcade has several hundreds of tanks, planes, etc. per level. that get spawned at specific locations on the map. |
| |
mhindsbo
Registered: Dec 2014
Posts: 51 |
Thanks for the input. Discussing here made me restructure my data format.
Each tile row on the map now simply has a start index and an end index of object to spawn. If start and end index is the same number is means no objects to spawn on that row.
I will limit the number of objects for any given level to 265. And use the suggestion to change object type to 0 once it is spawned.
significantly simpler, smaller and faster.
Thanks again for all the input. |
| |
ChristopherJam
Registered: Aug 2004
Posts: 1409 |
Quoting cadaverIn the original code, the X indexed variables are for currently active (onscreen) objects, of which there are much less than 256. The d6 / d7 variables point into an arbitrarily sized object spawn data.
Ah! That makes sense, thank you.
mhindsbo, glad we could help :) |
| |
Copyfault
Registered: Dec 2001
Posts: 478 |
Quoting ChristopherJam[...]
And I'm not seeing how Copyfault's suggestion gets past that, unless the upperbitlist table is used to dynamically select for each object ID which of two possible objects it might refer to.[...]
I did not write out all the details, but you're right, I had some kind of dynamic link list in mind. Ofcourse this does not really widen the length of the index value (X-reg is still in gear) but this rather gives a possibility to choose between "sub"-objects.
For a proper 9-bit-index-value, it should work to use another register (e.g. a zp-reg) as a highbyte for the index-value and use this just like upperbitlist in my former code examples, just without any index! Downside will certainly be the code doubling to choose between the different tables used lateron, but with self-modification of the code this can be worked around I think.
@mindsbo: glad to read that you found a data structure for your need:) Looking forward to seeing what kind of game comes out of it!!! |
| |
Copyfault
Registered: Dec 2001
Posts: 478 |
Hmm, now even though the initial problem is solved already, the following idea just crossed my mind: you could use x (or y) plus a byte in zeropage as index information, and directly use zp-adressing modes for access. I.e.:
$02 $00 (always!) ;lo-byte for accessing information-table, always =$00
$03 (hi-byte of index) ;hi-byte for information-table "=" hi-byte for index
... ...
ldy #obj_index_lo ;full object-index consists of this y-value plus the value currently in $03
lda ($02),y ;get information from table
The number of different values put in $03 gives a multiplier for the $100, extending the index range accordingly. So no need to initialize the vectors on every access to the object information, only if the index value overflows. Could cause problems because most probably the index-hi-byte cannot just be $00, $01, etc but rather some suitable pointer to a mem page. Plus, one needs even more differnt hi-byte-values if different table types come into play (isactive, position,...). |
| |
Oswald
Registered: Apr 2002
Posts: 5095 |
I'd rather duplicate code for the next 256 objs, and branch. fex c can hold the 9th bit for that. |
| |
ChristopherJam
Registered: Aug 2004
Posts: 1409 |
Nah, this calls for a complex spooling system - overwrite half the objects as you approach a new area, using a custom decruncher that writes scattered data from a compressed representation that was background-loaded earlier \o/ |
| Previous - 1 | 2 | 3 - Next |
