oops thanks, the V one should store to V

you made the same mistake in the other part of that section too
and thanks again for this awesome guide!

Map data format:
The data uses run length encoding for comression.  Lets say we had a simple map:

11111000001111
00000222220000
Pretty simple, each number representing a different tile.  With normal storage this would take
a single byte per tile.  Or we could represent the data in a different way:

150514052504
Seems much smaller, but what does it mean?  lets insert some imaginary commas and dashes to make
it easier:

1-5,0-5,1-4,0-5,2-5,0-4
Now you may or may not be able to see how the data is represented.  The first segment is 1-5, or 5 '1's in
a row, followed by 0-5, or five '0's in a row, and so on.  This is how the data in run length encoding is
represented.  And to further the compression (or confusion), each #-# segment is packed into a single byte.
Instead of two hex digits to represent a number from 0-255, we will have 2 hex digits, each from 0-15,
representing the two numbers of each #-# element.

The first Hex digit 0 to 15 is the tile number.  The second hex digit is the number of tiles to add to the
tilemap.  The digit goes from 0-15, but 0 doesnt make much sense, since that would mean this element doesnt
do anything , so we will add one to this after we decompress it so that it has a range of 1 to 16. 

There is a small disadvantage that if you have empty spaces of 17 or more in a row, it will take more than
1 byte to represent in the code.

Decompressing the Map:

[Data]->GDB1 //map data to GDB1
[tileData]->Pic1 //tile data for tilemap

0->N //element index for map data
0->I //map index for storing tile data

While I>=96 //until we have stored all tiles
{GBD+N}->A //Take the first element of the map data
N+1->N //Increment the map index
A^16->B //spit the map element into it
A/16->A two seperate elements

For(F,0,B //fill the map from current position I to I+B
A->{L1+I} //could be optimised with Fill but i couldnt get it
I+1->I //working :/
End

End //End while

After this code is run, the tile data will be decompressed into L1, as folows

0  1  2  3  4  5  6
7  8  9  10 11 12 13...
ect, it will be in a straigt line, but you will have to access it using your own routine.  Something like this

{Y*W+X+L1}
where W is the width in tiles of your map.  X and Y would be the tile coordinates starting at the top left at
0,0.


Displaying the map:

here is a rudimentary program that should be run right after the pervious decompressing program:

For(X,0,11 //loop through the entire screen coordinates with tiles of 8x8
For(Y,0,7
{Y*12+X+L1}->A //retrieve the correct tile from the data in L1
Pt-On(X*8,Y*8,A*8+Pic1 //draw the sprite to the screen
End
End


Also attached is a PEDIT program to create and compress maps into a Hex String into Str1, as well as an Axe program to decompress and display them.  Just put the string data into GDB1

Woot, although it would be nice if for the code segments there were line breaks between each line it would make it a bit easier to read.

Ah, yeah that would be hell.  It looks good though html and all ^^

Can somebody make a basic platformer using this code? If I had an premade example to work from, it'd help my comprehension of the tutorial.

mhmm it might be a good idea to have an example, actually, with maybe a screenshot. Some people are more visual. (like me)

yeah, I'll get on it