ROOM_CONS(ShardRoom, bool orb)
{
m_radius = 4;
boost::random::uniform_int_distribution<> xDist(2+m_radius,w-2-m_radius);
boost::random::uniform_int_distribution<> yDist(2+m_radius,h-2-m_radius);
m_x = xDist(RAND);
m_y = yDist(RAND);
m_orb = orb;
}
void
Dungeon::generate(Level *level)
{
for(int i=0; i<m_width*m_height;i++){
m_tiles[i] = m_tileFactory->getTile("Stone Floor");
}
generateCavern(0, m_height, 0, m_width,level);
bool placedUber = false;
for(int i=0;i<4;i++){
for(int ii=0;ii<80;ii++){
boost::random::uniform_int_distribution<> xDist(1,DUNGEON_WIN_W-2);
boost::random::uniform_int_distribution<> yDist(1,DUNGEON_WIN_H-2);
int x = xDist(RAND);
int y = yDist(RAND);
if(level->isWalkable(x,y)){
std::vector<std::string> tags;
int itemLevel = level->m_dungeonLevel;
if(!placedUber){
itemLevel += 3;
placedUber = true;
}
Actor *actor = level->m_actorFactory.getItem(itemLevel,level,tags);
if(actor != 0){
actor->m_x = x;
actor->m_y = y;
level->m_actors.push_back(actor);
ii=200;
}
}
}
}
int numExtraEnemies = 10;
if(level->m_dungeonLevel==15)
numExtraEnemies = 150;
for(int i=0;i<numExtraEnemies;i++){
for(int ii=0;ii<80;ii++){
boost::random::uniform_int_distribution<> xDist(1,DUNGEON_WIN_W-2);
boost::random::uniform_int_distribution<> yDist(1,DUNGEON_WIN_H-2);
int x = xDist(RAND);
int y = yDist(RAND);
if(level->isWalkable(x,y)){
std::vector<std::string> tags;
int hd = 1+level->m_dungeonLevel/4;
if(level->m_dungeonLevel == 1){
hd = 0;
}
Actor *actor = level->m_actorFactory.getCreature(hd,level,tags);
if(actor != 0){
actor->m_x = x;
actor->m_y = y;
level->m_actors.push_back(actor);
ii=200;
}
}
}
}
}
ROOM_CONS(SquareRoom, int size)
{
boost::random::uniform_int_distribution<> sizeDist(7,7);
switch(size){
case ROOM_SQUARE_SMALL:
sizeDist = boost::random::uniform_int_distribution<>(4,7);break;
case ROOM_SQUARE_MEDIUM:
sizeDist = boost::random::uniform_int_distribution<>(6,9);break;
case ROOM_SQUARE_LARGE:
sizeDist = boost::random::uniform_int_distribution<>(10,13);break;
case ROOM_SQUARE_HUGE:
sizeDist = boost::random::uniform_int_distribution<>(15,20);break;
}
m_w = sizeDist(RAND);
m_h = sizeDist(RAND);
m_roomWidth = m_w;
m_roomHeight = m_h;
boost::random::uniform_int_distribution<> xDist(2,w-2-m_w);
boost::random::uniform_int_distribution<> yDist(2,h-2-m_h);
m_x = xDist(RAND);
m_y = yDist(RAND);
boost::random::uniform_int_distribution<> doorWallDist(0,3);
boost::random::uniform_int_distribution<> numDoorsDist(1,3);
switch(size){
case ROOM_SQUARE_SMALL:
numDoorsDist = boost::random::uniform_int_distribution<>(1,2);break;
case ROOM_SQUARE_MEDIUM:
numDoorsDist = boost::random::uniform_int_distribution<>(1,2);break;
case ROOM_SQUARE_LARGE:
numDoorsDist = boost::random::uniform_int_distribution<>(1,3);break;
case ROOM_SQUARE_HUGE:
numDoorsDist = boost::random::uniform_int_distribution<>(2,5);break;
}
boost::random::uniform_int_distribution<> doorXDist(2,m_w-2);
boost::random::uniform_int_distribution<> doorYDist(2,m_h-2);
int numDoors = numDoorsDist(RAND);
for(int i=0;i<numDoors;i++){
CavernConnectivityPoint point;
int doorWall = doorWallDist(RAND);
point.x = doorXDist(RAND) + m_x;
point.y = doorYDist(RAND) + m_y;
switch(doorWall){
case 0: point.x = m_x;break;
case 1: point.x = m_x + m_w-1;break;
case 2: point.y = m_y;break;
case 3: point.y = m_y + m_h-1;break;
}
point.tag = -1;
point.type = CON_DUN;
m_doors.push_back(point);
}
}
void ParticleFilter::randomizeParticles(){
std::uniform_real_distribution<> xDist(xMin, xMax);
std::uniform_real_distribution<> yDist(yMin, yMax);
std::uniform_real_distribution<> dDist(dMin, dMax);
for(int i = 0; i < particleCount; i++){
particles[i].x = xDist(rnd);
particles[i].y = yDist(rnd);
particles[i].d = dDist(rnd);
particles[i].w = 0.0;
}
}
void
Dungeon::connectCaverns(int miny, int maxy, int minx, int maxx, char *tiles, std::vector<CavernConnectivityPoint> &points)
{
int width = maxx-minx;
int height = maxy-miny;
int numSteps = 500;
boost::random::uniform_int_distribution<> yDist(miny,maxy-1);
boost::random::uniform_int_distribution<> xDist(minx,maxx-1);
for(int i=0;i<numSteps;i++){
CavernConnectivityPoint point;
point.y = yDist(RAND);
point.x = xDist(RAND);
point.tag = -1;
point.type = CON_CAV;
if(tiles[point.x+point.y*width] == 0){
tiles[point.x+point.y*width] = 4;
points.push_back(point);
}
}
if(points.size() > 0){
CavernConnectivityPoint *point = &(points[0]);
point->tag = 1;
bool done = false;
while(!done){
recursiveConnectCaverns(width,height,point->y,point->x,tiles,&points);
float closestDist = FLT_MAX;
int closestPoint = -1;
int originPoint;
for(unsigned int i=0;i<points.size();i++){
if(points[i].tag == 1){
for(unsigned int ii=0;ii<points.size();ii++){
CavernConnectivityPoint &tmpPoint = points[ii];
if(tmpPoint.tag == -1 && (tmpPoint.roomID != points[i].roomID || tmpPoint.type != CON_DUN)){
float y = tmpPoint.y - points[i].y;
float x = tmpPoint.x - points[i].x;
float dist = y*y + x*x;
if(dist < closestDist){
closestDist = dist;
closestPoint = ii;
originPoint = i;
}
}
}
}
}
if(closestPoint != -1){
CavernConnectivityPoint &cp = points[closestPoint];
CavernConnectivityPoint &op = points[originPoint];
drawPath(op.y,cp.y,op.x,cp.x,width,tiles,setFloor);
cp.tag = 1;
point = &cp;
}
else{
done = true;
}
}
for(int i=0;i<width*height;i++){
if(tiles[i] < 126){
if(tiles[i]>1){
tiles[i] = 0;
}
else{
tiles[i] = 1;
}
}
}
}
}
void
SquareRoom::decorateRoom(Tile *tiles, TileFactory *tileFactory, std::vector<DecorationPlacement> &places)
{
boost::random::uniform_int_distribution<> xDist(1,m_w-2);
boost::random::uniform_int_distribution<> yDist(1,m_h-2);
double weights[] = {
0.20f,
1.00f,
1.00f,
1.00f,
1.50f,
0.30f,
};
boost::random::discrete_distribution<> patternDist(weights);
int pattern = patternDist(RAND) -1;
if(pattern >=0){
if(m_w < 4 || m_h < 4){
addDecoration(xDist(RAND),yDist(RAND),DEC_RANDOM,places);
}
else{
switch(pattern){
case 0: // corners
addDecoration( 1 , 1 ,DEC_PATTERN,places);
addDecoration( 1 ,m_h-2,DEC_PATTERN,places);
addDecoration(m_w-2, 1 ,DEC_PATTERN,places);
addDecoration(m_w-2,m_h-2,DEC_PATTERN,places);
break;
case 1: // corners, one in from walls
addDecoration( 2 , 2 ,DEC_PATTERN,places);
addDecoration( 2 ,m_h-3,DEC_PATTERN,places);
addDecoration(m_w-3, 2 ,DEC_PATTERN,places);
addDecoration(m_w-3,m_h-3,DEC_PATTERN,places);
break;
case 2: // one random
addDecoration(xDist(RAND),yDist(RAND),DEC_RANDOM,places);
break;
case 3: // few random
{
boost::random::uniform_int_distribution<> numDist(1,3);
//int numRand = numDist(RAND);
for(int i=0;i<m_w;i++){
addDecoration(xDist(RAND),yDist(RAND),DEC_RANDOM,places);
}
}
break;
case 4: // many random
{
boost::random::uniform_int_distribution<> numDist(4,7);
//int numRand = numDist(RAND);
for(int i=0;i<m_w;i++){
addDecoration(xDist(RAND),yDist(RAND),DEC_RANDOM,places);
}
}
break;
}
}
}
for(unsigned int i=0;i<m_doors.size();i++){
CavernConnectivityPoint &point = m_doors[i];
addDecoration(point.x-m_x,point.y-m_y,DEC_DOOR,places);
}
}
void
Room::decorate(char *charTiles, Tile *tiles, TileFactory *tileFactory, Level *level)
{
std::vector<std::string> creatureTags;
std::vector<DecorationPlacement> decorationPlacements;
std::vector<Decoration *> decorations;
decorateRoom(tiles, tileFactory, decorationPlacements);
int patternId = -1;
int randomId = -1;
int doorId = -1;
for(unsigned int i=0;i<decorationPlacements.size();i++){
DecorationPlacement &place = decorationPlacements[i];
Decoration *dec;
if(place.m_type == DEC_PATTERN)
dec = getPatternDecoration(patternId,place, creatureTags);
if(place.m_type == DEC_RANDOM)
dec = getRandomDecoration(randomId, place, creatureTags);
if(place.m_type == DEC_DOOR)
dec = getDoorDecoration(doorId, place, creatureTags,-1);
if(place.m_type == DEC_DOOR_CLOSED)
dec = getDoorDecoration(doorId, place, creatureTags, 1);
if(place.m_type == DEC_STAIRS_DOWN){
if(level->m_dungeonLevel < 15){
dec = getStairsDecoration(doorId, place, creatureTags, true);
}
else{
dec = getRandomDecoration(randomId, place, creatureTags);
}
}
if(place.m_type == DEC_STAIRS_UP)
dec = getStairsDecoration(doorId, place, creatureTags, false);
if(place.m_type == DEC_SHARD)
dec = getShardDecoration(doorId, place, creatureTags);
if(dec != 0){
if(dec->validate(charTiles)){
dec->reserve(charTiles);
decorations.push_back(dec);
}
else{
delete dec;
}
}
}
for(unsigned int i=0;i<decorations.size();i++){
decorations[i]->render(tiles, tileFactory, level);
delete decorations[i];
}
if(m_roomWidth > 0 && m_roomHeight > 0){
boost::random::uniform_int_distribution<> creatureNumDist(3,5);
boost::random::uniform_int_distribution<> xDist(0,m_roomWidth-1);
boost::random::uniform_int_distribution<> yDist(0,m_roomHeight-1);
int numCreatures = creatureNumDist(RAND);
for(int i=0;i<numCreatures;i++){
int x = xDist(RAND);
int y = yDist(RAND);
Tile *tile = getTile(x,y,tiles);
if(tile != 0 && tile->m_walkable){
int hd = 1+level->m_dungeonLevel/4;
Actor *actor = level->m_actorFactory.getCreature(hd,level,creatureTags);
if(actor != 0){
actor->m_x = m_x+x;
actor->m_y = m_y+y;
level->m_actors.push_back(actor);
}
}
}
}
}
