import java.applet.*; 
import java.awt.*; 
import java.awt.image.*; 
import java.awt.event.*; 
import java.io.*; 
import java.net.*; 
import java.text.*; 
import java.util.*; 
import java.util.zip.*; 

public class snakoban extends BApplet {
// Snakoban
// Kevan Davis, 26/8/03

int[][] square;
int[][] tailage;

int gamemode = 1;
int speed = 150;
int level,step;

int head  = 1;
int tail  = 2;
int block = 3;
int hole  = 4;
int fill  = 5;
int headcolor,tailcolor,blockcolor,holecolor,fillcolor;

int boardsize=10;
int squaresize=20;
int snakelength;

int offx=0,offy=0;

// Setup function, automatically called once at the start.
void setup() 
{
  size(boardsize*squaresize,boardsize*squaresize); 

  square = new int[boardsize][boardsize];
  tailage = new int[boardsize][boardsize];
  headcolor = color(0,200,0);
  tailcolor = color(0,100,0);
  holecolor = color(0,0,0);
  fillcolor = color(100,0,0);
  
  background(51); 

  // Fill the board with blank squares, except for the edges, which
  // start as filled holes.

  for(int x=0; x<boardsize; x++)
  { 
    for(int y=0; y<boardsize; y++)
    { 
      if (x==0 || y==0 || x==boardsize-1 || y==boardsize-1)
      { square[x][y] = fill; }
      else { square[x][y] = 0; }
    }
  }

  // Call the "add a block-and-hole at random" function, five times.
  addBlock();
  addBlock();
  addBlock();
  addBlock();
  addBlock();

  // Set the starting snake length.
  snakelength=5;

  // Place the snake.
  for (int i=0; i<snakelength; i++)
  {
    square[i+1][1] = tail;
    tailage[i+1][1] = snakelength-i;
  }
  square[snakelength+1][1] = head;

  // Set the level and step. (Level is how many blocks you need to
  // clear to finish that level; step is how many have been cleared.)
  level=1; step=0;
} 
 
// The "loop" function is automatically called again and again,
// forever, by Proce55ing. It's the main game loop.
void loop() 
{ 
  blockcolor = color(level*10,0,200-(level*10));

  int x,y,sq;

  // Loop through and draw each square. 
  for(x=0; x<boardsize; x++)
  { 
    for(y=0; y<boardsize; y++)
    { 
      // So what's in this x,y square?
      sq = square[x][y];

      // Depending on what it is, do one of several rather dull
      // and similar drawing routines.
      if (sq==head)
      {
        fill(headcolor); 
        rect(x*squaresize,y*squaresize,squaresize,squaresize);
      }
      else if (sq==tail)
      { 
        fill(tailcolor); 
        rect(x*squaresize,y*squaresize,squaresize,squaresize);
      }
      else if (sq==block)
      { 
        fill(blockcolor); 
        rect(x*squaresize,y*squaresize,squaresize,squaresize);
      }
      else if (sq==hole)
      { 
        fill(holecolor); 
        rect(x*squaresize,y*squaresize,squaresize,squaresize);
      }
      else if (sq==fill)
      { 
        fill(fillcolor); 
        rect(x*squaresize,y*squaresize,squaresize,squaresize);
      }
    }
  }

  // If in Snake mode, move the snake during each game loop, after
  // waiting for 'speed' milliseconds.
  if (gamemode == 2)
  { delay(speed); moveSnake(); }
}

// Function to add a block at random.
void addBlock()
{
  int i,rx,ry;
  for (i=0; i<200; i++)
  {
    // Pick a random x and y, and see if that square is empty.
    // If it is, change it to a block and set "i" to one, to break
    // this loop.
    rx = (int)random(boardsize-2)+1;
    ry = (int)random(boardsize-2)+1;
    if (square[rx][ry] == 0)
    { 
      if ((square[rx-1][ry-1] != fill && square[rx][ry-1] != fill &&
          square[rx+1][ry-1] != fill && square[rx-1][ry] != fill &&
          square[rx+1][ry] != fill && square[rx-1][ry+1] != fill &&
          square[rx][ry+1] != fill && square[rx+1][ry+1] != fill &&
          square[rx-1][ry-1] != block && square[rx][ry-1] != block &&
          square[rx+1][ry-1] != block && square[rx-1][ry] != block &&
          square[rx+1][ry] != block && square[rx-1][ry+1] != block &&
          square[rx][ry+1] != block && square[rx+1][ry+1] != block)
          || i>198)
      {
        square[rx][ry] = block; i=200; 
      }
    }
  }
  for (i=0; i<500; i++)
  {
    // Same again, to place a hole.
    rx = (int)random(boardsize);
    ry = (int)random(boardsize);
    if (square[rx][ry] == 0)
    { 
      if ((square[rx-1][ry-1] != fill && square[rx][ry-1] != fill &&
          square[rx+1][ry-1] != fill && square[rx-1][ry] != fill &&
          square[rx+1][ry] != fill && square[rx-1][ry+1] != fill &&
          square[rx][ry+1] != fill && square[rx+1][ry+1] != fill &&
          square[rx-1][ry-1] != block && square[rx][ry-1] != block &&
          square[rx+1][ry-1] != block && square[rx-1][ry] != block &&
          square[rx+1][ry] != block && square[rx-1][ry+1] != block &&
          square[rx][ry+1] != block && square[rx+1][ry+1] != block)
          || i>200)
      {
        square[rx][ry] = hole; i=500; 
      }
    }
  }
}

// This functiong gets called by Proce55ing whenever a key is
// pressed...
void keyPressed() 
{
  int x,y;

  // If playing as Sokoban, reset the offsets each keypress.
  if(gamemode == 1) { offy = 0; offx=0; }

  // See what grid offset the key provokes.
  if(key == 'w' || key == 'W') { offy = -1; offx=0; }
  if(key == 's' || key == 'S') { offy = 1; offx=0; }
  if(key == 'a' || key == 'A') { offx = -1; offy=0; }
  if(key == 'd' || key == 'D') { offx = 1; offy=0; }

  // Toggle mode (1=Sokoban, 2=Snake)
  if(key == 'm' || key == 'M') { gamemode = 3-gamemode; }

  // Restart
  if(key == 'q' || key == 'Q') { setup(); }

  // Restart
  if(key == '-' && speed < 200) { speed = speed + 10; }
  if(key == '+' && speed > 0) { speed = speed - 10; }
  
  // If in Sokoban mode, move the snake after each keypress.
  if (gamemode == 1)
  { moveSnake(); }
}

void moveSnake()
{
  int x,y,headx=0,heady=0;
  int oldest=snakelength,oldestx=0,oldesty=0;
  int finished=1;

  // Run through the board to see where the snake's head is, and
  // store its coordinates in headx and heady.
  for(x=0; x<boardsize; x++)
  { 
    for(y=0; y<boardsize; y++)
    { 
      if (square[x][y]==head)
      {
        headx=x; heady=y;
      }
    }
  }

  // See whether "current head position plus offset" is a block.
  if (square[headx+offx][heady+offy]==block)
  {
    // See whether "current head position plus offset *twice*" is
    // empty; if it is, the block can be pushed. Clever!
    if (square[headx+(offx*2)][heady+(offy*2)]==0)
    {
      // Move the block.
      square[headx+(offx*2)][heady+(offy*2)] = block;
      square[headx+offx][heady+offy] = 0;
    }
    if (square[headx+(offx*2)][heady+(offy*2)]==hole)
    {
      // Or fill a hole, for that matter.

      // Add a new block first, so that it doesn't land where
      // the old one was.
      addBlock();

      // If they've finished a level, add another block.
      if (step==level)
      {
        step=0; level++;
        if (level==21) { level=20; }
        snakelength++;
        addBlock();
      }

      // Fill the hole, kill the block.
      square[headx+(offx*2)][heady+(offy*2)] = 0;
      square[headx+offx][heady+offy] = 0;
      step++;
    }
  }

  // See whether "current position plus offset" is empty (or if
  // the player has pressed X).
  if (square[headx+offx][heady+offy]==0 || key == 'x' || key == 'X')
  {
    // Set the current head to a tail (with "tail age" zero).
    square[headx][heady] = tail;
    tailage[headx][heady] = 0;

    // Move the head.
    headx = headx + offx; 
    heady = heady + offy;
    square[headx][heady] = head;

    // Run through the board aging all the tail bits...
    for(x=0; x<boardsize; x++)
    { 
      for(y=0; y<boardsize; y++)
      { 
        if (square[x][y]==block)
        {
          // Oh, and check to see if any blocks are still around.
          // If they are, then the player hasn't finished the level.
          finished=0;
        }
        if (square[x][y]==tail)
        {
          // Age the tail, see if it's the oldest bit we've found
          // so far.
          tailage[x][y]++;
          if (tailage[x][y] >= oldest)
          { oldest = tailage[x][y]; 
            oldestx = x; oldesty = y; }
        }
      }
    }

    // If the oldest bit is longer than the snake, remove that bit.
    if (oldest > snakelength)
    {
      square[oldestx][oldesty] = 0;
    }
  }
}

// And that's it! Gosh.
}