Esempio n. 1
0
void sewer_level(void)
{
    int i,tx,ty,t,l,e;
    char rsi;
    Symbol lchar;

    Level->numrooms = random_range(3)+3;
    rsi = RS_DRAINED_SEWER;
    for (i=0; i<Level->numrooms; i++) {
        do {
            t = random_range((Level->level_length)-10)+1;
            l = random_range((Level->level_width)-10)+1;
            e = 4;
        } while ((Level->site[l][t].roomnumber == rsi) ||
                 (Level->site[l+e][t].roomnumber == rsi) ||
                 (Level->site[l][t+e].roomnumber == rsi) ||
                 (Level->site[l+e][t+e].roomnumber == rsi));
        if (random_range(5)) {
            lchar = FLOOR;
            rsi = RS_DRAINED_SEWER;
        }
        else {
            lchar = WATER;
            rsi = RS_DROWNED_SEWER;
        }
        build_room(l,t,e,rsi,i);
        sewer_corridor(l,t,-1,-1,lchar);
        sewer_corridor(l+e,t,1,-1,lchar);
        sewer_corridor(l,t+e,-1,1,lchar);
        sewer_corridor(l+e,t+e,1,1,lchar);
    }
    if (Current_Dungeon == E_SEWERS) {
        if ((Level->depth == SEWERLEVELS) && (State.getCompletedSewers() == false)) {
            findspace(&tx,&ty,-1);
            Level->mlist = ((MonsterList*) checkmalloc(sizeof(MonsterList)));
            Level->mlist->next = NULL;
            Level->mlist->monster =
                Level->site[tx][ty].creature =
                    ((Monster*) make_creature(GREAT_WYRM)); /* The Great Wyrm */
            Level->mlist->monster->x = tx;
            Level->mlist->monster->y = ty;
        }
    }
}
Esempio n. 2
0
    // Recursive city generator. Accepts 'depth' to determine
    // the segmentation granularity.
    void generate(int depth)
    {
        // determine the number of segments to cut vertically and horizontally
        int vRooms = randNext(ROOM_MIN_SEGMENTS, ROOM_MAX_SEGMENTS);
        int hRooms = randNext(ROOM_MIN_SEGMENTS, ROOM_MAX_SEGMENTS);

        // determine the size of each segment
        int vSize = city.getYSize() / vRooms;
        int hSize = city.getXSize() / hRooms;

        // often the factorization might not be clean
        // so determine where the vertical oversized segment should go.
        int *vSegments = new int[vRooms];
        for (int i = 0; i < vRooms; i++)
            vSegments[i] = vSize;
        int vIndex = randNext(0, vRooms);
        vSegments[vIndex] = vSize + city.getYSize() - (vSize * vRooms);

        // often the factorization might not be clean
        // so determine where the horizontal oversized segment should go.
        int *hSegments = new int[hRooms];
        for (int i = 0; i < hRooms; i++)
            hSegments[i] = hSize;
        int hIndex = randNext(0, hRooms);
        hSegments[hIndex] = hSize + city.getXSize() - (hSize * hRooms);

        // Start placing rooms recursively
        for (int i = 0, top = 0; i < vRooms; i++)
        {
            for (int j = 0, left = 0; j < hRooms; j++)
            {
                // determine the coordinates of the room
                int height = vSegments[i], width = hSegments[j];
                int actualTop = top, actualLeft = left;

                // this is to avoid double walling each room
                // if removed each room will sit inside a previous bound
                // hence adding a wall for each level of depth
                if (i != 0)
                {
                    actualTop = top - 1;
                    height += 1;
                }
                if (j != 0)
                {
                    actualLeft = left - 1;
                    width += 1;
                }

                // create room properties, this determines what kind of room, if it has doors
                // where the doors are, orientation, etc
                RoomProperties rp(actualTop, actualLeft, height, width);

                // determine if the room is a boundry for smaller rooms
                if (rp.isCompound)
                {
                    // build more rooms inside the boundary
                    generate(rp, depth - 1);
                } else
                {
                    // construct the room using the room properties
                    build_room(rp);
                }

                left += hSegments[j];
            }

            top += vSegments[i];
        }

        // construct the perimeter wall
        build_perimeter_wall();

        // add RED entities at a random position
        add_entities(Security::Mask::RED, 2, 4);

        // add ORANGE entities at a random position
        add_entities(Security::Mask::ORANGE, 1, 1);

        // change doors to ground
        finalize_doors();

        // find room locations
        // TODO: this can be removed( see comment on method)
        find_rooms();

        delete[] vSegments;
        delete[] hSegments;
    }
