Map.cpp

#include "stdafx.h"

static const int ROOM_MAX_SIZE = 12;
static const int ROOM_MIN_SIZE = 6;
static const int MAX_ROOM_MONSTERS = 3;
static const int MAX_ROOM_ITEMS = 2;

class BspListener : public ITCODBspCallback {
private:
	Map & map; // a map to dig
	int roomNum; // room number
	int lastx, lasty; // center of the last room

public:
	BspListener(Map &map) : map(map), roomNum(0) {}

	bool visitNode(TCODBsp *node, void *userData) {
		if (node->isLeaf()) {
			int x, y, w, h;
			bool withActors = (bool)userData;
			// dig a room
			w = map.rng->getInt(ROOM_MIN_SIZE, node->w - 2);
			h = map.rng->getInt(ROOM_MIN_SIZE, node->h - 2);
			x = map.rng->getInt(node->x + 1, node->x + node->w - w - 1);
			y = map.rng->getInt(node->y + 1, node->y + node->h - h - 1);
			map.createRoom(roomNum == 0, x, y, x + w - 1, y + h - 1, withActors);

			if (roomNum != 0) {
				//dig a corridor from last room
				map.dig(lastx, lasty, x + w / 2, lasty);
				map.dig(x + w / 2, lasty, x + w / 2, y + h / 2);
			}

			lastx = x + w / 2;
			lasty = y + h / 2;
			roomNum++;
		}
		return true;
	}
};

Map::Map(int width, int height) : width(width), height(height) {
	seed = TCODRandom::getInstance()->getInt(0, 0x7FFFFFFF);
}

Map::~Map() {
	delete [] tiles;
	delete map;
}

bool Map::isWall(int x, int y) const {
	return !map->isWalkable(x, y);
}

bool Map::canWalk(int x, int y) const {
	if (isWall(x, y)) {
		// this is a wall
		return false;
	}
	for (Actor **iterator = engine.actors.begin();
		iterator != engine.actors.end(); iterator++) {
		Actor *actor = *iterator;
		if (actor->blocks && actor->x == x && actor->y == y) {
			//there's a blocking actor here
			return false;
		}
	}
	return true;
}

bool Map::isExplored(int x, int y) const {
	return tiles[x + y * width].explored;
}

bool Map::isInFOV(int x, int y) const {
	if (x < 0 || x >= width || y < 0 || y >= height) {
		return false;
	}
	if (map->isInFov(x, y)) {
		tiles[x + y * width].explored = true;
		return true;
	}
	return false;
}

void Map::init(bool withActors) {
	rng = new TCODRandom(seed, TCOD_RNG_CMWC);
	tiles = new Tile[width*height];
	map = new TCODMap(width, height);
	TCODBsp bsp(0, 0, width, height);
	bsp.splitRecursive(rng, 8, ROOM_MAX_SIZE, ROOM_MAX_SIZE, 1.5f, 1.5f);
	BspListener listener(*this);
	bsp.traverseInvertedLevelOrder(&listener, (void *)withActors);
}

void Map::computeFov() {
	map->computeFov(engine.player->x, engine.player->y,
		engine.fovRadius);
}

void Map::addMonster(int x, int y) {
	TCODRandom *rng = TCODRandom::getInstance();
	if (rng->getInt(0, 100) < 80) {
		//create a drone with 80% probability
		Actor *drone = new Actor(x, y, 'd', "drone",TCODColor::darkBlue);
		drone->destructible = new MonsterDestructible(10, 0, "drone parts", 50);
		drone->attacker = new Attacker(3);
		drone->ai = new MonsterAi();
		engine.actors.push(drone);
	}
	else {
		//create an android with 20% probability
		Actor *android = new Actor(x, y, 'a', "android", TCODColor::darkPurple);
		android->destructible = new MonsterDestructible(16, 1, "android parts", 125);
		android->attacker = new Attacker(4);
		android->ai = new MonsterAi();
		engine.actors.push(android);
	}
}

