Info about assembly "variables"

I don't know what assembler you are using but you should be able to use the ds directive to reserve some space.

For example to reseve 64 bytes:
ds 64

I'm using sjasmplus, but if I use ds 2 (2 bytes).
I tryed

MissilesRefreshPositionTime			ds 2

but here the compile say to me: Bytes lost.

    ld		hl, MissilesRefreshPositionTime
    ld		(hl),256  ; Bytes lost compile error

The "ld (hl), 256" instruction of the Z80 cpu interprets the second value to be an 8 bit constant. So, it will ONLY write 1 byte. Regardless of however you define your variable. In this case, the least-significant byte of 256, which is just a "0".

To write value "256" to your "MissilesRefreshPositionTime" 16 bit variable, you have other options, for example:

- Put the address in "hl", and write 1 byte at a time:

  ld hl, MissilesRefreshPositionTime
  ld (hl), 256 % 8  ; write the least-significant byte
  inc hl
  (ld (hl), 256 / 8  ; write the most-significant byte

- Put the 16bit value in a 16bit register (e.g., "hl"), and then write it in a single instruction using an immediate address:

  ld hl, 256
  ld (MissilesRefreshPositionTime), hl

Basically, the z80 has a limited instruction set. So, you need to be careful with the things that the z80 can or cannot do. I strongly advise you to learn the z80 instruction set very carefully. Otherwise, coding in assembler is going to be a big challenge

    ld		hl, MissilesRefreshPositionTime
    ld		(hl),256  ; Bytes lost compile error

BTW maybe you can try latest version of z00m's fork of sjasmplus, I did update some of the error message in newer versions to make them hopefully more understandable:

$ sjasmplus --version
SjASMPlus Z80 Cross-Assembler v1.20.2 (<a href="https://github.com/z00m128/sjasmplus" title="https://github.com/z00m128/sjasmplus">https://github.com/z00m128/sjasmplus</a>)
$ sjasmplus --msg=lst -
 ld (hl),256
# file opened: 
(1): warning: value 0x100 is truncated to 8bit value: 0x00
1     0000 36 00         ld (hl),256
2     0002
# file closed: 

And in the listing the file there are line numbers, address the instruction is assembled for (0000) and machine code bytes `36 00` -> so you can sometimes reverse-check with instruction table what the assembler does produce, in this case it's `ld (hl),n` opcode and the `00` is the value, which is the truncated 256 to 8 bits. So this may be sometimes handy to figure out what happens during assembly.

What I always do is something like this (assuming the program is in ROM and you want to use RAM for variables) in the beginning of my .asm file:

Xpos: equ &C000
Ypos: equ &C001
Score: equ &C002
Highscore: equ &C004
Level: equ &C006
etc

XPos and Ypos are bytes and Score and Highscore are words.
You can load the variables like this:

ld a,0   (or xor a...)
ld (Xpos),a
ld hl,8000
ld (Highscore),hl

It might look tricky, because if you make a mistake you can overwrite variables, but it makes it easier to do something like this:

Enemy1: equ &C010 ; this is not a variable itself, but a start address for Enemy1 variables
Enemy1X: equ &C010
Enemy1Y: equ &C011
Enemy1Power: equ &C012

Enemy2: equ &C020 ; this is not a variable itself, but a start address for Enemy2 variables
Enemy2X: equ &C020
Enemy2Y: equ &C021
Enemy2Power: equ &C022

dx: equ 0  ; these are not variables, but displacements
dy: equ 1
dpow: equ 2

start:
ld IX,Enemy1
ld (IX+dx),20   ; sets x variable
ld (IX+dy),10  ; sets y 
ld (IX+dpow),0   ; sets power
ld IX,Enemy2
ld (IX+dx),50       ... etc