Going by Axe.inc, {^oY₁}^r is the address and {^oY₁+2} is the page.
So to answer your question, the pointer comes first.

Well, assuming that you assign each block an X and Y coordinate in a buffer, you could simply do a 'rand^94' when assigning an x coordinate, then leave it alone.

Pseudo-code:
0->block_count

While game_is_running == True:
    If create_a_block == True:
        rand^94->{block_count * 2 + L1}  // X-coordinate
        0->{block_count*2 + 1 + L1}      // Y-coordinate
        block_count++
    End
   
    For(A, 0, block_count):              // or is it 'For(A, 0, block_count - 1)' ?
        {block_count*2 + 1 + L1}++       // Increment each Y-coordinate so that every block moves down
    End

    [game code here]

End



Same thing, except with 100 blocks (Muhahaha).

.Number of blocks (don't exceed about 350)
100->N

.Clearing L1 (there are more efficient ways to do this,
.but I can never remember the exact syntax).
For(I,0,N*2)
    0->{L1+I}
End

While 1


    .Creating X and Y
    For(I,0,N)
        If {I*2+L1+1} > 64
            rand^94->{I*2+L1}
            0->{I*2+L1+1}
        End
    End
   
    .Some other stuff
   
    .Drawing
    For(I,0,N)
        I*2+L1->J
        Pt-On({J},{J+1},Pic2)
        {J+1}+1->{J+1}
    End
   
    .More stuff
   
    .Collision check
    For(I,0,N)
        I*2+L1->J
        If abs({J}-X)<8
            ReturnIf abs({J+1}-Y)<8
        End
    End
   
    .Obligatory emergency exit
    ReturnIf getKey(15)
End

You probably would want to lower the number of blocks + make tweaks so they don't fall down all at once.

Also, you can see that in this example I used a 'For' loop several times -- it would be generally better if you could optimize it into a single loop.

.Number of blocks (don't exceed about 350)
100->N

.Clearing L1 (there are more efficient ways to do this,
.but I can never remember the exact syntax).
For(I,0,N*2)
    0->{L1+I}
End

While 1
    .Some stuff

    For(I,0,N)
        .Creating X and Y
        If {I*2+L1+1} > 64
            rand^94->{I*2+L1}
            0->{I*2+L1+1}
        End
       
        .Drawing
        I*2+L1->J
        Pt-On({J},{J+1},Pic2)
        {J+1}+1->{J+1}
       
        .Collision Check 
        I*2+L1->J
        If abs({J}-X)<8
            ReturnIf abs({J+1}-Y)<8
        End
    End
   
    .More stuff
   
    .Obligatory emergency exit
    ReturnIf getKey(15)
End

The above code relies on pointers/free ram -- a crucial part of Axe programming.

See Deep Thought's wonderful tutorials on both:

http://www.omnimaga.org/index.php?action=articles;sa=view;article=59
http://www.omnimaga.org/index.php?action=articles;sa=view;article=61

The curly brackets dereference a pointer.
http://eeems.omnimaga.org/Files/Resources/program%20readmes/Axe/Commands.htm#Das is the usage instructions.

Lets say you have the following expression: {L1}
L1 essentially always contains the number 0x86EC (or 34540 in base 10). This happens to be the address of a safe spot in RAM.

Now, the memory in any computer is laid out numerically. The 83+'s have each individual number equal to one byte of storage space in the calculator. That means that each number can essentially hold from 0 to 255. L1 can hold from 0-255, L1+1 can hold from 0-255.

{L1} would get you the value of the number at 0x86EC. {L1+1} would get you the value of the number at 0x86ED.

These numbers can then be used as a normal variable. For example:

1->{L1} would store 1 into 0x86EC, or L1. 2->{L1+1} would store 2 into 0x86ED, or L1+1.


Lemme know if this doesn't clear it up for you.

L1 in Axe is not a list, it points to a block of data.  So, it's a "pointer". That's all the buffers are, spots of memory that tend to be empty, and are safe (for the most part) to use for data storage.

And yes, {L1} can be used as a normal variable, though it will only hold 0-255 if it's one byte.

{L1+1} is related to {L1} only that it's the byte immediately following the latter.


Hope this helps

L1 in terms of axe is a static value. It's not a list.

{L1} is one variable, {L1+1} is another, {L1+2} is another. They are all at independent addresses.

Note that it's possible to combine two addresses to form a 16-bit number, or a number from 0-65535 by using {L1}^r. This would use L1 and L1+1 to store the larger number.

Edit: If you know what an array is, think of the memory as a giant array from 0x0000-0xFFFF (though obviously not all of this is writable). The brackets simply return the index in ram that you specify as a variable.

short answer: yes.
long answer: depends on what you want to do with it. That's the beauty of midlevel languages like Axe--everything is what you want it to be.