////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////

abstract class Sprite
{
  private int row;
  private int col;
  private int width;
  private int height;
  private color backgroundColor;

  public Sprite(int _w, int _h)
  {
    setWidth(_w);
    setHeight(_h);
  }

  public int getRow()
  {
    return row;
  }

  public int getCol()
  {
    return col;
  }

  public int getWidth()
  {
    return width;
  }

  public int getHeight()
  {
    return height;
  }

  public int getColor()
  {
    return backgroundColor;
  }
  
  public void setRow(int _r)
  {
    row = _r;
  }

  public void setCol(int _c)
  {
    col = _c;
  }

  public void setWidth(int _w)
  {
    width = _w;
  }

  public void setHeight(int _h)
  {
    height = _h;
  }

  public void setColor(color _c)
  {
    backgroundColor = _c;
  }
}

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////

class Player extends Sprite
{
  public static final int up    = 1;
  public static final int left  = 2;
  public static final int down  = 3;
  public static final int right = 4;
  
  public Player()
  {
    super(0, 0);
    setColor(color(153, 217, 234));  // blue knight
  }
}

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////

class EmptySpace extends Sprite
{
  public EmptySpace()
  {
    super(0, 0);
    setColor(color(0, 0, 0));  // plain darkness
  }
}

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////

class Wall extends Sprite
{
  public Wall()
  {
    super(0, 0);
    setColor(color(255, 126, 0));  // orange brick
  }
}

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////

class World
{
  private Player player;
  private int rows;
  private int cols;
  Sprite[][] maze;
  
  public World(int _r, int _c)
  {
    player = new Player();
    
    rows = _r;
    cols = _c;
    
    maze = new Sprite[rows][cols];
  }

  public void setPlayer(Player _p)
  {
    player = _p;

    player.setWidth(getCellWidth());
    player.setHeight(getCellHeight());
  }
  
  public int getCellWidth()
  {
    return getWidth() / getRows();
  }
  
  public int getCellHeight()
  {
    return getHeight() / getCols();
  }
  
  public Player getPlayer()
  {
    return player;
  }

  public int getWidth()
  {
    return width;
  }

  public int getHeight()
  {
    return height;
  }
  
  public Sprite[][] getMaze()
  {
    return maze;
  }
  
  public int getRows()
  {
    return rows;
  }
  
  public int getCols()
  {
    return cols;
  }
  
  public boolean isValidPlayerMove(int r, int c)
  {
    if (r < 0 || c < 0)
      return false;
      
    if (r >= getRows() || c >= getCols())
      return false;
    
    if(maze[r][c] instanceof Wall)      // Do not break into walls.
      return false;
    
    return true;
  }   
  
  private void buildMaze()
  {
    for(int r=0; r<rows; r++)
    {
      for(int c=0; c<cols; c++)
      {
        maze[r][c] = null;
        
        switch(random(1))
        {
          case 0:          // Empty space
                  locateSprite(new EmptySpace(), r, c);
                  break;
          case 1:          // Walled area
                  locateSprite(new Wall(), r, c);
                  break;
        }
      }
    }
  }
  
  public boolean movePlayer(int direction)
  {
    int row = player.getRow();
    int col = player.getCol();
    
    switch(direction)
    {
      case Player.up:
                      col = col - 1;
                      break;
      case Player.down:
                      col = col + 1;
                      break;
      case Player.left:
                      row = row - 1;
                      break;
      case Player.right:
                      row = row + 1;
                      break;
    }
    
    if(!isValidPlayerMove(row, col))
      return false;
    
    locateSprite(new EmptySpace(), player.getRow(), player.getCol());
   
    locateSprite(player, row, col);  
      
    return true;
  }
  
  private boolean locatePlayer()
  {
    int r = random(getRows() - 1);
    int c = random(getCols() - 1);
    
    if(maze[r][c] instanceof EmptySpace)
    {
      locateSprite(new EmptySpace(), player.getRow(), player.getCol());
      locateSprite(player, r, c);  
      return true;
    }
    
    return false;
  }
  
  private void locateSprite(Sprite s, int r, int c)
  {
    s.setRow(r);
    s.setCol(c);
    s.setWidth(world.getCellWidth());
    s.setHeight(world.getCellHeight());
    
    maze[r][c] = s;
  }
  
  public boolean teleport()
  {
    for (int itry=0; itry<10; itry++)
    {
      if(locatePlayer())
        return true;
    }
    
    return false;
  }
  
  public void reset()
  {
    buildMaze();

    teleport();
  }
}

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////

World world = null;

void setup()
{
  world = new World(7, 9);
  world.setPlayer(new Player());
  world.reset();
}

void draw()
{
  background(0);
  
  //////////////////////////////////////////////////////////////////////////

  Sprite[][] maze = world.getMaze();
  
  for(int r=0; r<world.getRows(); r++)
  {
    for(int c=0; c<world.getCols(); c++)
    {
      Sprite object = maze[r][c];
      
      fill(object.getColor());
      rect(r * world.getCellWidth(), 
           c * world.getCellHeight(), 
           object.getWidth(), 
           object.getHeight());
    }
  }

  //////////////////////////////////////////////////////////////////////////
}

void keyPressed()
{
   switch(keyCode)
   {
     case UP:
       world.movePlayer(Player.up);
     break;
     case DOWN:
       world.movePlayer(Player.down);
     break;
     case LEFT:
       world.movePlayer(Player.left);
     break;
     case RIGHT:
       world.movePlayer(Player.right);
     break;
     case FIRE:
       boolean control = world.teleport();
     break;
   }
}

void softkeyPressed(String label)
{
}

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////