basically, what you would want for a simple 4x4 tilemapper would be extremely similar to an 8x8 one:

For(B,0,15
For(A,0,23
Pt-On(A*4,B*4,{B*24+A+Data_Pointer}*8+Tile_Data_Pointer
End
End
All you need to define is a pointer to map and tile data

hey scout =D
here is the basic idea explained in as much detail as i can manage:

firstly, your data needs to be in a readable format. if you have 4*4 tiles it doesn't seem like you'd need a full byte to designate which tile is to be drawn, but, for simplicity's sake, we'll do just that. there are plenty of half-byte tutorials out there for you to read once you have the basic idea.

take the map you want to draw, assign a unique one byte value to each type of tile you are going to be drawing, and, reading from left to right, top to bottom, convert your map into a string of those byte values.
for example, if   is assigned to 00,   to 01, and to 02, and you had the following map:
 
 
   

it would translate to:
[000001
[020102
[000202

once that's done, you need to take the images to be used for your tiles, convert them to hex data, and store them in order. although it makes the tile images take up four times what they would as 4*4 images, the absolute easiest way to handle this is to convert your images as if they were 8*8 images instead, leaving a four pixel buffer of blank both to the right of and beneath your desired image. this will make each of your images take up 8 bytes of data.


i bet you know that much already, though, and the real question is how to draw any arbitrary 24 wide by 16 tall chunk of this map on the screen.
that can be done with the following code:
:for(L,0,23
:for(M,0,15
:PtOff(L*4,M*4,{M+[the y offset, in tiles, of the spot in the map you want to draw, starting from the uppermost tile row in the map being zero]*[the total width of your map, in tiles]+L+[the x offset, in tiles, of the spot in the map you want to begin drawing at, starting with the leftmost tile collumn in the map being 0]+[a pointer, like GDB1 for example, to where you stored the tilemap you converted earlier]}*8+[the pointer to your tile image data]
:end
:end

or, with real arguments inserted:

:for(L,0,23
:for(M,0,15
:PtOff(L*4,M*4,{M+B*N+L+A+GDB1}*8+Pic1
:end
:end
where:
A= xoffset
B= yoffset
N= total map width, in tiles
GDB1= tilemap data
Pic1= tile image data

this method is simple, but it can be optimised a good deal (and there are plenty of threads showing how for that as well which you should be able to understand once you get the basic idea).
good luck!

No. You are doing wrong. If you arrange the bytes that way, the pointer (GDB1) is pointing to the last 2 bytes of the map.
///
Quick tutorial on tilemapping
///
A tilemap is exactly what the name says: a map full of tiles. In the classic z80 tilemap, you can have up to 255 tiles (There is always one white tile, that you don't need to draw)
Now, lets go to some code. (Scout, for 4*4 tiles, you need to adjust some values, I'll comment in which values)
.TILEMAPR
.Tile data:
[FFFFFFFFFFFFFFFF->Pic1  ; Or any variable (StrX,PicX,GDBX)
[F0F0F0F0F0F0F0F0
.Those are 8x8, for 4x4 just add 4x4 tiles (Wow thats hard to understand :D)
.Tilemap data (4x4 tilemap)
[00000001->Pic1TL  ; Or any variable (StrX,PicX,GDBX)
[01010102              ; Each tile takes a byte. Make sure to get the right hex code!
[02010201
[00010002
.Draw the tilemap
For(A,0,3)    ; Change the 3 to the height of the map minus 1
For(B,0,3)    ; Change the 3 to the width of the map minus 1
If {Pic1TL+(A*4)+B}->C ; Change the 4 to the width of the map
-1->C
Pt-On(B*8,A*8,Pic1+(C*8));Change the 8 in the coordinates to the width and height of the tiles
End
End
End
I hope this is clear enough. Now you have a tilemap drawn on the buffer. Add a dispgraph and... voila, your tilemap is there!

So, I got some more of it and started coding, based on aeTIo's sample.

.TILEMAPR
.Tile data:
[FFFFFFFFFFFFFFFF->Pic1
[F0F0F0F0F0F0F0F0
[22222222->Pic1TL
[20000002
[20000002
[22222222

Repeat getKey(15)
.Draw the tilemap
For(A,0,3)
For(B,0,3)
If {Pic1TL+(A*4)+B}->C
-1->C
Pt-On(B*8,A*8,Pic1+(C*8))
End
End
DispGraph
End
End
But why is this code a lot of dots and two blocks on the right. I don't really get how changing Pic1TL affects the code.

EDIT: I actually think I got it, I'm changing half of a byte, and not an entire byte.

Yeah, changing bytes worked better.

the issue there was, as you realised, using half bytes rather than full bytes in your map data, so instead of
[22222222
[20000002
[20000002
[22222222
i think what you were trying to have it draw was
[02020202
[02000002
[02000002
[02020202
for which your tilemap code would work just fine.
two other things:
the code you have here will work, but will run more quickly when there are lots of 00 tiles and more slowly when there aren't, whereas the one i posted above has a stable draw speed regardless of what it's drawing.
also, instead of doing things like
Pic1+(C*
you should use
C*8+Pic1
because fewer parentheses means less space taken up and greater speed.

Bump, I really need help with this for the contest, thanks.

FinaleTI, yeah it worked =) The only problem is that I still need all the 0s in the end of the hex code of a sprite, but it's cool anyway.

Thanks

Anybody know how to add greyscale to this?

.TILEMAPR
.Tile data:
[F0F0F0F000000000->Pic1
[C0C0C0C000000000
[01010101->Pic1TL
[01000001
[01000001
[01010101

Repeat getKey(15)
.Draw the tilemap
For(A,0,3)
For(B,0,3)
If {Pic1TL+(A*4)+B}->C
-1->C
Pt-On(B*4,A*4,Pic1+(C*8))
End
End
DispGraph
End
End