Esempio n. 3
0
    // Recursive city generator. Accepts 'depth' to determine
    // the segmentation granularity. This version uses room properties to
    // perform segmentation.
    void generate(const RoomProperties& roomProperties, int depth)
    {
        // if the depth is reached draw floor
        if (depth <= 0)
        {
            build_floor(roomProperties);
            return;
        }

        // determine the number of segments to cut vertically and horizontally
        int vRooms = randNext(ROOM_MIN_SEGMENTS, ROOM_MAX_SEGMENTS);
        int hRooms = randNext(ROOM_MIN_SEGMENTS, ROOM_MAX_SEGMENTS);

        // determine the size of each segment
        int vSize = roomProperties.height / vRooms;
        int hSize = roomProperties.width / hRooms;

        // if the size is too small return
        if ((vSize <= 0) || (hSize <= 0))
        {
            return;
        }

        // often the factorization might not be clean
        // so determine where the vertical oversized segment should go.
        int *vSegments = new int[vRooms];
        for (int i = 0; i < vRooms; i++)
            vSegments[i] = vSize;
        int vIndex = randNext(0, vRooms);
        vSegments[vIndex] = vSize + roomProperties.height - (vSize * vRooms);

        // often the factorization might not be clean
        // so determine where the horizontal oversized segment should go.
        int *hSegments = new int[hRooms];
        for (int i = 0; i < hRooms; i++)
            hSegments[i] = hSize;
        int hIndex = randNext(0, hRooms);
        hSegments[hIndex] = hSize + roomProperties.width - (hSize * hRooms);

        // Start placing rooms recursively
        for (int i = 0, top = roomProperties.top; i < vRooms; i++)
        {
            for (int j = 0, left = roomProperties.left; j < hRooms; j++)
            {
                // determine the coordinates of the room
                int height = vSegments[i], width = hSegments[j];
                int actualTop = top, actualLeft = left;

                // this is to avoid double walling each room
                // if removed each room will sit inside a previous bound
                // hence adding a wall for each level of depth
                if (i != 0)
                {
                    actualTop = top - 1;
                    height += 1;
                }
                if (j != 0)
                {
                    actualLeft = left - 1;
                    width += 1;
                }

                // create room properties, this determines what kind of room, if it has doors
                // where the doors are, orientation, etc
                RoomProperties rp(actualTop, actualLeft, height, width);

                // determine if the room is a boundry for smaller rooms
                if (rp.isCompound)
                {
                    // build more rooms inside the boundary
                    generate(rp, depth - 1);
                } else
                {
                    // construct the room using the room properties
                    build_room(rp);
                }

                left += hSegments[j];
            }
            top += vSegments[i];
        }

        delete[] vSegments;
        delete[] hSegments;
    }
Esempio n. 4
0
// this function is really ugly
static void generate(zone * z)
{
	static int first = 1;

	int i, x, y, max, timeout;
	int wall;
	int x1,x2,y1,y2;
	int rc;
	room ** rooms;
	item * it;
	creature * cr;

	if (first) {
		fill_walls();
		first = 0;
	}

	z->name = place_name(world.eth);

	rc = random() % ((z->width * z->height) / ROOM_INFREQ) + ROOM_MIN;
	rooms = malloc(sizeof(room*) * rc);

	//make everything walls!
	for (x = 0; x < z->width; x++) {
	for (y = 0; y < z->height; y++) {
		z->tiles[x][y].impassible = 1;
	}
	}

	//gen rooms and cut out
	for(i=0; i< rc; i++){
		rooms[i]=gen_room(world.grooms,1);
		build_room(z,rooms[i]);
	}

	//make sure rooms are connected!
	//connect each room to one other room

	for(i=0; i< rc; i++){
		max = random() % rc;
		room_spot(z,rooms[i],&x1,&y1);
		room_spot(z,rooms[max],&x2,&y2);
		wall=0;

		if(x1 == -1 || x2 == -1){
			warning("Room generation timed out!");
			break;
		}

		for(;x1 != x2; x1-= sign(x1-x2)){
			if(z->tiles[x1][y1].impassible) wall=1;
			else if (wall) break;

			zone_empty_tile(z,x1,y1);
		}

		for(;y1 != y2; y1-= sign(y1-y2)){
			if(z->tiles[x1][y1].impassible) wall=1;
			else if (wall) break;

			zone_empty_tile(z,x1,y1);
		}
	}

	//do rendering thing
	for (x = 0; x < z->width; x++) {
	for (y = 0; y < z->height; y++) {
		if (z->tiles[x][y].impassible) {
			set_wall_char(z,x,y);
		}
	}
	}

	for(i=0; i< rc; i++)
		free(rooms[i]);

	free(rooms);

	// place some random junk
	max = random() % (z->width * z->height / ITEM_INFREQ) + ITEM_MIN;
	for (i = max; i >= 0; i--) {
		it = gen_item(world.gitems, 1);

		timeout = 1000;
		do {
			x = random() % z->width;
			y = random() % z->height;
			timeout--;
		} while ((z->tiles[x][y].impassible || !inv_try(z->tiles[x][y].inv, it)) && timeout);

		if (timeout) {
			item_tele(it, x, y, z);
			zone_update(z, x, y);
		} else {
			item_free(it);
		}
	}

	// place some more random junk
	if (!config.all_alone) {
		max = random() % (z->width * z->height / CRTR_INFREQ) + CRTR_MIN;
		for (i = max; i >= 0; i--) {
			cr = gen_crtr(world.gcrtrs, 1);
			crtr_spawn(cr, z);
			zone_update(z, cr->x, cr->y);
		}
	}

	// place random zone jumpers
	for (i = 0; i < 4; i++) {
		do {
			x = random() % z->width;
			y = random() % z->height;
			timeout--;
		} while (z->tiles[x][y].impassible);

		z->tiles[x][y].linked = 1;
		z->tiles[x][y].link_z = NULL;
		z->tiles[x][y].ch = '@';
		z->tiles[x][y].show_ch = '@';
	}

	// cleanup
	//for (x = 0; x < z->width; x++) free(walls[x]);
	//free(walls);
	//free(rv);
}