//------------------------------------------------------------------------------
// Tutorial
// Subject: Walking/Tiles
// Author: Roelf Leenders(el.moog@gmail.com)
// Started: 4-2-2005 (11:32:29h)
//------------------------------------------------------------------------------
program tutorial;

const

//Size of the tiles(duh!)
TILESIZE = 50;

//Dimensions of the level(L*B = DIM*DIM)
DIM = 50;

//Screen size:
SCREENX = 320;
SCREENY = 240;

global

//Sometimes it's easy to group variables, easy for saving/loading and it keeps
//the code organized and easier to read

//Structure to save the level data:
struct level;
  //Holds which tiles are where
  tile[DIM][DIM];
  //Start position for a character
  start[1];
end

//Structure for scrolling the level:
//sx and sy are holding the 'camera' point in pixels, that point is in the upper
//left corner of the screen
struct scrol;
  sx;
  sy;
  cam;
end

//FPG file:
fpg1;

//true if editor, false if not
editormode;

//GP Keys
__A = _control;
__B = _alt;
__SELECT = _space;
__START = _enter;
__R = _tab;
__L = _backspace;

local
xs,ys;

begin
//Initialize screen:
set_title("Serie Tutorials by Roelf Leenders");
full_screen = false;
set_mode(SCREENX,SCREENY,16);

//Load the fpg with the graphics for tiles/editor/character
fpg1 = load_fpg("help.fpg");

//If the level exists it can be loaded, otherwise create a fresh one
if(exists("level.lvl"))
  load("level.lvl",level);
else
  //Fill up the level with tile number 1(normal ground)
  for(x=0;x<DIM;x++)
    for(y=0;y<DIM;y++)
      level.tile[x][y] = 1;
    end
  end
  //set the default start position
  level.start[0] = DIM/2;
  level.start[1] = DIM/2;
end

//Fire up the editor then!
editor();

//kill the program when select is pushed
loop
  if(key(__SELECT))
    exit("",0);
  end
  frame;
end

end


/*
Renders the level to the screen every frame
*/
Process RenderLevel()

private
//tile number of the edges of the visible area
tleft,tright,tup,tdown;

begin

loop
  //clear the screen:
  clear_screen();

  //follow a camera process if one is defined
  if(exists(scrol.cam))
    scrol.sx = scrol.cam.xs - SCREENX/2;
    scrol.sy = scrol.cam.ys - SCREENY/2;
  end
  
  //Make sure the camera position doesn't go out of the level;
  if(scrol.sx < 0)scrol.sx = 0;end
  if(scrol.sy < 0)scrol.sy = 0;end
  if(scrol.sx > DIM * TILESIZE - SCREENX)scrol.sx = DIM * TILESIZE - SCREENX;end
  if(scrol.sy > DIM * TILESIZE - SCREENY)scrol.sy = DIM * TILESIZE - SCREENY;end

  //Fix the real coordinates of the camera process(only a good solution when
  //there aren't multiple processes that need their coordinates converted)
  if(exists(scrol.cam))
    scrol.cam.x = scrol.cam.xs - scrol.sx;
    scrol.cam.y = scrol.cam.ys - scrol.sy;
  end

  //Determine which tiles are on screen and should be drawn:
  tleft = scrol.sx / TILESIZE - 1;
  tright = tleft + SCREENX / TILESIZE + 2;
  tup = scrol.sy / TILESIZE - 1;
  tdown = tup + SCREENY / TILESIZE + 2;

  //Check if they stay within the borders of the level
  if(tleft < 0)tleft = 0;end
  if(tup < 0)tup = 0;end
  if(tright >= DIM)tright = DIM -1;end
  if(tdown >= DIM)tdown = DIM -1;end

  //And render the level:
  for(x=tleft;x=<tright;x++)
    for(y=tup;y=<tdown;y++)
      put(fpg1,level.tile[x][y],x * TILESIZE - scrol.sx + TILESIZE/2,y * TILESIZE - scrol.sy + TILESIZE/2);
    end
  end

  //Draw the player start node when in editor mode
  if(editormode == 1)
    put(fpg1,12,level.start[0] * TILESIZE - scrol.sx + TILESIZE/2,level.start[1] * TILESIZE - scrol.sy + TILESIZE/2);
  end
  
  frame;
end

end

/*
Editor process, allows the user to change the tiles of the level as he sees fit.
*/
Process Editor()

