Sorry your browser is not supported!

iStartY# = (IMAGE HEIGHT(10)) - 25

pixel = IMG_RGBA(0,0,0,255)

`PROGRAM START CODE
set display mode desktop width(), desktop height(), 32
Set window position 0,0
sync on
sync rate 60

objId = 1 ` not implemented yet
scale# = 5.3 ` probably any non-zero value will work
reduce# = 0.5 ` values in the range 0.5 to 1.0 work best
`This is the max
sizeX = 256` doesn't need to be square
sizeY = 256

global Dim terrainH(sizeX,sizeY) as Float     `each sizeX,sizeY holds a 0-255 value
global dim marker(sizeX,sizeY) 



getImageEdge(GET DIR$() + "\images\MAP_SEED.jpg","highx")
GenerateTerrain(Obj,scale#,reduce#,sizeX,sizeY)


`Goal of this function is to save the x pixels from given edge to an array
`which then gets used to fill the terrain array during the process of making the heightmap
`which should in theory anyway, link our heightmaps together automatically
function getImageEdge(sWhichImage$,sWhichEdge$)
    `Image ID 10 is reserved for this process
    `Memblock ID 10 is reserved for this process as SOURCE
    `Memblock ID 11 is reserved for this process as DESTINATION
    
    iStartX# AS INTEGER : iStartY# AS INTEGER
    iEndX# AS INTEGER : iEndY# AS INTEGER
    iPosX# AS INTEGER : iPosY# AS INTEGER

    load image sWhichImage$,10
    MAKE MEMBLOCK FROM IMAGE 10,10
    
    `Make a blank image to start pasting into
    `memblock = IMG_MAKE(700, 700, IMG_RGBA(255,0,0,255))
    
    SELECT sWhichEdge$
        `When we take the LOWX edge of the image, we need to apply it to the HIGHX of the neighbor image
        ` but in reverse - so that 1,2,3 becomes 3,2,1
        CASE "lowx":
`            `IMG_PASTE_MEMBLOCK_PART(memblock,10, 0, 0, 0, 0, IMAGE WIDTH(10), 3)
`            iStartX# = 1 : iStartY# = 1
`            iEndX# = IMAGE WIDTH(10) : iEndY# = 3
`            
`            `we intend on placing the new image content here
`            iPosX# = 0 : iPosY# = IMAGE HEIGHT(10) - 3
            print "test"
        ENDCASE
        `When we take the HIGHX edge of the image, we need to apply it to the LOWX of the neighbor image
        CASE "highx":
            `IMG_PASTE_MEMBLOCK_PART(memblock,10, 0, IMAGE HEIGHT(10) - 25, 0, IMAGE HEIGHT(10) - 25, IMAGE WIDTH(10), IMAGE HEIGHT(10))
            iStartX# = 0
            `iStartY# = (IMAGE HEIGHT(10)) - 1 - 10
            iStartY# = 0
            iEndX# = IMAGE WIDTH(10) - 1
            `iEndY# = IMAGE HEIGHT(10) - 1
            iEndY# = 11
            `Show me the variables for this
            `show message STR$(iStartX#) + " - " + STR$(iEndX#) + " -- " + (STR$(iStartY#+1)) + " - " + STR$(iEndY#)

            `we intend on placing the new image content here
            iPosX# = 0 
            `iPosY# = 0
            `iPosY# = (IMAGE HEIGHT(10)) - 1 - 10
            iPosY# = (IMAGE HEIGHT(10)) - 1
        ENDCASE
        
        `THIS IS WORKING AS INTENDED - DO NOT CHNAGE IT!!!!!
        CASE "lowy":
            `IMG_PASTE_MEMBLOCK_PART(memblock,10, 0, IMAGE HEIGHT(10) - 25, 0, IMAGE HEIGHT(10) - 25, IMAGE WIDTH(10), IMAGE HEIGHT(10))
            iStartX# = 0
            `iStartY# = (IMAGE HEIGHT(10)) - 1 - 10
            iStartY# = 0
            iEndX# = IMAGE WIDTH(10) - 1
            `iEndY# = IMAGE HEIGHT(10) - 1
            iEndY# = 11
            `Show me the variables for this
            `show message STR$(iStartX#) + " - " + STR$(iEndX#) + " -- " + (STR$(iStartY#+1)) + " - " + STR$(iEndY#)

            `we intend on placing the new image content here
            iPosX# = 0 
            iPosY# = (IMAGE HEIGHT(10)) - 1
        ENDCASE
        
        
        `THIS IS WORKING AS INTENDED - DO NOT CHNAGE IT!!!!!
        CASE "highy":
            `IMG_PASTE_MEMBLOCK_PART(memblock,10, 0, IMAGE HEIGHT(10) - 25, 0, IMAGE HEIGHT(10) - 25, IMAGE WIDTH(10), IMAGE HEIGHT(10))
            iStartX# = 0
            iStartY# = (IMAGE HEIGHT(10)) - 1 - 10
            `iStartY# = 0
            iEndX# = IMAGE WIDTH(10) - 1
            iEndY# = IMAGE HEIGHT(10) - 1
            `Show me the variables for this
            `show message STR$(iStartX#) + " - " + STR$(iEndX#) + " -- " + (STR$(iStartY#+1)) + " - " + STR$(iEndY#)

            `we intend on placing the new image content here
            iPosX# = 0 
            iPosY# = 0

        ENDCASE        
    ENDSELECT

    icx = iPosX#
    icy = iPosY#
    icxstart = iPosX#
    icystart = iPosY#
    
    `HIGH Y WORKS - DO NOT TOUCH IT
    if sWhichEdge$ = "highy" 
        FOR x = iStartX# to iEndX#
            FOR y = iEndY# TO iStartY# STEP -1
                `show message STR$(x) + " - " + STR$(y)
                 col = RGBR(IMG_GET_PIXEL3(10,x,y,IMAGE WIDTH(10),IMAGE HEIGHT(10)))
                 if col<0 then col=0
                 if col > 200 then col=200
    
                terrainH(icx,icy) = col            
                `I know this works by setting this - whichever side I go to will be full white
                `terrainH(iPosX# + x,iPosY# + y) = 255
                marker(icx,icy) = 1
    
                if icy = iEndY# - iStartY#
                     icy = 0
                ELSE
                    icy = icy + 1
                ENDIF
             NEXT
            
            if icx = iEndX# - iStartX#
                 icx = 0
            ELSE
                icx = icx + 1
            ENDIF
        NEXT
    ENDIF


    if sWhichEdge$ = "lowy" 
        `show message STR$(iPosX#) + " - " + STR$(iPosY#)
        `show message STR$(iStartX#) + " - " + STR$(iEndX#)
        `show message STR$(iStartY#) + " - " + STR$(iEndY#)

        FOR x = iStartX# to iEndX#
            FOR y = iStartY# to iEndY#
            `FOR y = iEndY# TO iStartY# STEP -1
                
                 col = RGBR(IMG_GET_PIXEL3(10,x,y,IMAGE WIDTH(10),IMAGE HEIGHT(10)))
                 if col<0 then col=0
                 if col > 200 then col=200

                `show message STR$(x) + " - " + STR$(y)
                `show message STR$(icx) + " - " + STR$(icy)

                terrainH(icx,icy) = col            
                `I know this works by setting this - whichever side I go to will be full white
                `terrainH(iPosX# + x,iPosY# + y) = 255
                marker(icx,icy) = 1
    
                if icy = iPosY# - (iEndY# - iStartY#)
                     icy = iPosY#
                ELSE
                    icy = icy - 1
                ENDIF
             NEXT
            
            if icx = iEndX# + iStartX#
                 icx = iPosX#
            ELSE
                icx = icx + 1
            ENDIF
        NEXT
    ENDIF
   
    DELETE IMAGE 10
    `MAKE IMAGE FROM MEMBLOCK 11, memblock
    `imagesDir$ = GET DIR$() + "\images\"
    `SAVE IMAGE imagesDir$ + "TESTFILE111111.jpg",11
    
    `DELETE IMAGE 10
    DELETE MEMBLOCK 10
    `DELETE MEMBLOCK 11
ENDFUNCTION



`THESE ARE THE FUNCTIONS FROM THE HEIGHTMAP GENERATOR POST 
` SOME OF HAVE BEEN MODIFIED SLIGHTLY AND NEW FUNCTIONS INTRODUCED

`sets all the marker array values as zero to start off with so we have a correctly sized array at the start
function initMarkerArray()
    for x = 0 to sizeX - 1
    for y = 0 to sizeY - 1
        `we may have already set markers 
        marker(x,y) = 0
    next y
    next x
ENDFUNCTION

function initTerrainArray()
    for x = 0 to sizeX - 1
    for y = 0 to sizeY - 1
        `we may have already set markers 
        terrainH(x,y) = 0
    next y
    next x
ENDFUNCTION

Function GenerateTerrain(Obj,scale#,reduce#,sizeX,sizeY)
    `This has been commented out because marker() may be populated by another function
    ` so I don't want to over-write what's in it
    `  for x = 1 to sizeX
    `    for y = 1 to sizeY
    `        `we may have already set markers 
    `        if not marker(x,y) = 1
    `            marker(x,y) = 0
    `        endif
    `    next y
    `  next x
    
    `This may need to be modified
    `InitialiseArray(sizeX,sizeY)
    
    DivideArray(1,1,sizeX,sizeY,scale#,reduce#)
    
    Img = CreateImage(SizeX,SizeY)
    Save image "TEST_NEW_MAP.jpg",Img
Endfunction

function InitialiseArray(sizeX,sizeY)
    terrainH(1,1) = 0
    terrainH(1,sizeY) = 0
    terrainH(sizeX,1) = 0
    terrainH(sizeX,sizeY) = 0
endfunction


Function DivideArray(X1,Y1,X2,Y2,scale#,reduce#)
    Local H11 as float
    Local H21 as float
    Local H12 as float
    Local H22 as float

    H11=terrainH(X1,Y1)
    H21=terrainH(X2,Y1)
    H12=terrainH(X1,Y2)
    H22=terrainH(X2,Y2)
    
    stepX = X2-X1
    stepY = Y2-Y1
    
    NewX=X1+stepX/2
    NewY=Y1+stepY/2
    
    if marker(NewX,Y1) = 0 then terrainH(NewX,Y1)=(H11+H21)/2.0+(rnd(100)-50)*scale#:marker(NewX,Y1) = 1
    if marker(X1,NewY) = 0 then terrainH(X1,NewY)=(H11+H12)/2.0+(rnd(100)-50)*scale#:marker(X1,NewY) = 1
    if marker(NewX,Y2) = 0 then terrainH(NewX,Y2)=(H12+H22)/2.0+(rnd(100)-50)*scale#:marker(NewX,Y2) = 1
    if marker(X2,NewY) = 0 then terrainH(X2,NewY)=(H21+H22)/2.0+(rnd(100)-50)*scale#:marker(X2,NewY) = 1
    if marker(NewX,NewY) = 0 then terrainH(NewX,NewY)=(H11+H21+H12+H22)/4.0+(rnd(100)-50)*scale#:marker(NewX,NewY) = 1
    
    `show message str$((H11+H21+H12+H22)/4.0+(rnd(100)-50)*scale#)
    if (stepX<=2) and (stepY<=2) then exitfunction
    
    scale# = scale#*reduce#
    DivideArray(X1,Y1,NewX,NewY,scale#,reduce#)
    DivideArray(NewX,Y1,X2,NewY,scale#,reduce#)
    DivideArray(X1,NewY,NewX,Y2,scale#,reduce#)
    DivideArray(NewX,NewY,X2,Y2,scale#,reduce#)
Endfunction

`For multiple heightmap images to line up, the 2 pixels around their borders need to match
Function CreateImage(SizeX,SizeY)
    mem=FreeMem()
    cls
    img=FreeImg()
    get image img,0,0,SizeX,SizeY
    make memblock from image mem,img
    MemW=memblock dword(mem,0)   `First four bytes are WIDTH
    MemH=memblock dword(mem,4)   `Next four bytes are HEIGHT
    `NEXT FOUR ARE DEPTH WHICH HAS ALREADY BEEN SET
    
    `The 2 pixels around the entire edge of the image must be the same as the 3rd pixel for everything to line up
    `This should be accomplished at this level
    `NOTE: TOP LEFT PIXEL IS 0,0 - THIS IS WORKING RIGHT NOW
    `       BOTTOM RIGHT IS 699,699  (IMAGES ARE ZERO INDEX BASED?)
    For X = 0 to sizeX - 1
      For Y = 0 to sizeY - 1
         
         col=int(terrainH(X,Y))
         `col = 255
         
         Pos=(3+x+y*MemW)*4
         if col<0 then col=0
         if col > 200 then col=200
         
         if Pos<  Get Memblock Size(mem)
            Write memblock byte mem,Pos,Col
            Write memblock byte mem,Pos+1,Col
            Write memblock byte mem,Pos+2,Col
         endif
         
      Next Y
    Next X
    
    `we need to check the 3rd pixel along each side and then copy it to the closest 2 pixels along the edge
    For X = 0 to sizeX - 1
        For Y = 0 to sizeY - 1
             Col=int(terrainH(X,Y))
             `col = 255
             if col<0 then col=0
             if col > 200 then col=200
        
        if  Y = 2
            `write -1 pixel
            Write memblock byte mem,(3+x+(Y-1)*MemW)*4,Col
            Write memblock byte mem,(3+x+(Y-1)*MemW)*4+1,Col
            Write memblock byte mem,(3+x+(Y-1)*MemW)*4+2,Col
            `write -2 pixel
            Write memblock byte mem,(3+x+(Y-2)*MemW)*4,Col
            Write memblock byte mem,(3+x+(Y-2)*MemW)*4+1,Col
            Write memblock byte mem,(3+x+(Y-2)*MemW)*4+2,Col
        ENDIF
        
        if Y = SizeY - 3
            `write +1 pixel
            Write memblock byte mem,(3+x+(y+1)*MemW)*4,Col
            Write memblock byte mem,(3+x+(y+1)*MemW)*4+1,Col
            Write memblock byte mem,(3+x+(y+1)*MemW)*4+2,Col
            `write +2 pixel
            Write memblock byte mem,(3+x+(y+2)*MemW)*4,Col
            Write memblock byte mem,(3+x+(y+2)*MemW)*4+1,Col
            Write memblock byte mem,(3+x+(y+2)*MemW)*4+2,Col
        ENDIF
       
       `If we are on the 3rd pixel
        if  X = 2
            `write -1 pixel
            Write memblock byte mem,(3+(x-1)+(y)*MemW)*4,Col
            Write memblock byte mem,(3+(x-1)+(y)*MemW)*4+1,Col
            Write memblock byte mem,(3+(x-1)+(y)*MemW)*4+2,Col
            `write -2 pixel
            Write memblock byte mem,(3+(x-2)+(y)*MemW)*4,Col
            Write memblock byte mem,(3+(x-2)+(y)*MemW)*4+1,Col
            Write memblock byte mem,(3+(x-2)+(y)*MemW)*4+2,Col
        ENDIF
        
        if X = SizeX - 3
            `write +1 pixel
            Write memblock byte mem,(3+(x+1)+(y)*MemW)*4,Col
            Write memblock byte mem,(3+(x+1)+(y)*MemW)*4+1,Col
            Write memblock byte mem,(3+(x+1)+(y)*MemW)*4+2,Col
            `write +2 pixel
            Write memblock byte mem,(3+(x+2)+(y)*MemW)*4,Col
            Write memblock byte mem,(3+(x+2)+(y)*MemW)*4+1,Col
            Write memblock byte mem,(3+(x+2)+(y)*MemW)*4+2,Col
        ENDIF       

        Next Y
    Next X
    
    
    Delete image img
    Make image from memblock img,mem
    Delete memblock mem
Endfunction img


Function FreeMem()
    mem=1
    while memblock exist(mem)
      inc mem
    endwhile
endfunction mem

Function FreeImg()
    Img=1
    while Image exist(Img)
      inc Img
    endwhile
endfunction Img


Function ControlCam(cam,Sp#)
    rotate camera Cam,camera angle x(Cam)+(mousemovey()/2),camera angle y(Cam)+(mousemovex()/2.0),0
    set camera range Cam, 1,2000
    If keystate(17)=1 then move camera Cam,Sp#
    If keystate(31)=1 then move camera Cam,-Sp#
    
    If keystate(30)=1
      Yrotate camera Cam,Camera angle Y(Cam)-90
      Move camera Cam,Sp#
      Yrotate camera Cam,Camera angle Y(Cam)+90
    endif
    
    If keystate(32)=1
      Yrotate camera Cam,Camera angle Y(Cam)+90
      Move camera Cam,Sp#
      Yrotate camera Cam,Camera angle Y(Cam)-90
    endif
    
    if wrapvalue(camera angle x(Cam))>40 and wrapvalue(camera angle x(Cam))<180 then xrotate camera Cam,40
    if wrapvalue(camera angle x(Cam))>180 and wrapvalue(camera angle x(Cam))<280 then xrotate camera Cam,280
    
    `position camera Cam,camera position X(Cam),camera position Y(Cam)-FallVelocity#,camera position Z(Cam)
    position camera Cam,camera position X(Cam),500,camera position Z(Cam)
Endfunction


`FUNCTIONS FROM THE MEMBLOCK IMAGE LIBRARY TO MAKE THE POST SMALLER

function IMG_GET_PIXEL3(memblock as byte, x as integer, y as integer, width as integer, height as integer)
   `show message str$(x) + "," + str$(y) + "," + str$(width) + "," + str$(height)
   pixel = IMG_RGBA(0,0,0,255)
`EDIT COMMENTED OUT AND REPLACED WITH 0,0,0
`   pixel = IMG_RGBA(255,255,255,255)
   if x>-1 and x<width
      if y>-1 and y<height
         n as double integer
         n = (4*((y*width)+x))+12
         pixel = memblock dword(memblock,n)
      endif
   endif
   `oColor = RGBR(pixel)
   `show message oColor
   `Debug(str$(pixel))
   `pixel = int(pixel)
endfunction pixel

//converts 4 seperate colour channels into a single DWORD and returns it.
function IMG_RGBA(r as byte, g as byte, b as byte, a as byte)
   col = (a<<24) + (r<<16) + (g<<8) + b
endfunction col

for x = 1 to 5
for y = 1 to 5
generate_block(x,y)
next y
next x

function update_world()
do
    player_chunk_x_prev = player_chunk_x
    player_chunk_y_prev = player_chunk_y
    player_chunk_x = floor(object position x(1)/640)
    player_chunk_y = floor(object position z(1)/640)
    if player_chunk_x_prev <> player_chunk_x  or player_chunk_y_prev <> player_chunk_y
    if player_chunk_x_prev > player_chunk_x 
         x = chunk_x(pcn)+3
         if x > 5 then x = x - 5
         for y = 1 to 5
             obj_n = chunk_number(x,y)+1
             delete object obj_n : delete object obj_n+25
             tree_start = chunks(obj_n,0,0,4) : tree_end = chunks(obj_n,0,0,5) 
             for t = tree_start to tree_end
                delete object t
             next t
             if file exist("saves\world"+str$(selection)+"\chunk"+str$(player_chunk_x-2)+","+str$(player_chunk_y-3+y)+".bin") = 0 then generate_chunk(obj_n,str$(player_chunk_x-2)+","+str$(player_chunk_y-3+y))
             next coroutine
             make_chunk(obj_n,str$(player_chunk_x-2)+","+str$(player_chunk_y-3+y))
             next coroutine
         NEXT   
         if pcn = 5 or pcn = 10 or pcn = 15 or pcn = 20 or pcn = 25 then pcn = pcn-4 else pcn = pcn+1  
    endif

    if player_chunk_x_prev < player_chunk_x
         x = chunk_x(pcn)-3
         if x < 1 then x = x + 5
         for y = 1 to 5
             obj_n = chunk_number(x,y)+1
             delete object obj_n : delete object obj_n+25
             tree_start = chunks(obj_n,0,0,4) : tree_end = chunks(obj_n,0,0,5) 
             for t = tree_start to tree_end
                delete object t
             next t
             if file exist("saves\world"+str$(selection)+"\chunk"+str$(player_chunk_x+2)+","+str$(player_chunk_y-3+y)+".bin") = 0 then generate_chunk(obj_n,str$(player_chunk_x+2)+","+str$(player_chunk_y-3+y))
             next coroutine
             make_chunk(obj_n,str$(player_chunk_x+2)+","+str$(player_chunk_y-3+y))
             next coroutine
         NEXT  
         if pcn = 1 or pcn = 6 or pcn = 11 or pcn = 16 or pcn = 21 then pcn = pcn+4 else pcn = pcn-1
    endif
    
    if player_chunk_y_prev > player_chunk_y
         y = chunk_y(pcn)+3
         if y > 5 then y = y - 5
         for x = 1 to 5
             obj_n = chunk_number(x,y)+1
             delete object obj_n : delete object obj_n+25
             tree_start = chunks(obj_n,0,0,4) : tree_end = chunks(obj_n,0,0,5) 
             for t = tree_start to tree_end
                delete object t
             next t
             if file exist("saves\world"+str$(selection)+"\chunk"+str$(player_chunk_x-3+x)+","+str$(player_chunk_y-2)+".bin") = 0 then generate_chunk(obj_n,str$(player_chunk_x-3+x)+","+str$(player_chunk_y-2))
             next coroutine
             make_chunk(obj_n,str$(player_chunk_x-3+x)+","+str$(player_chunk_y-2))
             next coroutine
         NEXT  
        if pcn = 1 or pcn = 2 or pcn = 3 or pcn = 4 or pcn = 5 then pcn = pcn+20 else pcn = pcn-5
    endif
    
    if player_chunk_y_prev < player_chunk_y
         y = chunk_y(pcn)-3
         if y < 1 then y = y + 5
         for x = 1 to 5
             obj_n = chunk_number(x,y)+1
             delete object obj_n : delete object obj_n+25
             tree_start = chunks(obj_n,0,0,4) : tree_end = chunks(obj_n,0,0,5) 
             for t = tree_start to tree_end
                delete object t
             next t
             if file exist("saves\world"+str$(selection)+"\chunk"+str$(player_chunk_x-3+x)+","+str$(player_chunk_y+2)+".bin") = 0 then generate_chunk(obj_n,str$(player_chunk_x-3+x)+","+str$(player_chunk_y+2))
             next coroutine
             make_chunk(obj_n,str$(player_chunk_x-3+x)+","+str$(player_chunk_y+2))
             next coroutine
         NEXT  
       if pcn = 21 or pcn = 22 or pcn = 23 or pcn = 24 or pcn = 25 then pcn = pcn-20 else pcn = pcn+5
    endif
    endif
    next coroutine
loop
endfunction

void MATRIX::make_texture2()
{
	// Earlier I loaded the bmp file with the gradient in it.
	// Here I create the 256 textures for the terrain using those
	// colour values.

	// this is the one that's now used (creates 256 textures for the matrix)
	int tile_size = 128;		// tile texture size
	int bm = free_bitmap();
	int grad[256];
	int x, y, xx, yy;
	int col, r, g, b;
	int rr, gg, bb;

	// Load the gradient ramp and store the RGB values
	// It's the only BMP file uses because the DDS wouldn't work
	// properly for some reason...
	dbLoadBitmap( "media\\grad1.bmp", bm );
	dbLockPixels();
	for ( x=0; x<256; x++) {
		grad[x]=dbPoint(x, 0); }
	dbUnlockPixels();
	dbDeleteBitmap( bm );

	// Create the 256 textures with a bit of distortion
	dbCreateBitmap( bm, tile_size * 16, tile_size * 16 );
	dbLockPixels();
	for ( x=0; x<16; x++ ) {
		for ( y=0; y<16; y++ ) {
			// get original RGB
			col = grad[x + (y*16)];
			// separate them
			r = ( col & 0xff0000 ) >> 16;
			g = ( col & 0x00ff00 ) >> 8;
			b = ( col & 0x0000ff );
			for ( xx=0; xx<tile_size; xx++ ) {
				for ( yy=0; yy<tile_size; yy++) {
					// distort the RGB values
					rr = r + ( rand() & 31 ) - 16;
					if ( rr<0 ) rr=0; else if ( rr>255 ) rr=255;
					gg = g + ( rand() & 31 ) - 16;
					if ( gg<0 ) gg=0; else if ( gg>255 ) gg=255;
					bb = b + ( rand() & 31 ) - 16;
					if ( bb<0 ) bb=0; else if ( bb>255 ) bb=255;
					// draw pixel to the correct tile
					dbDot( x * tile_size + xx, y * tile_size + yy, dbRGB(rr, gg, bb) );
				}
			}
		}
	}
	dbUnlockPixels();
	// grab the image and prepare it for the matrix
	dbGetImage( mtext = free_image(), 0,0, tile_size * 16, tile_size * 16 );
	dbDeleteBitmap( bm );
	//dbPrepareMatrixTexture( 1, mtext, 16, 16 );
}

Rem ***** Included Source File *****
`This function is based completely off of the work of WLGfx.  The functionality was provided
`  in C from WLGfx which was brought into DBP.
FUNCTION generateTextureFromGradient()
    path$ = GET DIR$() + "\media\" + "grad1.bmp"
    iTS = 128                       `Tile Size
    iBMID = FIND FREE BITMAP()      `Bitmap ID
    DIM arrGrad(256)                `Holds the color value from each pixel of the gradient
    
    LOAD BITMAP path$, iBMID
    
    LOCK PIXELS
    `Fill the gradient array
    FOR x = 0 TO (256-1)
        arrGrad(x) = POINT(x,0)
    NEXT x
    UNLOCK PIXELS
    
    `Finished - clear the bitmap
    DELETE BITMAP iBMID
    
    CREATE BITMAP iBMID,(iTS * 16),(iTS * 16)
    LOCK PIXELS
    `Zero based loop, loop to count-1
    FOR x = 0 TO 15
        FOR y = 0 TO 15
            col = arrGrad(x + (y*16))
            `WLGfx's code used something different but I believe the goal was to get the RGB values from the color
            r = RGBR(col)
            g = RGBG(col)
            b = RGBB(col)
            
            `This loops the tile size... so 128 -1
            FOR xx = 0 TO 127
                FOR yy = 0 TO 127
                    rr = r + (rnd(31)) - 16
                    gg = r + (rnd(31)) - 16
                    bb = r + (rnd(31)) - 16
                    
                    `Check the values
                    IF rr < 0 THEN rr = 0 : IF rr > 255 THEN rr = 255
                    IF gg < 0 THEN gg = 0 : IF gg > 255 THEN gg = 255
                    IF bb < 0 THEN bb = 0 : IF bb > 255 THEN bb = 255
                    `Draw the dot on the correct tile
                    DOT (x * iTS) + xx,(y * iTS) + yy, RGB(rr,gg,bb)
                NEXT yy
            NEXT xx
        NEXT y
    NEXT x
    UNLOCK PIXELS
    img = FIND FREE IMAGE()
    GET IMAGE img,0,0,iTS*16,iTS*16
    DELETE BITMAP iBMID
ENDFUNCTION img

    img = generateTextureFromGradient()
    PREPARE MATRIX TEXTURE iMATRIXID, img, 16,16

function MATRIX_MAKE_TEXTURE2()
    local tile_size as integer
    local bm as integer
    local dim grad(256) as integer
    local x as integer
    local y as integer
    local xx as integer
    local yy as integer
    local col as integer
    local r as integer
    local rr as integer
    local g as integer
    local gg as integer
    local b as integer
    local bb as integer
    
    tile_size = 128
    
    ` load the gradient and store the colours in the local array
    bm = free_bitmap()
    Load Bitmap "media\grad1.bmp", bm
    
    Lock Pixels
    for x=0 to 255
        grad(x)=Point(x,0)
    NEXT
    Unlock Pixels
    
    Delete Bitmap bm
    
    ` create a tiled map of 256 textures for the matrix
    bm = free_bitmap()
    x=tile_size*16
    Create Bitmap bm, x, x
    
    Lock Pixels
    
    for x=0 to 15
        for y=0 to 15
            ` get original RGB's
            col=grad(x+(y*16))
            
            ` separate them
            r=(col and 0xff0000)>>16
            g=(col and 0x00ff00)>>8
            b=(col and 0x0000ff)
            
            for xx=0 to tile_size-1
                for yy=0 to tile_size-1
                    ` distort the RGB values
                    rr=r+rnd(32)-16
                    gg=g+rnd(32)-16
                    bb=b+rnd(32)-16
                    
                    if rr<0 then rr=0
                    if rr>255 then rr=255
                    
                    if gg<0 then gg=0
                    if gg>255 then gg=255
                    
                    if bb<0 then bb=0
                    if bb>255 then bb=255
                    
                    Dot x*tile_size+xx,y*tile_size+yy,RGB(rr,gg,bb)
                next
            next
        NEXT
    NEXT
    
    Unlock Pixels
    
    mat.mtext = free_image()
    Get Image mat.mtext, 0, 0, tile_size*16, tile_size*16
    
    Delete Bitmap bm
ENDFUNCTION

RANDOMIZE TIMER()
Set Display Mode 800 , 600 , 32
sync on : sync rate 120 : color backdrop 0

NOISE SET PARAMS 0, 6.5, .25, 1.5, 1.25, 0

`OBJECT ID CONSTANTS
#CONSTANT iCHARACTERID 1
#CONSTANT iCAMID 0
#CONSTANT iMATRIXID 1
`OBJECT ID CONSTANTS

`How big is the block size? options are 4x4 - 12x12 in multiples of 2
`TO DO - MOVE THIS INTO THE MATRIX TYPE
DIM iBlockCount(0)
iBlockCount(0) = 4

`This is the count before the map marker changes - used in virtual X-Z positioning
`TO DO - MOVE THIS INTO THE MATRIX TYPE
DIM iSegmentLength(0)
iSegmentLength(0) = 256

`Number of segments across the matrix
`TO DO - MOVE THIS INTO THE MATRIX TYPE
DIM iSegmentCount(0)
iSegmentCount(0) = 256

`This is the length of the matrix true space measurement
`TO DO - MOVE THIS INTO THE MATRIX TYPE
DIM iMatrixLengthXZ(0)
iMatrixLengthXZ(0) = iSegmentLength(0) * iSegmentCount(0)

`TO DO - MOVE THIS INTO THE MATRIX TYPE
DIM iStepDistance(0)
`Control the speed of your movement here
iStepDistance(0) = 10 `This is the step distance or STEP VALUE for movement

`TO DO - MOVE THIS INTO THE MATRIX TYPE
DIM iCamDrawDist(0)
dist = iMatrixLengthXZ(0) * 2
iCamDrawDist(0) = dist



`######## GENERATE THE MATRIX
MAKE MATRIX iMATRIXID,iMatrixLengthXZ(0),iMatrixLengthXZ(0),iSegmentCount(0),iSegmentCount(0)
`######## GENERATE THE MATRIX

`######## LIGHTING NORMALS FOR MATRIX
DIM normals#(iSegmentCount(0),iSegmentCount(0),1)

`Test array for handling my terrain
DIM arrTerrain(iSegmentCount(0),iSegmentCount(0),1)

`######## GET THE CENTER OF THE MATRIX
centerX=int((iSegmentCount(0))/2)
centerZ=int((iSegmentCount(0))/2)
iCenterX = centerX      `Set the center of the map
iCenterZ = centerZ      `Set the center of the map
centerX = int(iMatrixLengthXZ(0) / 2)
centerZ = int(iMatrixLengthXZ(0) / 2)
iMCenterX = centerX
iMCenterZ = centerZ
`######## GET THE CENTER OF THE MATRIX

`#### MAKE CAMERA
POSITION CAMERA iCAMID,iMCenterX,400.0,iMCenterZ
XROTATE CAMERA iCAMID,25
SET CAMERA RANGE iCAMID,200, iCamDrawDist(0)
`#### MAKE CAMERA

`######## MAKE A CHARACTER OBJECT
make object sphere iCHARACTERID,25
color object iCHARACTERID,rgb(0,0,255)
position object iCHARACTERID,iMCenterX,15,iMCenterZ
`######## MAKE A CHARACTER OBJECT
    
`#######################################################
`This type holds all the scroll data for the matrix code
TYPE MatrixScrollData
    x# AS FLOAT             `X position
    h# AS FLOAT             `H (Y) position
    z# AS FLOAT             `Z position
    oldx# AS FLOAT          `previous X for ref during movement
    oldz# AS FLOAT          `previous Z for ref during movement
    oldh# AS FLOAT          `previous H(Y) for ref during movement

    shx# AS FLOAT           `ShiftX - Used as our counter for map coordinates
    shz# AS FLOAT           `ShiftZ - Used as our counter for map coordinates

    fMapX# AS FLOAT
    fMapZ# AS FLOAT

    `I don't really need this as it can be calculated.  It won't be included in the map file    
    iMatX AS INTEGER        `The MATRIX X coordinate - this accounts for the scrolling
    iMatZ AS INTEGER        `The MATRIX Z coordinate - this accounts for the scrolling
    
    iViewRange AS INTEGER   `View Range modifier
    
    mx# AS FLOAT            `New matrix location X
    mz# AS FLOAT            `New matrix location Z

    `Direction Controls
    dirUp AS INTEGER
    dirDown AS INTEGER
    dirLeft AS INTEGER
    dirRight AS INTEGER
    
    `These are the maximum coordinates used in calculating the location of the data in the map file
    iMinX# AS FLOAT
    iMaxX# AS FLOAT
    iMinZ# AS FLOAT
    iMaxZ# AS FLOAT

        
ENDTYPE
`#######################################################

DIM oMSD(0) AS MatrixScrollData
oMSD(0).x# = iMCenterX              `FLOAT
oMSD(0).z# = iMCenterZ              `FLOAT
oMSD(0).iMatX = iSegmentCount(0) / 2 `INTEGER 
oMSD(0).iMatZ = iSegmentCount(0) / 2 `INTEGER
oMSD(0).iViewRange = iMCenterZ     `INTEGER

`These are the Min/Max coordinates used in calculating the location of the data in the map file
oMSD(0).iMaxX# = (iSegmentCount(0) * iBlockCount(0)) / 2
oMSD(0).iMaxZ# = (iSegmentCount(0) * iBlockCount(0)) / 2
oMSD(0).iMinX# = oMSD(0).iMaxX# * -1.0
oMSD(0).iMinZ# = oMSD(0).iMaxZ# * -1.0


set matrix 1,0,0,1,2,1,1,1
set matrix trim 1,0.004,0.004

backgroundcolor=RGB(136,164,200)
color backdrop backgroundcolor
set ambient light 60
set directional light 0,7,-3,0
color light 0,200,200,200
set light range 0,100000

fog on
fog distance iMatrixLengthXZ(0)*0.7
fog color backgroundcolor

`Update our matrix before we actually start our game loop so that it picks up our heights
`for the viewable area
UpdateMatrix()

DO
    oMSD(0).oldx# = oMSD(0).x#
    oMSD(0).oldz# = oMSD(0).z#
    oMSD(0).oldh# = oMSD(0).h#
    
    `WRAP( Current Value, Min Value, Max Value)
    oMSD(0).fMapX# = WRAP((oMSD(0).x# / iSegmentLength(0)),oMSD(0).iMinX#,oMSD(0).iMaxX#)
    oMSD(0).fMapZ# = WRAP((oMSD(0).z# / iSegmentLength(0)),oMSD(0).iMinZ#,oMSD(0).iMaxZ#)
    
    `#################################################################################################
    `DEBUG STATEMENTS FOR DISPLAY DURING RUNTIME
    `ink RGB(136,164,200), RGB(0,0,0)
    SET CURSOR 0,0
    `print "oldX:";str$(oMSD(0).oldx#);" oldY: ";str$(oMSD(0).oldh#);" oldZ: ";str$(oMSD(0).oldz#)
    print "FPS:";screen fps()
    `print  "SHX/SHZ: " + STR$(oMSD(0).shx#) + "," + STR$(oMSD(0).shz#) + " STEPVAL: " + STR$(iSegmentLength(0))
    print "X:";str$(oMSD(0).x#);" Y: ";str$(oMSD(0).h#);" Z: ";str$(oMSD(0).z#)
    `print "iMapX :";str$(oMSD(0).iMapX);" iMapZ :";str$(oMSD(0).iMapZ)
    print "fMapX :";str$(oMSD(0).fMapX#);" fMapZ :";str$(oMSD(0).fMapZ#)
    print "MAT X :";str$(oMSD(0).iMatX);" MAT Z :";str$(oMSD(0).iMatZ)
    `print "CAM POS X:";camera position x(iCAMID);" CAM POS Y: ";camera position y(iCAMID);" CAM POS Z: ";camera position z(iCAMID)
    `print "CHAR POS X:";object position x(iCHARACTERID);" CHAR POS Y: ";object position y(iCHARACTERID);" CHAR POS Z: ";object position z(iCHARACTERID)
    print "CHAR ANGLE Y: ";iCharAngleY#
    print "MX:" + STR$(mx#) + " MZ:" + STR$(mz#)
    `#################################################################################################


    `IF isMoving > 0 THEN print "CHARACTER MOVING"
    isMoving = 0        `Is the character moving?
    If Upkey()=1 then isMoving = 1
    if Downkey() = 1 then isMoving = 2
    
    s#=0              `This is involved with stepping movement
    if isMoving = 1 and s# < iStepDistance(0) then s# = s# + iStepDistance(0)
    if isMoving = 2 and s# > -1.0*iStepDistance(0) then s# = s# - iStepDistance(0)

    `######
    `this is our movement/stepping bit of code - newvalue gets the location of the next s# sized step
    oMSD(0).x# = newxvalue(oMSD(0).x#,iCharAngleY#,s#)
    oMSD(0).z# = newzvalue(oMSD(0).z#,iCharAngleY#,s#)
    oMSD(0).h# = get ground height(1,oMSD(0).x#-oMSD(0).mx#,oMSD(0).z#-oMSD(0).mz#)
    `######
    
    `If the character is moving, setup the calculations for moving the map matrix
    ` and fire the controlMatrix() function
    if isMoving > 0
        oMSD(0).shx# = oMSD(0).shx# + (oMSD(0).x# - oMSD(0).oldx#)
        oMSD(0).shz# = oMSD(0).shz# + (oMSD(0).z# - oMSD(0).oldz#)
        controlMatrix()
    endif

    `Get the angle (direction) on the Y axis that the character is facing
    ` We use this to power the compass eventually!
    iCharAngleY# = OBJECT ANGLE Y(iCHARACTERID)
    
    
    `######## CONTROL THE SCENE
    If Leftkey()=1 then Yrotate object iCHARACTERID,Wrapvalue(iCharAngleY#-2)
        yrotate camera Wrapvalue(iCharAngleY#-2)
    If Rightkey()=1 then Yrotate object iCHARACTERID,Wrapvalue(iCharAngleY#+2) 
        yrotate camera Wrapvalue(iCharAngleY#+2)
    
    Position camera iCAMID,oMSD(0).x#,oMSD(0).h#+400,oMSD(0).z#
    position object iCHARACTERID,oMSD(0).x#,oMSD(0).h#,oMSD(0).z#

    `IF WE HIT THE 2 KEY, SWITCH TO VIEW 2
    IF KEYSTATE(3) = 1
        print "View 2"
        POSITION CAMERA iCAMID,camera position x(iCAMID),25000.0,camera position z(iCAMID)
        `POSITION CAMERA iCAMID,0,999.0,0
        `Camera 2 has a downward pointing view
        XROTATE CAMERA iCAMID,30
    ELSE
        print "View 1"
        POSITION CAMERA iCAMID,camera position x(iCAMID),OBJECT POSITION Y(iCHARACTERID) + 200.0,camera position z(iCAMID)-300
        `POSITION CAMERA iCAMID,0,400.0,0
        `Camera 2 has a downward pointing view
        XROTATE CAMERA iCAMID,25
    ENDIF
    `######## CONTROL THE SCENE

    IF KEYSTATE(4) = 1
        print "View 3"
        POSITION CAMERA iCAMID,camera position x(iCAMID),10000.0,camera position z(iCAMID) + 300
        `POSITION CAMERA iCAMID,0,999.0,0
        `Camera 2 has a downward pointing view
        XROTATE CAMERA iCAMID,90
    ENDIF
    
    sync
LOOP
    
`##############################################################################################################
`##############################################################################################################
`##############################################################################################################

function controlMatrix()
    oMSD(0).dirUp = 0
    oMSD(0).dirDown = 0
    oMSD(0).dirLeft = 0
    oMSD(0).dirRight = 0
        
    if LatentShift = 0
        rem up
        IF oMSD(0).shz# >= iSegmentLength(0)
            `Matrix Shift variable controller
            oMSD(0).shz# = (oMSD(0).shz# - iSegmentLength(0)) - 1

            `Map Location controller
            `oMSD(0).iMapZ = oMSD(0).iMapZ + 1

            `Matrix Location counter - This is not a point counter, it counts which area we are in
            ` based on a ZERO index -- SO it's ZERO to (iSegmentCount(0) -1)
            oMSD(0).iMatZ = oMSD(0).iMatZ + 1
            if oMSD(0).iMatZ >= iSegmentCount(0) then oMSD(0).iMatZ = 0
            
            `Direction Controls
            oMSD(0).dirUp = 1
        ENDIF

        rem down
        IF oMSD(0).shz# < 0.0
            `Matrix Shift variable controller
            oMSD(0).shz# = (oMSD(0).shz# + iSegmentLength(0))
            
            `Map Location controller
            `oMSD(0).iMapZ = oMSD(0).iMapZ - 1
            
            
            `Matrix Location counter - This is not a point counter, it counts which area we are in
            ` based on a ZERO index -- SO it's ZERO to (iSegmentCount(0) -1)
            oMSD(0).iMatZ = oMSD(0).iMatZ - 1
            if oMSD(0).iMatZ < 0 then oMSD(0).iMatZ = iSegmentCount(0) - 1
            
            `Direction Controls
            oMSD(0).dirDown = 1
        ENDIF

         if dirup=1 or dirdown=1
            rem prepare for latent shift
            LatentShift=1
         else
            rem left
            IF oMSD(0).shx# >= iSegmentLength(0)
                oMSD(0).shx# = (oMSD(0).shx# - iSegmentLength(0))
                
                `oMSD(0).iMapX = oMSD(0).iMapX + 1
                
                `Matrix Location counter - This is not a point counter, it counts which area we are in
                ` based on a ZERO index -- SO it's ZERO to (iSegmentCount(0) -1)
                oMSD(0).iMatX = oMSD(0).iMatX - 1
                if oMSD(0).iMatX < 0 then oMSD(0).iMatX = iSegmentCount(0)
                
                `Direction Controls
                oMSD(0).dirLeft = 1
            ENDIF

            rem right
            IF oMSD(0).shx# < 0.0
                oMSD(0).shx# = (oMSD(0).shx# + iSegmentLength(0))
                
                `oMSD(0).iMapX = oMSD(0).iMapX - 1
                
                `Matrix Location counter - This is not a point counter, it counts which area we are in
                ` based on a ZERO index -- SO it's ZERO to (iSegmentCount(0) -1)
                oMSD(0).iMatX = oMSD(0).iMatX + 1
                if oMSD(0).iMatX > iSegmentCount(0) then oMSD(0).iMatX = 0
                
                `Direction Controls
                oMSD(0).dirRight = 1
            ENDIF

         endif `if dirup=1 or dirdown=1
    else `else latent shift is not 0 
        LatentShift=0
        rem left
        IF oMSD(0).shx# >= iSegmentLength(0)
            oMSD(0).shx# = (oMSD(0).shx# - iSegmentLength(0))
            
            `oMSD(0).iMapX = oMSD(0).iMapX + 1
            
            `Matrix Location counter - This is not a point counter, it counts which area we are in
            ` based on a ZERO index -- SO it's ZERO to (iSegmentCount(0) -1)
            oMSD(0).iMatX = oMSD(0).iMatX - 1
            if oMSD(0).iMatX < 0 then oMSD(0).iMatX = iSegmentCount(0)
            
            `Direction Controls
            oMSD(0).dirLeft = 1
        ENDIF

        rem right
        IF oMSD(0).shx# < 0.0
            oMSD(0).shx# = (oMSD(0).shx# + iSegmentLength(0))
            
            `oMSD(0).iMapX = oMSD(0).iMapX - 1

            `Matrix Location counter - This is not a point counter, it counts which area we are in
            ` based on a ZERO index -- SO it's ZERO to (iSegmentCount(0) -1)
            oMSD(0).iMatX = oMSD(0).iMatX + 1
            if oMSD(0).iMatX > iSegmentCount(0) then oMSD(0).iMatX = 0

            `Direction Controls
            oMSD(0).dirRight = 1
        ENDIF

    endif `if LatentShift=0

    `######## PLAYER MOVEMENT UP ########
    IF oMSD(0).dirUp = 1
        `Loop through each segment on the matrix on ONE axis
        `Perform all maths based on the one axis
        FOR iSeg = 0 TO iSegmentCount(0)

        

        NEXT iSeg
        `Perform the matrix shift
        SHIFT MATRIX DOWN iMATRIXID
    ENDIF `IF oMSD(0).dirUp = 1
    `######## PLAYER MOVEMENT UP ########


    `######## PLAYER MOVEMENT DOWN ########
    IF oMSD(0).dirDown = 1
        `Loop through each segment on the matrix on ONE axis
        `Perform all maths based on the one axis
        FOR iSeg = 0 TO iSegmentCount(0) - 1
            
            
        NEXT iSeg
        `Perform the matrix shift
        SHIFT MATRIX UP iMATRIXID
    ENDIF `IF oMSD(0).dirDown = 1
    `######## PLAYER MOVEMENT DOWN ########


    `######## PLAYER MOVEMENT LEFT ########
    IF oMSD(0).dirLeft = 1
        `Loop through each segment on the matrix on ONE axis
        `Perform all maths based on the one axis
        FOR iSeg = 0 TO iSegmentCount(0) - 1
                       

        NEXT iSeg
        `Perform the matrix shift
        SHIFT MATRIX LEFT iMATRIXID
    ENDIF `IF oMSD(0).dirDown = 1
    `######## PLAYER MOVEMENT LEFT ########

    `######## PLAYER MOVEMENT RIGHT ########
    IF oMSD(0).dirRight = 1
        `Loop through each segment on the matrix on ONE axis
        `Perform all maths based on the one axis
        FOR iSeg = 0 TO iSegmentCount(0) - 1




        NEXT iSeg
        `Perform the matrix shift
        SHIFT MATRIX RIGHT iMATRIXID
    ENDIF `IF oMSD(0).dirDown = 1
    `######## PLAYER MOVEMENT RIGHT ########

    rem reposition matrix
    oMSD(0).mx# = (oMSD(0).x# - oMSD(0).iViewRange) - oMSD(0).shx#
    oMSD(0).mz# = (oMSD(0).z# - oMSD(0).iViewRange) - oMSD(0).shz#
    position matrix iMATRIXID,oMSD(0).mx#,0,oMSD(0).mz#
    
    `print "MOVE MATRIX: " + STR$(oMSD(0).mx#) + "," + STR$(oMSD(0).mz#)
    `print "UP:";STR$(dirup);" DOWN:";STR$(dirdown);" LEFT:";STR$(dirleft);" RIGHT:";STR$(dirright)
    
ENDFUNCTION

`##############################################################################################################

`This is the function that actually generates the terriain data
function UpdateMatrix()
    `Generates a texture from a gradient image
    `generateTextureFromGradient()
    `img = generateTextureFromGradient()
    `PREPARE MATRIX TEXTURE Matrix Number, Image Number, Across, Down
    `PREPARE MATRIX TEXTURE iMATRIXID, img, 16,16
    
    set matrix wireframe off 1
    for x = 0 to iSegmentCount(0)
        for z = 0 to iSegmentCount(0)
            hgt = abs(NOISE GET HEIGHT TILED(0,x,z,100,100)) * 255
            `hgt = abs(NOISE GET HEIGHT(0,x,z)) * 255
            set matrix height iMATRIXID,x,z,hgt
            
            calcNormal(x,hgt,z)
            nx#=sin(normals#(x,z,0))
            ny#=cos(normals#(x,z,0))
            nz#=sin(normals#(x,z,1))
            set matrix normal iMATRIXID,x,z,1*nx#,1*ny#,1*nz#
        NEXT z
    NEXT x
    UPDATE MATRIX iMATRIXID
ENDFUNCTION

`##############################################################################################################

FUNCTION calcNormal(x,y,z)
    rem  Verteces on the matrix
    rem    x-1,z-1    x,z-1
    rem    x-1,z      x,z
    rem Get stored heights

    h8# = GET MATRIX HEIGHT(iMATRIXID,x,WRAP((z-1),0,256))
    h4# = GET MATRIX HEIGHT(iMATRIXID,WRAP((x-1),0,256),z)
    h1# = GET MATRIX HEIGHT(iMATRIXID,x,z)
    
    rem Calculate projected angle X using heights
    y1#=h1#
    y2#=h4#
    rem X distance is a function of step#
    dx#=iSegmentLength(0) / 4
    rem Y distance is the difference in height
    dy#=y2#-y1#
    ax#=atanfull(dx#,dy#)
    ax#=wrapvalue(90-ax#)
    
    rem Calculate projected angle Z using heights
    y1#=h1#
    y2#=h8#
    rem Z distance is a function of step#
    dz#=iSegmentLength(0) / 4
    rem Y distance is the difference in height
    dy#=y2#-y1#
    az#=atanfull(dz#,dy#)
    az#=wrapvalue(90-az#)
    
    rem save normal angles in an array
    normals#(x,z,0)=ax#
    normals#(x,z,1)=az#
    
ENDFUNCTION

. . . .
. . . .
. . . .
. . . .
0

(0,0), (0,1), (1,1)
A       B      C

x=(255*40)/1000 = 10.2
z=(255*40)/1000 = 10.2

(0,100,0) , (0,30,10.2) , (10.2,127,10.2)
A            B             C

void PROC_MAP::_NORMALISE()
{
	//
	// Now to normalise all the verts
	//

	_VERT*	vptr = &verts[0];
	_FACE*	fptr = &faces[0];

	int		vsize = verts.size();
	int		fsize = faces.size();

	int		loop;

	// first clear all the normals
	//
	// Also be adding the noise height in here while I'm at it
	//
	// Oh and by the way, let's calculate the texture coords
	//

	for ( loop = 0; loop < vsize; loop++ )
	{
		vptr->nx = vptr->ny = vptr->nz = 0.0f;		// that's the normals cleared
		
		vptr->s = vptr->x / (float)size_max;		// setting texture coords here
		vptr->t = vptr->z / (float)size_max;

		vptr->y = vptr->y + get_noise( vptr->x, vptr->z );	// and the noise height

		vptr++;
	}

	// reset vptr
	vptr = &verts[0];

	// vars used for the normals calcs
	float	x1, y1, z1;
	float	x2, y2, z2;
	float	x3, y3, z3;
	float	normx, normy, normz;
	float	normlength;

	int		v1, v2, v3;

	int*	vcount = new int[vsize];			// counts the faces a vertex has
	memset( vcount, 0, sizeof(int)*vsize );		// set all values to 0

	// now loop through all the faces and get the normals and average the vert normals
	for ( loop = 0; loop < fsize; loop++ )
	{
		// reverse the faces for the CW face orientation
		v1 = fptr->v1;		v2 = fptr->v3;		v3 = fptr->v2;

		x1 = vptr[v1].x;	y1 = vptr[v1].y;	z1 = vptr[v1].z;
		x2 = vptr[v2].x;	y2 = vptr[v2].y;	z2 = vptr[v2].z;
		x3 = vptr[v3].x;	y3 = vptr[v3].y;	z3 = vptr[v3].z;

		normx = (z1-z2)*(y3-y2)-(y1-y2)*(z3-z2);
		normy = (x1-x2)*(z3-z2)-(z1-z2)*(x3-x2);
		normz = (y1-y2)*(x3-x2)-(x1-x2)*(y3-y2);

		// change this to a fast square root algorithm
		normlength = sqrt((normx*normx)+(normy*normy)+(normz*normz));

		normx /= normlength;
		normy /= normlength;
		normz /= normlength;

		// add this faces normal to all three verts
		vptr[v1].nx = ( vptr[v1].nx + normx );
		vptr[v1].ny = ( vptr[v1].ny + normy );
		vptr[v1].nz = ( vptr[v1].nz + normz );

		vptr[v2].nx = ( vptr[v2].nx + normx );
		vptr[v2].ny = ( vptr[v2].ny + normy );
		vptr[v2].nz = ( vptr[v2].nz + normz );

		vptr[v3].nx = ( vptr[v3].nx + normx );
		vptr[v3].ny = ( vptr[v3].ny + normy );
		vptr[v3].nz = ( vptr[v3].nz + normz );

		vcount[v1]++;	// increment the vert normal count for averaging
		vcount[v2]++;
		vcount[v3]++;

		fptr++;			// almost forgot to move the face pointer onwards
	}

	// now average the normals by the face count
	for ( loop = 0; loop < vsize; loop++ )
	{
		vptr[loop].nx = vptr[loop].nx / (float)vcount[loop];
		vptr[loop].nx = vptr[loop].nx / (float)vcount[loop];
		vptr[loop].nx = vptr[loop].nx / (float)vcount[loop];
	}

	// free the temp vertex faces count
	delete[] vcount;
}

	for ( loop = 0; loop < vsize; loop++ )
	{
		vptr[loop].nx = vptr[loop].nx / (float)vcount[loop];
		vptr[loop].nx = vptr[loop].nx / (float)vcount[loop];
		vptr[loop].nx = vptr[loop].nx / (float)vcount[loop];
	}

FUNCTION calcNormal(x,y,z)
    rem  Verteces on the matrix
    rem    x-1,z-1    x,z-1
    rem    x-1,z      x,z
    rem Get stored heights

    h8# = GET MATRIX HEIGHT(iMATRIXID,x,WRAP((z-1),0,256))
    h4# = GET MATRIX HEIGHT(iMATRIXID,WRAP((x-1),0,256),z)
    h1# = GET MATRIX HEIGHT(iMATRIXID,x,z)
    
    rem Calculate projected angle X using heights
    y1#=h1#
    y2#=h4#
    rem X distance is a function of step#
    dx#=iSegmentLength(0) / 4
    rem Y distance is the difference in height
    dy#=y2#-y1#
    ax#=atanfull(dx#,dy#)
    ax#=wrapvalue(90-ax#)
    
    rem Calculate projected angle Z using heights
    y1#=h1#
    y2#=h8#
    rem Z distance is a function of step#
    dz#=iSegmentLength(0) / 4
    rem Y distance is the difference in height
    dy#=y2#-y1#
    az#=atanfull(dz#,dy#)
    az#=wrapvalue(90-az#)
    
    rem save normal angles in an array
    normals#(x,z,0)=ax#
    normals#(x,z,1)=az#
    
ENDFUNCTION

iTiles = 4 * 128
set matrix wireframe off 1
for x = 0 to 128
    for z = 0 to 128
        hgt# = NOISE GET HEIGHT TILED(0,x,z,iTiles,iTiles) * 255
        set matrix height iMATRIXID,x,z,hgt#
     NEXT z
NEXT x
WL MATRIX NORMALISE 1
UPDATE MATRIX 1

    hgt# = NOISE GET HEIGHT TILED(0,x,z,512,512) * 255

RANDOMIZE TIMER()
Set Display Mode 800 , 600 , 32
sync on : sync rate 120 : color backdrop 0

TYPE MatrixData
    `How many NxN blocks exist in this world's map?
    iBlocksCount AS INTEGER
    `The number of points across the axis of the matrix.
    iSegPoints AS INTEGER
    `The length of the segment BETWEEN 2 points... this is the space between (0,0) and (0,1) for instance
    iSegLength AS INTEGER
    `The acutual length of the axis of the matrix... the whole side
    iAxisLength AS INTEGER
    `Marker for the center point of the matrix object
    iAxisCenter AS INTEGER
    `How far do we travel with each step
    fStepDistance# AS FLOAT
    
    `The max point (and inverse min) point where the map should wrap
    iMaxPoint AS INTEGER

    fPosX# AS FLOAT : fPosZ# AS FLOAT
    fPosY# AS FLOAT

    `These hold the OLD X,Z position before stepping to the new position
    fOPosX# AS FLOAT : fOPosZ# AS FLOAT
    
    `These are both here to check any differences between using real/integer values
    `Changed from float to integer - looks to be ok - this is like locking to a grid
    fMatPosX# AS FLOAT : fMatPosZ# AS FLOAT 
    `When the matrix moves, the 0,0 point of the matrix sits at these coordinates
    iMatPosX AS INTEGER : iMatPosZ AS INTEGER
    `Matrix shifting values
    fSHX# AS FLOAT : fSHZ# AS FLOAT
    `Direction Controls
    dirUp AS INTEGER : dirDown AS INTEGER : dirLeft AS INTEGER : dirRight AS INTEGER
    
    `Latent Shift controller - may wind up being removed
    iLS AS INTEGER
    
    ic AS INTEGER
ENDTYPE

`NOISE SET PARAMS 0, 5, .0039, .00045, 1, 0
NOISE SET PARAMS 0, 5, .339, .240, 1, 0

`Type data does not need to be an array
oMD AS MatrixData
oMD.iBlocksCount = 4
oMD.fStepDistance# = 2
oMD.iSegPoints = 128
oMD.iAxisLength = 1024
oMD.iAxisCenter = (oMD.iAxisLength/2)

oMD.fPosX# = oMD.iAxisCenter
oMD.fPosZ# = oMD.iAxisCenter

oMD.iSegLength = (oMD.iAxisLength / oMD.iSegPoints)
oMD.iMaxPoint = (oMD.iSegPoints * oMD.iBlocksCount)

oMD.ic = 0
oMD.iLS = 0

`#########################################################
`These are for the debugging code I wrote
DIM iDFC(0)
iDFC(0) = 32
`We will start all our counts at 1
`Structure:
`   arrDebugFiles(x,0) = fileid
`   arrDebugFiles(x,1) = filename
`   arrDebugFiles(x,2) = is file open CURRENTLY
DIM arrDebugFiles$(iDFC(0),2)
`#########################################################

`OBJECT ID CONSTANTS
#CONSTANT iCHARACTERID 1
#CONSTANT iCAMID 1
#CONSTANT iMATRIXID 1
`OBJECT ID CONSTANTS

`######## GENERATE THE MATRIX
`oMD.iSegPoints = 256 oMD.iAxisLength = 256
MAKE MATRIX iMATRIXID,oMD.iAxisLength,oMD.iAxisLength,oMD.iSegPoints,oMD.iSegPoints
position matrix iMATRIXID,0,0,0
`######## GENERATE THE MATRIX

`#### MAKE CAMERA
`oMD.iAxisCenter
make camera iCAMID
POSITION CAMERA iCAMID,oMD.iAxisCenter,50.0,oMD.iAxisCenter-50
XROTATE CAMERA iCAMID,30
`SET CAMERA RANGE iCAMID,1, iCamDrawDist(0)
`#### MAKE CAMERA

`######## MAKE A CHARACTER OBJECT
make object sphere iCHARACTERID,5
color object iCHARACTERID,rgb(0,0,255)
position object iCHARACTERID,oMD.iAxisCenter,5,oMD.iAxisCenter
`######## MAKE A CHARACTER OBJECT
    
set matrix 1,0,0,1,2,1,1,1
set matrix trim 1,0.004,0.004

`backgroundcolor=RGB(136,164,200)
`color backdrop backgroundcolor
set ambient light 60
set directional light 0,7,-3,0
color light 0,200,200,200
`set light range 0,100000

`fog on
`fog distance iMatrixLengthXZ(0)*0.7
`fog color backgroundcolor

`Update our matrix before we actually start our game loop so that it picks up our heights
`for the viewable area
UpdateMatrix()

Yrotate object iCHARACTERID,355

DO
    `Set our old variables
    oMD.fOPosX# = oMD.fPosX#
    oMD.fOPosZ# = oMD.fPosZ#  
    oMD.fPosY# = get ground height(iMATRIXID,oMD.fPosX#,oMD.fPosZ#)
    `Handle the wrapping of the map values here
    `WRAP( Current Value, Min Value, Max Value)
    `oMD(0).fMapX# = WRAP((oMSD(0).x# / oMD.iAxisLength),oMSD(0).iMinX#,oMSD(0).iMaxX#)
    `oMSD(0).fMapZ# = WRAP((oMSD(0).z# / oMD.iAxisLength),oMSD(0).iMinZ#,oMSD(0).iMaxZ#)
    
    `#################################################################################################
    `DEBUG STATEMENTS FOR DISPLAY DURING RUNTIME
    ink RGB(255,0,0), RGB(0,0,0)
    SET CURSOR 0,0
    print "FPS:";screen fps()
    print "CHAR ANGLE Y: ";iCharAngleY#
    print "Segment Length: " + str$(oMD.iSegLength)
    print "X:";str$(oMD.fPosX#);" Y: ";str$(oMD.fPosY#);" Z: ";str$(oMD.fPosZ#)
    print "fSHX:";str$(oMD.fSHX#);"  fSHZ: ";str$(oMD.fSHZ#)
    print "Up: " + str$(oMD.dirUp) + " Down: " + str$(oMD.dirDown) + " Left: " + str$(oMD.dirLeft) + " Right: " + str$(oMD.dirRight)
    print "MatPosX: " + str$(oMD.iMatPosX) + " MatPosZ: " + str$(oMD.iMatPosZ)
    print "MatPosX: " + str$(oMD.fMatPosX#) + " MatPosZ: " + str$(oMD.fMatPosZ#)

    `#################################################################################################


    `IF isMoving > 0 THEN print "CHARACTER MOVING"
    isMoving = 0        `Is the character moving?
    If Upkey()=1 then isMoving = 1
    if Downkey() = 1 then isMoving = 2
    
    `Control roatation quickly 
    IF KEYSTATE(72) = 1 : Yrotate object iCHARACTERID,0 : ENDIF
    IF KEYSTATE(80) = 1 : Yrotate object iCHARACTERID,180 : ENDIF
    IF KEYSTATE(75) = 1 : Yrotate object iCHARACTERID,270 : ENDIF
    IF KEYSTATE(77) = 1 : Yrotate object iCHARACTERID,90 : ENDIF

   
    s#=0 `This is involved with stepping movement
    if isMoving = 1 and s# < oMD.fStepDistance# then s# = s# + oMD.fStepDistance#
    if isMoving = 2 and s# > -1.0*oMD.fStepDistance# then s# = s# - oMD.fStepDistance#

    `######
    `this is our movement/stepping bit of code - newvalue gets the location of the next s# sized step
    `fPosX# AS FLOAT : fPosY# AS FLOAT : fPosZ# AS FLOAT
    oMD.fPosX# = newxvalue(oMD.fPosX#,iCharAngleY#,s#)
    oMD.fPosZ# = newzvalue(oMD.fPosZ#,iCharAngleY#,s#)
    oMD.fPosY# = get ground height(iMATRIXID,oMD.fPosX#,oMD.fPosZ#)
    `######
    
    `If the character is moving, setup the calculations for moving the map matrix
    ` and fire the controlMatrix() function
    if isMoving > 0
        oMD.fSHX# = oMD.fSHX# + (oMD.fPosX# - oMD.fOPosX#)
        oMD.fSHZ# = oMD.fSHZ# + (oMD.fPosZ# - oMD.fOPosZ#)
        controlMatrix()
    endif

    `Get the angle (direction) on the Y axis that the character is facing
    ` We use this to power the compass eventually!
    iCharAngleY# = OBJECT ANGLE Y(iCHARACTERID)
    
    
     `######## CONTROL THE SCENE
     If Leftkey()=1 then Yrotate object iCHARACTERID,Wrapvalue(iCharAngleY#-2)
         yrotate camera iCAMID,Wrapvalue(iCharAngleY#-2)
     If Rightkey()=1 then Yrotate object iCHARACTERID,Wrapvalue(iCharAngleY#+2) 
         yrotate camera iCAMID,Wrapvalue(iCharAngleY#+2)
     
     theheight# = GET GROUND HEIGHT(iMATRIXID,oMD.iAxisCenter,oMD.iAxisCenter)
     `position object iCHARACTERID,oMD.iAxisCenter,theheight#,oMD.iAxisCenter
    position object iCHARACTERID,oMD.fPosX#,theheight#,oMD.fPosZ#
    
    `IF WE HIT THE 2 KEY, SWITCH TO VIEW 2
    IF KEYSTATE(3) = 1
        print "View 2"
        POSITION CAMERA iCAMID,oMD.fPosX#,400.0,oMD.fPosZ#
        `POSITION CAMERA iCAMID,0,999.0,0
        `Camera 2 has a downward pointing view
        XROTATE CAMERA iCAMID,40
    ELSE
        print "View 1"
        `POSITION CAMERA iCAMID,oMD.iAxisCenter,100,(oMD.iAxisCenter)-50
        POSITION CAMERA iCAMID,oMD.fPosX#,theheight#+20,oMD.fPosZ# -50
        `POSITION CAMERA iCAMID,0,400.0,0
        `Camera 2 has a downward pointing view
        XROTATE CAMERA iCAMID,30
    ENDIF
    `######## CONTROL THE SCENE

   IF KEYSTATE(4) = 1
        print "View 3"
        POSITION CAMERA iCAMID,camera position x(iCAMID),1000.0,camera position z(iCAMID)
        `POSITION CAMERA iCAMID,0,999.0,0
        `Camera 2 has a downward pointing view
        XROTATE CAMERA iCAMID,90
    ENDIF
    
    IF KEYSTATE(5) = 1 
        print "View 4"
        camx = oMD.fPosX# - 400
        camz = oMD.fPosZ# + 400
        POSITION CAMERA iCAMID,camx,200,camz
        `POSITION CAMERA iCAMID,0,999.0,0
        `Camera 2 has a downward pointing view
        XROTATE CAMERA iCAMID,80
    ENDIF
    
`   cya#=wrapvalue(cya#+(mousemovex()/3.0))
`   cxa#=cxa#+(mousemovey()/3.0)
`   if cxa#<-45.0 then cxa#=-45.0
`   if cxa#>45.0 then cxa#=45.0
`
`   rem smooth camera rotation
`   cx#=curveangle(cxa#,cx#,1.0)
`   cy#=curveangle(cya#,cy#,4.0)
`
`   rotate camera cx#,cy#,0
`   rotate#=cy#

   `position camera x#,h#+1500,z#
    
    sync
LOOP
    
`##############################################################################################################
`##############################################################################################################
`##############################################################################################################

function controlMatrix()
    oMD.dirUp = 0 : oMD.dirDown = 0 : oMD.dirLeft = 0 : oMD.dirRight = 0
    freq# = 0 : ampl# = 0 : prevh# = 0
    iTiles = oMD.iBlocksCount * oMD.iSegPoints

    `Did I already shift once?
    iShifted = 0

    IF oMD.fPosX# < oMD.fOPosX#
        iShifted = 1
    ENDIF
    IF oMD.fPosX# > oMD.fOPosX#
        iShifted = 2
    ENDIF


    IF oMD.iLS = 0
       `Movement up
        IF oMD.fSHZ# >= oMD.iSegLength
            oMD.fSHZ# = 0
            oMD.dirUp = 1
        ENDIF
        `Movement Down
        IF oMD.fSHZ# <= (0.0 - oMD.iSegLength)
            oMD.fSHZ# = 0
            oMD.dirDown = 1
        ENDIF

        IF oMD.dirUp = 1 OR oMD.dirDown = 1 
            oMD.iLS = 1
        ELSE
        
           `Movement Right
            IF oMD.fSHX# >= oMD.iSegLength
                oMD.fSHX# = 0
                oMD.dirRight = 1
            ENDIF
            `Movement Left
            IF oMD.fSHX# <= (0.0 - oMD.iSegLength)
                oMD.fSHX# = 0
                oMD.dirLeft = 1
            ENDIF

        ENDIF
    ELSE
        oMD.iLS = 0
       `Movement Right
        IF oMD.fSHX# >= oMD.iSegLength
            oMD.fSHX# = 0
            oMD.dirRight = 1
        ENDIF
        `Movement Left
        IF oMD.fSHX# <= (0.0 - oMD.iSegLength)
            oMD.fSHX# = 0
            oMD.dirLeft = 1
        ENDIF        
    ENDIF


remstart
`Uncomment this code to remove the latent shifting code
` The latent shift code came from the example code I found on the boards.
` I am not sure if the latent shift helps or not... it doesn't seem to
   `Movement up
    IF oMD.fSHZ# >= oMD.iSegLength
        oMD.fSHZ# = 0
        oMD.dirUp = 1
    ENDIF
    `Movement Down
    IF oMD.fSHZ# <= (0.0 - oMD.iSegLength)
        oMD.fSHZ# = 0
        oMD.dirDown = 1
    ENDIF
   `Movement Right
    IF oMD.fSHX# >= oMD.iSegLength
        oMD.fSHX# = 0
        oMD.dirRight = 1
    ENDIF
    `Movement Left
    IF oMD.fSHX# <= (0.0 - oMD.iSegLength)
        oMD.fSHX# = 0
        oMD.dirLeft = 1
    ENDIF
remend

    `######## PLAYER MOVEMENT UP ########
    IF oMD.dirUp = 1
        controlMatrixHeights("up",iShifted)
        `Perform the matrix shift
        SHIFT MATRIX DOWN iMATRIXID
        WL MATRIX NORMALISE iMATRIXID
        `iShifted = 1
    ENDIF `IF oMD(0).dirUp = 1
    `######## PLAYER MOVEMENT UP ########

    `######## PLAYER MOVEMENT DOWN ########
    IF oMD.dirDown = 1
        controlMatrixHeights("down",iShifted)
        `Perform the matrix shift
        SHIFT MATRIX UP iMATRIXID
        WL MATRIX NORMALISE iMATRIXID
        `iShifted = 2
    ENDIF `IF oMD(0).dirDown = 1
    `######## PLAYER MOVEMENT DOWN ########

    `######## PLAYER MOVEMENT LEFT ########
    IF oMD.dirLeft = 1
        controlMatrixHeights("left",iShifted)
        `Perform the matrix shift
        SHIFT MATRIX RIGHT iMATRIXID
        WL MATRIX NORMALISE iMATRIXID
    ENDIF `IF oMD(0).dirDown = 1
    `######## PLAYER MOVEMENT LEFT ########

    `######## PLAYER MOVEMENT RIGHT ########
    IF oMD.dirRight = 1
        controlMatrixHeights("right",iShifted)
        `Perform the matrix shift
        SHIFT MATRIX LEFT iMATRIXID
        WL MATRIX NORMALISE iMATRIXID
    ENDIF `IF oMD(0).dirDown = 1
    `######## PLAYER MOVEMENT RIGHT ########

    rem reposition matrix
    oMD.fMatPosX# = (oMD.fPosX# - oMD.iAxisCenter) - oMD.fSHX#
    oMD.fMatPosZ# = (oMD.fPosZ# - oMD.iAxisCenter) - oMD.fSHZ#
    `position matrix iMATRIXID,oMD.fMatPosX#,0,oMD.fMatPosZ#
    
    `Converted to integer values for a more gridlike approach
    `This number in essence moves by the size of iSegLength
    oMD.iMatPosX = ((oMD.fPosX# - oMD.iAxisCenter) - oMD.fSHX#)
    oMD.iMatPosZ = ((oMD.fPosZ# - oMD.iAxisCenter) - oMD.fSHZ#)
    `show message oMD.iMatPosX
    position matrix iMATRIXID,oMD.iMatPosX,0,oMD.iMatPosZ
ENDFUNCTION
 
`##############################################################################################################

FUNCTION controlMatrixHeights(sDir$,iShifted)
    `iShifted:  1 = UP -- 2 = DOWN
    iTiles = oMD.iBlocksCount * oMD.iSegPoints
    `There can be shifting in 2 directions at any given time that this function is fired
    `Need to account for that in the noisex and noisez variables to ensure that the correct height 
    ` values are grabbed

    SELECT sDir$
        CASE "up":
            FOR iSeg = 0 TO oMD.iSegPoints
                `These are the points on the MATRIX that actually get affected by the update
                x = iSeg : z = oMD.iSegPoints
                `When the matrix is created, the heights are set with the entire world in mind
                ` So iTiles = oMD.iBlocksCount * oMD.iSegPoints
                `As the matrix moves around, the 0,0 location of  the matrix moves around the map 
                ` and is held in the oMD.iMatPosX and oMD.iMatPosZ values
                `  - it's these values that become the 0,0 for the matrix
                
                noisez = WRAP(((oMD.iMatPosZ / oMD.iSegLength) + oMD.iSegPoints + 1 ),0,iTiles)
                noisex = WRAP(((oMD.iMatPosX / oMD.iSegLength) + iSeg),0,iTiles)
                
                `noisez = WRAP(((oMD.fMatPosZ# / oMD.iSegLength) + oMD.iSegPoints +1 ),0,iTiles)
                `noisex = WRAP(((oMD.fMatPosX# / oMD.iSegLength) + iSeg),0,iTiles)
                
                newh# = NOISE GET HEIGHT TILED(0,noisex,noisez,iTiles,iTiles) * 255
                set matrix height iMATRIXID,x,z,newh#
                `set matrix height iMATRIXID,x,0,newh#
                
                `strdebug$ = "UP x: " + str$(noisex) + " z: " + str$(noisez)+ " H: " + str$(newh#)
                `strdebug$ = strdebug$ + " Applied to: " + str$(x) + "," + str$(z)
                `debugit("move-up.txt",strdebug$,0) 

            NEXT iSeg
        ENDCASE
        CASE "down":
            FOR iSeg = 0 TO oMD.iSegPoints
                x = iSeg : z = 0
                
                noisez = WRAP(((oMD.iMatPosZ / oMD.iSegLength) - 1),0,iTiles)
                noisex = WRAP(((oMD.iMatPosX / oMD.iSegLength) + iSeg),0,iTiles)
                
                `noisez = WRAP(((oMD.fMatPosZ# / oMD.iSegLength)-1),0,iTiles)
                `noisex = WRAP(((oMD.fMatPosX# / oMD.iSegLength) + iSeg),0,iTiles)
                
                newh# = NOISE GET HEIGHT TILED(0,noisex,noisez,iTiles,iTiles) * 255
                `debugit("noisex.txt","x: " + str$(noisex) + " z: " + str$(noisez)+ " H: " + str$(newh#),0) 
                set matrix height iMATRIXID,x,z,newh#
                `set matrix height iMATRIXID,x,oMD.iSegPoints,newh#
            NEXT iSeg

        ENDCASE
        
        `Unless we are dead on moving left (270deg) we are either shifting DOWN (up) or UP (down) BEFORE this 
        `movement occurs
        CASE "left":
            FOR iSeg = 0 TO oMD.iSegPoints
                x = 0 : z = iSeg

                SELECT iShifted
                    CASE 0: `Moving straight on at 270
                    `This works - don't change anything
                        noisez = WRAP(((oMD.iMatPosZ / oMD.iSegLength) + iSeg),0,iTiles)
                        noisex = WRAP((((oMD.iMatPosX / oMD.iSegLength) + oMD.iSegPoints)-1),0,iTiles)
                        `noisez = WRAP(((oMD.fMatPosZ# / oMD.iSegLength) + iSeg),0,iTiles)
                        `noisex = WRAP(((oMD.fMatPosX# / oMD.iSegLength) -1),0,iTiles)
                    ENDCASE
                    CASE 1: `Moving with an up angle
                        noisez = WRAP(((oMD.iMatPosZ / oMD.iSegLength) + iSeg),0,iTiles)
                        noisex = WRAP(((oMD.iMatPosX / oMD.iSegLength) ) ,0,iTiles)
                        `noisez = WRAP(((FLOOR(oMD.fMatPosZ#) / oMD.iSegLength) + iSeg),0,iTiles)
                        `noisex = WRAP(((FLOOR(oMD.fMatPosX#) / oMD.iSegLength))-1,0,iTiles)
                        
                        `The update has already occurred on the first x point, now subtract one again
                        `and let the shifting action bring it into view
                       x = WRAP(x-1,0,oMD.iSegPoints)
                        `z = WRAP(z+2,0,oMD.iSegPoints)
                        
                    ENDCASE
                    `CASE 2: `Moving with a down angle - not implemented yet
                    `    noisez = WRAP(((oMD.iMatPosZ / oMD.iSegLength) + iSeg),0,iTiles)
                    `    noisex = WRAP(((oMD.iMatPosX / oMD.iSegLength) -1),0,iTiles)
                    `    `noisez = WRAP(((oMD.fMatPosZ# / oMD.iSegLength) + iSeg),0,iTiles)
                    `    `noisex = WRAP(((oMD.fMatPosX# / oMD.iSegLength)),0,iTiles)
                    `ENDCASE
                ENDSELECT

                newh# = NOISE GET HEIGHT TILED(0,noisex,noisez,iTiles,iTiles) * 255
                
                strdebug$ = "LEFT x: " + str$(noisex) + " z: " + str$(noisez)+ " H: " + str$(newh#)
                strdebug$ = strdebug$ + " Applied to: " + str$(x) + "," + str$(z)
                strdebug$ = strdebug$ + " Mat Posx:" + str$(oMD.iMatPosX) + " Mat PosZ:" + str$(oMD.iMatPosZ)
                debugit("movement.txt",strdebug$,0) 
                
                set matrix height iMATRIXID,x,z,newh#
                `set matrix height iMATRIXID,oMD.iSegPoints,z,newh#
                
            NEXT iSeg

        ENDCASE
        CASE "right":
            `IF iShifted = 1 : iShifter = 1 : ENDIF
            `IF iShifted = 2 : iShifter = -1 : ENDIF
        
            FOR iSeg = 0 TO oMD.iSegPoints
                x = oMD.iSegPoints : z = iSeg
                
                noisez = WRAP(((oMD.iMatPosZ / oMD.iSegLength) + iSeg),0,iTiles)
                noisex = WRAP(((oMD.iMatPosX / oMD.iSegLength) +1),0,iTiles)
                `noisez = WRAP(((oMD.fMatPosZ# / oMD.iSegLength) + iSeg),0,iTiles)
                `noisex = WRAP(((oMD.fMatPosX# / oMD.iSegLength) +1),0,iTiles)
                
                newh# = NOISE GET HEIGHT TILED(0,noisex,noisez,iTiles,iTiles) * 255
                `debugit("noisex.txt","x: " + str$(noisex) + " z: " + str$(noisez)+ " H: " + str$(newh#),0) 
                set matrix height iMATRIXID,x,z,newh#
                `set matrix height iMATRIXID,0,z,newh#
            NEXT iSeg
        ENDCASE
    ENDSELECT
ENDFUNCTION
 
 
`##############################################################################################################
 
 `This is the function that actually generates the terriain data
function UpdateMatrix()
     `Generates a texture from a gradient image
     `generateTextureFromGradient()
     `img = generateTextureFromGradient()
    `PREPARE MATRIX TEXTURE Matrix Number, Image Number, Across, Down
     `PREPARE MATRIX TEXTURE iMATRIXID, img, 16,16

    iTiles = oMD.iBlocksCount * oMD.iSegPoints
    `iTiles = oMD.iSegPoints
     set matrix wireframe off iMATRIXID
     for x = 0 to oMD.iSegPoints
         for z = 0 to oMD.iSegPoints
             hgt# = NOISE GET HEIGHT TILED(0,x,z,iTiles,iTiles) * 255
             `hgt# = NOISE GET HEIGHT(0,x,z) * 255
             set matrix height iMATRIXID,x,z,hgt#
             `DebugIt("TestFilesize.txt",STR$(x) + "," + str$(z) + ": " + STR$(hgt),0)
             `DebugIt("JustHeight.txt",STR$(hgt),0)
         NEXT z
     NEXT x
     WL MATRIX NORMALISE iMATRIXID
     UPDATE MATRIX iMATRIXID
ENDFUNCTION