So my game is as good as complete, the last thing I must do is to be able to permanently save data.
I've read the AppVar part in Developpers Guide, but I just lack the knowledge to comprehend it all.
My question remains: How do I store simple data (just numbers, that's all) so that it can be recalled the next time someone runs the App?
All I really want is things like:
Hi-Score:
         .db       496
Achievements:
         .db       1
Whatever:
         .db       9999
but then to be saved after the programm is exited, and able to recall later on.
Would be perfect if the AppVar gets archived when the programm is closed, but that part shouldn't be hard and I can figure that out myself.

So... anyone has an easy way to save/recall numbers in Apps?

_player that is all correct except the type is 15h.

@Jerros, here is a nice routine to get you to the start of the appVar. It will create it if it doesn't exist, and it will unarchive it if it's archived.
getAppVar:
ld hl, appVarName
rst 20h ;move9ToOp1
bcall(_chkFindSym)
jr nc, found

ld hl, size
push hl
bcall(_createAppVar)

inc de ;skip size bytes
inc de
ex de, hl
pop bc
bcall(_clearMem) ;fills hl with bc 0's
jr getAppVar
found:
ld a, b
or a
jr z, inRam
bcall(_arc_unarc)
jr getAppVar
inRam:
inc de
inc de
ret

appVarName:
.db appVarObj, "appVar", 0, 0
;  15h

Just be sure to archive it when you program quits.

Edit:
   The appVar is just like regular ram, you can use it however you see fit. Just be sure that you use it the same way consistently. Like, don't save the first byte as highscore, and then read the first byte as achievements.

I've found you actually don't have to fill it with 0's. While it makes your code look pretty and makes it more logical, you only really need one 0. Basically the rst would grab your name and whatever was after it, but it doesn't matter because you already stopped it with 0.

Sorry about that, _memClear is in my mind as _clearMem, I don't know why I always mix them up. As long as you give it an HL that is not in front of your program, and a bc that is >=2 it won't crash.

As for accessing them, I'll draw a picture.

Here is ram before.
prgmA | prgmB | MirageOS appvar | prgmDESTROY | etc....

When you call make appVar, the OS makes a hole in the programs for yours to go, so:
prgmA | prgmB |   500 + 2 byte hole   | MirageOS appvar | prgmDESTROY | etc....
                    ^
Then when you call chkFindSym on it, it will tell you that yes, your appVar exists, and that you can find it's start in DE. DE is now pointing to that line in front of the hole. The first thing you have to do is skip two byte, these two byte are how big of a hole was created. Now you have 500 bytes to do whatever you want with.

To access it, you have to do it through hl or de. ld (appVar), hl won't work because at assembly time, the assembler doesn't know where the appVar is going to be. It's location can even change within your program if you make another appVar. You then have two options:

If you have just a little bit of data to store, you can do this:
ld hl, name
rst 20h
bcall(_chkFindSym)

inc de
inc de

ex de, hl

ld (hl), a
inc hl
ld (hl), b
inc hl
ld (hl), c
inc hl
ld de, (score)
ld (hl), e
inc hl
ld (hl), d
You can see how this would get ugly if say you needed to store 500 bytes. The other option is to set up your memory usage to accommodate the final saving. Here is how you could do that:
dataStart equ appBackUpScreen

enemyBuf equ dataStart ;256
bulletBuf equ enemyBuf+256 ;256
score equ bulletBuf+256 ;2
lives equ score+2 ;1
reload equ lives+1 ;1

dataEnd equ reload+1 ;1


ld hl, name
rst 20h
bcall(_chkFindSym)

inc de
inc de

ld hl, dataStart
ld bc, dataEnd-dataStart
ldir
This method is good if you need to store buffers and such. Then to access them, just do it in reverse. For the first example, just switch (hl) with the other register and it will pull data out instead. For the last one, ex de, hl and you will be copying to your data area from the appVar.

The way I generally do appvars is like this:

;To read form the appvar:

call    Routine_that_Gets_pointer_of_appvar_in_HL
ld      de,AppDataStart
ld      bc,AppDataEnd-AppDataStart   ;Size of data
ldir                                 ;copy the appvar TO your data

;If appvar wasn't found, fill the data area with default values

ld      hl,DefaultDataStart
ld      de,AppDataStart
ld      bc,AppDataEnd-AppDataStart   ;Size of data
ldir                                 ;copy the default TO your data

;To write to your appvar:

call    Routine_that_Gets_pointer_of_appvar_in_HL
ex     de,hl
ld      hl,AppDataStart
ld      bc,AppDataEnd-AppDataStart   ;Size of data
ldir                                 ;copy the data TO the appvar

;This is how I hold my variables using this macro I made:

#define VAR(name,size) name: \ .org name+(size)

.org SomeFreeRamLocation
AppDataStart:

VAR(MyVar1,1)   ;A one byte variable
VAR(MyWord,2)   ;A two byte variable
VAR(MyArray,100)  ;A 100 byte array

AppDataEnd:



Yes, calls can be conditional. They can also use all the conditions not just z nz c nc. Like m for negative or p for positive.

To compare two 16 bit numbers, use:
or a
sbc hl, de
add hl, de
This affects the flags the exact same way that cp hl, de would if it were a real command.

Also, you only need one inc hl after you write a variable to memory. That's because A is one byte, ld (hl), a stores one byte, so you only need to increase one byte. If you have a bigger number to store, you have to split it into bytes. So DE is stored E then D.

Code: [Select]

or a
sbc hl, de
add hl, de


What should "a" be in the "or    a" line?
Or is that completely irrelevant and are those 3 lines just an equivalent of "cp    HL"?

Uhm... another stupid question, but how do I use that to check wether one 16-bit number is larger than another?
With the "cp  HL" routine you gave me, it's only possible to check wether the numbers match or not.
How would I do a jump only if, lets say, DE holds a bigger number than HL?

EDIT:
Figured that'd be done with:
or a
sbc hl, de
add hl, de
             JR        "condition", "Label-DE-is-Bigger"
.....
code DE-and-HL-were-equal-or-HL-was-Bigger
.....
Not sure which condition to use yet, but I'll try some.