tilemap_base

// Tilemap and Occluder with centered tile based movement in P3 by vvixi
// added helper function for collisions
// todo: fog of war, collision
PImage tilemapimg;
TileMap tilemap;
int blk = 16;
int tileCols = 10;
int tileRows = 10;

ArrayList<PImage> tiles;
int wrldCols, wrldRows;
int cols = 40, rows = 40;
int [][] map = new int [cols][rows];
Player player;

int tileW, tileH;

void setup() {
  surface.setTitle("Tilemap Base");
  size(640, 640);
  tilemapimg = loadImage("assets/Dungeon_Tileset.png");
  imageMode(CENTER);
  
  // calculate size of a tile
  tileW = tilemapimg.width/tileCols;
  tileH = tilemapimg.height/tileRows;

  // install room values into map
  PVector[] locs = new PVector[4];
  
  // add tiles from tilemap
  tiles = new ArrayList();
  for (int y = 0; y < tileRows; y++) {
    
    for (int x = 0; x < tileCols; x++) {
      tiles.add(tilemapimg.get(x * 16, y * 16, tileW, tileH));
    }
  }

  tilemap = new TileMap();
  // offset needs adjusted for floor with first two parameters
  tilemap.drawRoom(0, 0, cols, rows);
  player = new Player(width/2, height/2);
  
}

void draw() {
  background(0);
  tilemap.displayMap();
  player.display();

}
class TileMap {

  int offsX, offsY;
  // occluder details
  int ocStartX = 1, ocEndX = width/16-1;
  int ocStartY = 1, ocEndY = width/16-1;
  
  TileMap() {
    int offsX = 0;
    int offsY = 0;
  }
  PVector world2screen(int _x, int _y) {
    return new PVector(_x + player.posx/16, _y + player.posy/16);
  }
  void drawRoom(int _startX, int _startY, int _xSize, int _ySize) {
    map = new int [_xSize + _startX][_ySize + _startY];
    for (int y = _startX; y < _xSize+_startX; y++) {
      for (int x = _startY; x < _ySize+_startY; x++) {
        // place floors
        //map[x][y] = 0;
        //map[int(random(x+1, _xSize-2))][int(random(y+1, _ySize-2))] = 4;
        // place outer walls
        map[x][_startY] = 1;
        map[_startX][y] = 1;
        map[x][_ySize-1] = 1;
        map[_xSize-1][y] = 1;
        // place doors
        map[_startX][floor(_xSize/2)] = 3;
        map[_ySize-1][floor(_xSize/2)] = 3;
        map[floor(_ySize/2)][_xSize-1] = 3;
        map[floor(_ySize/2)][_startY] = 3;
        
      }
    }
  }

  void displayMap() {

    for (int i = max(0, ocStartY); i < min(ocEndY, cols); i++) {
      for (int j = max(0, ocStartX); j < min(ocEndX, rows); j++) {
        if(true) {

          switch (map[i][j]) {
            
            case 0:
              // floor tile
              image(tiles.get(6), j * tileW + tileW/2 + offsX, i * tileH + tileH/2 + offsY, tileW, tileH);
              break;
              
            case 1:
            // wall tile
              image(tiles.get(1), j * tileW + tileW/2 + offsX, i * tileH + tileH/2 + offsY, tileW, tileH);
              //image(tiles.get(2), j * tileW + tileW/2 + offsX, i * tileH + tileH/2 + offsY, tileW, tileH);
              //image(tiles.get(3), j * tileW + tileW/2 + offsX, i * tileH + tileH/2 + offsY, tileW, tileH);
              //image(tiles.get(4), j * tileW + tileW/2 + offsX, i * tileH + tileH/2 + offsY, tileW, tileH);
              break;
              
            case 3:
              // door
              image(tiles.get(36), j * tileW + tileW/2 + offsX, i * tileH + tileH/2 + offsY, tileW, tileH);
              break;
              
            case 4:
              // door
              fill(0);
              image(tiles.get(68), j * tileW + tileW/2 + offsX, i * tileH + tileH/2 + offsY, tileW, tileH);
              break;
              
            default:
              fill(0);
              //image(tiles.get(7), j * tileW, i * tileH, tileW, tileH);
              break;
          }
        }
      }
    }
  }
 
}
void keyPressed() {
  player.keyPressed();

}
class Player{
  boolean spawned = true;
  float posx, posy;
  PVector dir = new PVector(0, 0);
  PVector up = new PVector(0, -1);
  PVector down = new PVector(0, 1);
  PVector left = new PVector(-1, 0);
  PVector right = new PVector(1, 0);
  
  Player(float _posx, float _posy)  {
    posx = _posx;
    posy = _posy;
  }
  
  void update() {
    
  }
  
  void display() {
    // char sprite
    fill(200);
    noStroke();
    rect(posx, posy, blk, blk);
  }
  
  public boolean canMove(PVector _dir) {
    dir = _dir;
    boolean move = true;
    return move;
    // need check for a wall tile in passed in dir
  }
  
  void keyPressed() {

    if(spawned) {
      if(key == CODED) {
        if(keyCode == UP) {
          // basic collision test before allowing movement
          if (canMove(up)) {
            tilemap.offsY += blk;
            tilemap.ocStartY -= 1;
            tilemap.ocEndY -= 1;
          }

        }
        else if(keyCode == DOWN) {
          if (canMove(down)) {
            tilemap.offsY -= blk;
            tilemap.ocStartY += 1;
            tilemap.ocEndY += 1;
          }
        }
        else if(keyCode == LEFT) {
          if (canMove(left)) {
            tilemap.offsX += blk;
            tilemap.ocStartX -= 1;
            tilemap.ocEndX -= 1;
          }
        }
        else if(keyCode == RIGHT) {
          if (canMove(right)) {
            tilemap.offsX -= blk;
            tilemap.ocStartX += 1;
            tilemap.ocEndX += 1;
          }
        }
      }
    }
  }
  
}