155 lines
3.4 KiB
Plaintext
155 lines
3.4 KiB
Plaintext
import standard;
|
|
import node;
|
|
|
|
//consts
|
|
var ROOM_WIDTH: int const = 8;
|
|
var ROOM_HEIGHT: int const = 8;
|
|
|
|
var TILE_WIDTH: int const = 64;
|
|
var TILE_HEIGHT: int const = 64;
|
|
|
|
//map between the identity and position on the sprite sheet
|
|
var tilemap: [[string]] = null;
|
|
var collisions: [[bool]] = null;
|
|
|
|
var tileset: [string : [int]] = [
|
|
"pillar": [0, 0, 1],
|
|
|
|
"floor-0": [0, 1, 0],
|
|
"floor-1": [1, 1, 0],
|
|
"floor-2": [2, 1, 0],
|
|
"floor-3": [3, 1, 0],
|
|
|
|
"wall-t": [0, 2, 1],
|
|
"wall-b": [1, 2, 1],
|
|
"wall-l": [2, 2, 1],
|
|
"wall-r": [3, 2, 1],
|
|
|
|
"corner-tl": [0, 3, 1],
|
|
"corner-tr": [1, 3, 1],
|
|
"corner-bl": [2, 3, 1],
|
|
"corner-br": [3, 3, 1],
|
|
|
|
"edge-tl": [0, 4, 1],
|
|
"edge-tr": [1, 4, 1],
|
|
"edge-bl": [2, 4, 1],
|
|
"edge-br": [3, 4, 1]
|
|
];
|
|
|
|
|
|
//debug vars
|
|
var camX = 0;
|
|
var camY = 0;
|
|
var camW = 1080;
|
|
var camH = 720;
|
|
|
|
|
|
//lifecycle functions
|
|
fn onInit(node: opaque) {
|
|
node.loadTexture("sprites:/tileset.png");
|
|
|
|
tilemap = generateTilemap(clock().hash(), ROOM_WIDTH, ROOM_HEIGHT);
|
|
collisions = bakeCollisionMap(tilemap, ROOM_WIDTH, ROOM_HEIGHT);
|
|
|
|
print tilemap;
|
|
print collisions;
|
|
}
|
|
|
|
fn onDraw(node: opaque) {
|
|
//calc the region to render
|
|
var lowerX: int = round((camX - camW/2.0) / TILE_WIDTH);
|
|
var upperX: int = round((camX - camW*1.5) / TILE_WIDTH);
|
|
var lowerY: int = round((camY - camH/2.0) / TILE_HEIGHT);
|
|
var upperY: int = round((camY - camH*1.5) / TILE_HEIGHT);
|
|
|
|
//bounds check
|
|
lowerX = max(0, lowerX);
|
|
upperX = min(upperX < 0 ? abs(upperX) : 0, ROOM_WIDTH);
|
|
lowerY = max(0, lowerY);
|
|
upperY = min(upperY < 0 ? abs(upperY) : 0, ROOM_HEIGHT);
|
|
|
|
|
|
//draw the tilemap
|
|
for (var j = lowerY; j < upperY; j++) {
|
|
for (var i = lowerX; i < upperX; i++) {
|
|
|
|
var pos = tileset[tilemap[i][j]];
|
|
node.setNodeRect(pos[0] * 16, pos[1] * 16, 16, 16);
|
|
|
|
node.drawNode(i * TILE_WIDTH, j * TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//utils functions for map generation
|
|
fn generateTilemap(seed: int, width: int, height: int) {
|
|
import random;
|
|
var rng: opaque = createRandomGenerator(seed);
|
|
|
|
//generate an empty grid
|
|
var result: [[string]] = [];
|
|
var row: [string] = [];
|
|
for (var j: int = 0; j < height; j++) {
|
|
row.push("pillar");
|
|
}
|
|
|
|
for (var i: int = 0; i < width; i++) {
|
|
result.push(row);
|
|
}
|
|
|
|
//generate the contents of the grid - floor
|
|
for (var j: int = 1; j < height - 1; j++) {
|
|
for (var i: int = 1; i < width - 1; i++) {
|
|
//select a random floor tile
|
|
var x: int = rng.generateRandomNumber() % 4;
|
|
var t: string = "floor-" + string x;
|
|
|
|
result[i][j] = t;
|
|
}
|
|
}
|
|
|
|
//draw top and bottom walls
|
|
for (var i: int = 1; i < width - 1; i++) {
|
|
result[i][0] = "wall-t";
|
|
result[i][height - 1] = "wall-b";
|
|
}
|
|
|
|
//draw the left and right walls
|
|
for (var j: int = 1; j < height - 1; j++) {
|
|
result[0][j] = "wall-l";
|
|
result[width-1][j] = "wall-r";
|
|
}
|
|
|
|
//draw the corners
|
|
result[0][0] = "corner-tl";
|
|
result[width - 1][0] = "corner-tr";
|
|
result[0][height - 1] = "corner-bl";
|
|
result[width - 1][height - 1] = "corner-br";
|
|
|
|
return result;
|
|
}
|
|
|
|
fn bakeCollisionMap(tilemap: [[string]], width: int, height: int) {
|
|
//generate an empty grid
|
|
var result: [[bool]] = [];
|
|
var row: [bool] = [];
|
|
for (var j: int = 0; j < height; j++) {
|
|
row.push(false);
|
|
}
|
|
|
|
for (var i: int = 0; i < width; i++) {
|
|
result.push(row);
|
|
}
|
|
|
|
//extract the collision map
|
|
for (var j: int = 0; j < height; j++) {
|
|
for (var i: int = 0; i < width; i++) {
|
|
//almost - you still need one pair of parentheses
|
|
result[i][j] = (tileset[ tilemap[i][j] ][2] != 0);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|