private
tilex;
tiley;

goodToMove;

begin

//Render the level
RenderLevel();

editormode = 1;
tilex = DIM/2;
tiley = DIM/2;

write(0,0,0,0,"Welcome to the editor, there are two");
write(0,0,10,0,"tiles avaliable, A to change a tile");
write(0,0,20,0,"L to save level");
write(0,0,30,0,"R to go to play mode");
write(0,0,40,0,"START to place start token");

//set red square as graphic
file = fpg1;
graph = 11;

//set camera to follow the red square
scrol.cam = id;

loop
  //navigate the 'cursor' through the level
  if(goodToMove)
    if(key(_left) and tilex>0)tilex--;end
    if(key(_right) and tilex<DIM-1)tilex++;end
    if(key(_up) and tiley>0)tiley--;end
    if(key(_down) and tiley<DIM-1)tiley++;end
  end
  
  if(!key(_left) and !key(_right) and !key(_up) and !key(_down))
    goodToMove = true;
  else
    goodToMove = false;
  end
  
  //Change tiles with the A button
  if(key(__A))
    level.tile[tilex][tiley] = (level.tile[tilex][tiley] % 2)+1;
    while(key(__A))frame;end
  end

  //Change the player start token with the start key
  if(key(__START))
    level.start[0] = tilex;
    level.start[1] = tiley;
    while(key(__START))frame;end
  end

  //Calculate position with the position in tiles
  xs = tilex * TILESIZE + TILESIZE/2;
  ys = tiley * TILESIZE + TILESIZE/2;

  //save the level with L
  if(key(__L))
    save("level.lvl",level);
    //wait for L button to be released
    while(key(__L))frame;end
  end

  //switch to character mode
  if(key(__R))
    //wait for R key to be released
    while(key(__R))frame;end
    //delete the written text
    delete_text(all_text);
    //start the character process
    character();
    return;
  end

  frame;
end


end



/*
Walking a person through the level created with the editor, colliding with the
wall blocks
*/
Process Character()

private
//if the character is just standing around, no animation is needed.
standing = 1;

//character radius
radius = 20;

begin
//set editormode to zero(ie, do not draw the player start node)
editormode = 0;

file = fpg1;

//use double sized graphics(they're too small for the tiles)
size = 200;

//put character on the start position
xs = level.start[0] * TILESIZE + TILESIZE/2;
ys = level.start[1] * TILESIZE + TILESIZE/2;

//set the camera to follow this process
scrol.cam = id;

write(0,0,0,0,"Walk around with the stick");
write(0,0,10,0,"R to switch to editor mode");

loop
  //assume character is standing, when the program is convinced he isn't it's changed
  standing = 1;
  
  //move the character forwards using the xs and ys coordinates, as they are automatically
  //converted to screen coordinates by the renderlevel process
  if(key(_up))
     //move forward 8 pixels
     xs += get_distx(angle,8);
     ys += get_disty(angle,8);

    //walking sequence
    graph = ((graph - 3)+1) % 8 +3;
    
    //obviously not standing anymore!
    standing = 0;
  end

  //move it backwards
  if(key(_down))
    //move!
    xs += get_distx(angle,-8);
    ys += get_disty(angle,-8);
    
    //walking sequence
    graph = ((graph - 3)+1) % 8 +3;

    //and of course not standing anymore
    standing = 0;
  end

  //turn to both sides
  if(key(_right))
    angle -= 5000;
  end
  
  if(key(_left))
    angle += 5000;
  end

  //switch to editor mode
  if(key(__R))
    //wait for key to be released
    while(key(__R))frame;end

    delete_text(all_text);

    //start up the editor
    editor();
    
    //kill this process
    return;
  end
  
  //if just standing, reset the graphic
  if(standing)
    graph = 8;
  end

  //collision detection for all 4 sides using the given radius
  while(level.tile[(xs+radius)/TILESIZE][ys/TILESIZE] == 2)
    xs--;
  end
  while(level.tile[(xs-radius)/TILESIZE][ys/TILESIZE] == 2)
    xs++;
  end
  while(level.tile[xs/TILESIZE][(ys+radius)/TILESIZE] == 2)
    ys--;
  end
  while(level.tile[xs/TILESIZE][(ys-radius)/TILESIZE] == 2)
    ys++;
  end

  frame;
end

end