void Map::addItem(int x, int y) {

	TCODRandom *rng = TCODRandom::getInstance();
	int randomNumber = rng->getInt(0, 100);
	if (randomNumber < 70) { 
		//create a stimpak with 70% probability
		Actor *healthPotion = new Actor(x, y, '!', "stimpak",
			TCODColor::lightRed);
		healthPotion->blocks = false;
		healthPotion->pickable = new Healer(4);
		engine.actors.push(healthPotion);
	}
	else if (randomNumber < 80) { 
		// create a zapper with 10% probability
		Actor *taser = new Actor(x, y, '#', "taser",
			TCODColor::azure);
		taser->blocks = false;
		taser->pickable = new Taser(5, 20);
		engine.actors.push(taser);
	}
	else if (randomNumber < 90) { 
		// create a molotov with 10% probability
		Actor *molotovCocktail = new Actor(x, y, '#', "molotov cocktail",
			TCODColor::darkerFlame);
		molotovCocktail->blocks = false;
		molotovCocktail->pickable = new Molotov(3, 12);
		engine.actors.push(molotovCocktail);
	}
	else {
		// create an emp pulse device with 10% probability
		Actor *empDevice = new Actor(x, y, '#', "emp device",
			TCODColor::darkPink);
		empDevice->blocks = false;
		empDevice->pickable = new EmpPulse(10, 8);
		engine.actors.push(empDevice);
	}
}

void Map::dig(int x1, int y1, int x2, int y2) {
	if (x2 < x1) {
		int tmp = x2;
		x2 = x1;
		x1 = tmp;
	}
	if (y2 < y1) {
		int tmp = y2;
		y2 = y1;
		y1 = tmp;
	}
	for (int tilex = x1; tilex <= x2; tilex++) {
		for (int tiley = y1; tiley <= y2; tiley++) {
			map->setProperties(tilex, tiley, true, true);
		}
	}
}

void Map::createRoom(bool first, int x1, int y1, int x2, int y2, bool withActors) {
	dig(x1, y1, x2, y2);
	if (!withActors) {
		return;
	}
	if (first) {
		//put the player in the first room
		engine.player->x = (x1 + x2) / 2;
		engine.player->y = (y1 + y2) / 2;
	}
	else {
		TCODRandom *rng = TCODRandom::getInstance();
		int numberOfMonsters = rng->getInt(0, MAX_ROOM_MONSTERS);
		int numberOfItems = rng->getInt(0, MAX_ROOM_ITEMS);

		while (numberOfMonsters  > 0) {
			int x = rng->getInt(x1, x2);
			int y = rng->getInt(y1, y2);
			if (canWalk(x, y)) {
				addMonster(x, y);
			}
			numberOfMonsters--;
		}

		while (numberOfItems > 0) {
			int x = rng->getInt(x1, x2);
			int y = rng->getInt(y1, y2);
			if (canWalk(x, y)) {
				addItem(x, y);
			}
			numberOfItems--;
		}
	}
	// set stairs position
	engine.stairs->x = (x1 + x2) / 2;
	engine.stairs->y = (y1 + y2) / 2;
}

void Map::render() const {
	static const TCODColor darkWall(20, 25, 35);
	static const TCODColor darkGround(30, 35, 50);
	static const TCODColor lightWall(45, 65, 100);
	static const TCODColor lightGround(60, 110, 135);

	for (int x = 0; x < width; x++) {
		for (int y = 0; y < height; y++) {
			if (isInFOV(x, y)) {
				TCODConsole::root->setCharBackground(x, y,
					isWall(x, y) ? lightWall : lightGround);
			}
			else if (isExplored(x, y)) {
				TCODConsole::root->setCharBackground(x, y,
					isWall(x, y) ? darkWall : darkGround);
			}
		}
	}
}