Random Object on Screen

On the 1st floor, I will teach you how to write the program step by step. Now, suppose that I want to display a 7×7 (m×n size) square object in random position. First we call:
/*
pop xr0
hex D4 DD 00 06
memzero ;0:8FBA
*/
to clear the 1st_buffer. Then we call num_frombyte (1:D94CH) like this:
/*
;You should skip LR for any functions that start with "PUSH LR" instruction
pop xr0
hex 40 E6 ;example address for storing min_x value
hex 00 00
num_frombyte
;Note that storing one number to any destination, it always accounts for 10 bytes.
pop xr0
hex 50 E6 ;example address for storing max_x value
hex B8 00 ;0xB8 = 191 - 7 = 184
num_frombyte
pop xr0
hex 60 E6 ;example address for storing min_y value
hex 01 00
num_frombyte
pop xr0
hex 70 E6 ;example address for storing max_y value
hex 38 00 ;0x38 = 63 - 7 = 56
num_frombyte
*/
After that, we call num_randint (1:395EH) like this:
/*
pop xr0
hex 40 E6 ;min_x result addr
hex 50 E6 ;max_x result addr
num_randint
pop xr0
hex 60 E6 ;min_y result addr
hex 70 E6 ;max_y result addr
num_randint
;Note that result of these num_randint will overwrite [ER0] so you must loop program from "num_frombyte" part again to ensure it could reset the min_x and min_y value for next execution.
*/
Now, we must copy back the result from each [ER0] to var_x (0xD36A) and var_y (0xD374) respectively using memcpy (length: 10 bytes = 0A 00)
/*
pop xr0
hex 6A D3 ;dest
hex 40 E6 ;src
BL memcpy, pop er0 ;0:86F0H
hex 0A 00 ;length
pop xr0
hex 74 D3
hex 60 E6
BL memcpy, pop er0
hex 0A 00
*/

2nd floor: Continue
After did copying result step, you can easily use this formula: "256 × y + x" to calculate pos in decimal using calc_func (1:77DAH). Note that the address of formula would increase after calculating formula, so try to loop whole program including formula address and whole token in this formula too.
/*
pop xr0
adr addr_formula_calc
hex A0 D3 ;dest to store result
calc_func
<loop part here>
addr_formula_calc: # for example label addr here is 0xD880. If you write code by hand, you should account the address correctly.
adr formula_calc
formula_calc: # 0xD882
hex 32 35 36 A8 49 A6 48 00 ;token of 256×y + x formula
object: ;0xD88A
<hex of object here>
*/
Next, we must convert the position from decimal to hexadecimal. We will use this pair: 1:5F86 and 1:5FFC (remember to skip LR) to convert, and converted result will store to ER0.
/*
pop er0
hex A0 D3
pop er12
hex A0 D3
call 15F88
call 15FFE
*/
Now, we can store the result to any address, for example 0xE9D4. We simply do this:
/*
setlr
er2 = er0,er0 += er4,rt
pop er8
hex D4 E9
[er8] = er2, pop xr8
hex D4 E9 00 00
*/
We almost done. Now we will render the object using render_bitmap (0:8ACEH) with position we stored before, we just load the value from 0xE9D4 to er0 and set size of object to 7×7 and specify addr of object (in hex).
/*
pop er2
hex 00 00
[er8] += er2, pop xr8
hex 00 00 00 00 ;to load value from 0xE9D4 to er2
er0 = er2,rt ;copy to er0
pop er2
hex 07 07
render_bitmap
pop er0
hex 8A D8 ;example address
render.ddd4
*/

3rd floor: Last step
Finally, we just need to loop the program. Use @贴吧用户_QQR3MM4 (xyzst) loop for more efficient (a.k.a memcpy loop). But first we should set delay because we want to see object display in random position:
/*
pop er0
hex 00 20
delay
DI,RT
pop er8
adr length
pop er2
hex 01 00
[er8] = er2, pop xr8
hex 00 00 00 00
pop qr0
<program length>
<src addr>
<dest addr>
<sp jump addr> - 2
hex CC 87
length:
start_label:
<end of program - start_label> ;to calculate remaining length
hex 00 00
sp = er6,pop er8
*/
That's it. If you dont understand, you can read my example program in the 4th floor

4th floor: Example program.
Inject data to 0xE9E0 and run it using this launcher: FD24 30 30 D8 91 30 30 8C 92 30 30 E2 30 31 30 16 01 E0 E9 30 D8 2E D8 CC 87 31 30 30 30 38 1D 32 30.
Some explanation:
1. D8A0: 34 61 01 00 [34 D9] A0 D3 DC 77 01 00...
It means ER0 = 34 D9 (0xD934). 0xD934 contains "address of formula", not "formula" itself. Data at 0xD934 is 36 D9 which is 0xD936 = address of formula. 32 35 36 A8 49 A6 48 00 is token of formula: "256×y+x".
2. D8F0: 00 00 A8 21 01 00 [3E D9] 06 87 00 00...
3E D9 (0xD93E) here is address of picture/object that is written in hexadecimal form, you can look at the data at 0xD93E.
3. D90A: 36 9A 00 00 [2C D9]; D910: C2 8F 00 00 [01 00] 28 8F 00 00 00 00 00 00...
It means 0xD92C is addr of remaining length, which is replaced by 01 00 and because 1:87CC is BL memcpy but indirect, we must replace the remaining length to memcpy (segment 1) continuously to make it loop by repeating storing 01 00 to addr of remaining length.
4. D91E: E2 30 01 00 [16 01] [E0 E9] [30 D8] [2E D8] ...
0x0116 = 278 bytes = length of whole program
0xE9E0 = backup addr
0xD830 = source addr (= where to execute and process the program)
0xD82E = sp jump ER6, we must copy repeatedly from backup to src, so that we could jump back to the starting point and loop (using 38 1D 32 30 at the end of program)
5. D92A: CC 87 [12 00] 00 00
0012 = remaining length, count from 0xD92C to 0xD93E (from the addr after CC 87 to the end (that we configured before). The purpose here is to make the remaining part to be fixed, cannot change, like even if the addr of addr of formula increases from D936 to D93E (there are 8 tokens in that formula) it still reset to D936, and we can repeat executing the formula again and again.
That's all. If you have any questions, feel free to ask in this post.