496 lines
14 KiB
C
496 lines
14 KiB
C
/* omega copyright (c) 1987,1988,1989 by Laurence Raphael Brothers */
|
|
/* gen2.c */
|
|
/* level generator functions */
|
|
|
|
#include "glob.h"
|
|
|
|
|
|
|
|
/* For each level, there should be one stairway going up and one down.
|
|
fromlevel determines whether the player is placed on the up or the down
|
|
staircase. The aux value is currently unused elsewhere, but is set
|
|
to the destination level. */
|
|
|
|
void make_stairs(int fromlevel)
|
|
{
|
|
int i,j;
|
|
/* no stairway out of astral */
|
|
if (Current_Environment != E_ASTRAL) {
|
|
findspace(&i,&j,-1);
|
|
Level->site[i][j].locchar = STAIRS_UP;
|
|
Level->site[i][j].aux = Level->depth-1;
|
|
lset(i,j,STOPS);
|
|
if (fromlevel >= 0 && fromlevel < Level->depth) {
|
|
Player.x = i;
|
|
Player.y = j;
|
|
}
|
|
}
|
|
if (Level->depth < MaxDungeonLevels) {
|
|
findspace(&i,&j,-1);
|
|
Level->site[i][j].locchar = STAIRS_DOWN;
|
|
Level->site[i][j].aux = Level->depth+1;
|
|
lset(i,j,STOPS);
|
|
if (fromlevel > Level->depth) {
|
|
Player.x = i;
|
|
Player.y = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* tactical map generating functions */
|
|
|
|
|
|
void make_country_screen(Symbol terrain)
|
|
{
|
|
int i,j;
|
|
TempLevel = Level;
|
|
if (ok_to_free(TempLevel)) {
|
|
#ifndef SAVE_LEVELS
|
|
free_level(TempLevel);
|
|
#endif
|
|
TempLevel = NULL;
|
|
}
|
|
#ifndef SAVE_LEVELS
|
|
Level = ((plv) checkmalloc(sizeof(levtype)));
|
|
#else
|
|
msdos_changelevel(TempLevel,0,-1);
|
|
Level = &TheLevel;
|
|
#endif
|
|
clear_level(Level);
|
|
Level->environment = E_TACTICAL_MAP;
|
|
Level->generated = TRUE;
|
|
|
|
Level->level_length = TACTICAL_LENGTH;
|
|
Level->level_width = TACTICAL_WIDTH;
|
|
|
|
switch(terrain) {
|
|
case FOREST: make_forest(); break;
|
|
case JUNGLE: make_jungle(); break;
|
|
case SWAMP: make_swamp(); break;
|
|
case RIVER: make_river(); break;
|
|
case MOUNTAINS: case PASS: make_mountains(); break;
|
|
case ROAD: make_road(); break;
|
|
default: make_plains(); break;
|
|
}
|
|
if (nighttime()) {
|
|
print3("Night's gloom shrouds your sight.");
|
|
for(i=0;i<Level->level_width;i++)
|
|
for(j=0;j<Level->level_length;j++) {
|
|
Level->site[i][j].showchar = SPACE;
|
|
Level->site[i][j].lstatus = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void make_general_map(char *terrain)
|
|
{
|
|
int i, j;
|
|
int size = strlen(terrain);
|
|
char curr;
|
|
|
|
for (i=0;i<Level->level_width;i++)
|
|
for (j=0;j<Level->level_length;j++) {
|
|
if ((i == 0 && j == 0) || !random_range(5))
|
|
curr = terrain[random_range(size)];
|
|
else if (j == 0 || (random_range(2) && i > 0))
|
|
curr = Level->site[i - 1][j].locchar&0xff;
|
|
else
|
|
curr = Level->site[i][j - 1].locchar&0xff;
|
|
switch (curr) {
|
|
case (FLOOR&0xff):
|
|
Level->site[i][j].locchar = Level->site[i][j].showchar = FLOOR;
|
|
Level->site[i][j].p_locf = L_NO_OP;
|
|
break;
|
|
case (HEDGE&0xff):
|
|
Level->site[i][j].locchar = Level->site[i][j].showchar = HEDGE;
|
|
Level->site[i][j].p_locf = L_HEDGE;
|
|
break;
|
|
case (WATER&0xff):
|
|
Level->site[i][j].locchar = Level->site[i][j].showchar = WATER;
|
|
Level->site[i][j].p_locf = L_WATER;
|
|
break;
|
|
case (RUBBLE&0xff):
|
|
Level->site[i][j].locchar = Level->site[i][j].showchar = RUBBLE;
|
|
Level->site[i][j].p_locf = L_RUBBLE;
|
|
break;
|
|
}
|
|
Level->site[i][j].lstatus = SEEN+LIT;
|
|
Level->site[i][j].roomnumber = RS_COUNTRYSIDE;
|
|
if ((i == 0) || (j == 0) || (i == (Level->level_width)-1) || (j == (Level->level_length)-1))
|
|
Level->site[i][j].p_locf = L_TACTICAL_EXIT;
|
|
}
|
|
}
|
|
|
|
void make_plains(void)
|
|
{
|
|
make_general_map(".");
|
|
}
|
|
|
|
void make_road(void)
|
|
{
|
|
int x, y;
|
|
make_general_map("\"\"~4....");
|
|
for (x = (Level->level_width)/2 - 3; x <= (Level->level_width)/2 + 3; x++)
|
|
for (y = 0; y < Level->level_length; y++) {
|
|
Level->site[x][y].locchar = Level->site[x][y].showchar = FLOOR;
|
|
if (y != 0 && y != ((Level->level_length) - 1))
|
|
Level->site[x][y].p_locf = L_NO_OP;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void make_forest(void)
|
|
{
|
|
make_general_map("\".");
|
|
straggle_corridor(0,random_range(Level->level_length),Level->level_width,random_range(Level->level_length),
|
|
WATER,RS_COUNTRYSIDE);
|
|
}
|
|
|
|
|
|
void make_jungle(void)
|
|
{
|
|
make_general_map("\"\".");
|
|
}
|
|
|
|
|
|
void make_river(void)
|
|
{
|
|
int i,y,y1;
|
|
make_general_map("\".......");
|
|
y = random_range(Level->level_length);
|
|
y1 = random_range(Level->level_length);
|
|
straggle_corridor(0,y,Level->level_width,y1,WATER,RS_COUNTRYSIDE);
|
|
for(i=0;i<7;i++) {
|
|
if (y > (Level->level_length)/2) y--;
|
|
else y++;
|
|
if (y1 > (Level->level_length)/2) y1--;
|
|
else y1++;
|
|
straggle_corridor(0,y,Level->level_width,y1,WATER,RS_COUNTRYSIDE);
|
|
}
|
|
}
|
|
|
|
|
|
void make_mountains(void)
|
|
{
|
|
int i,x,y,x1,y1;
|
|
make_general_map("4...");
|
|
x = 0;
|
|
y = random_range(Level->level_length);
|
|
x1 = Level->level_width;
|
|
y1 = random_range(Level->level_length);
|
|
straggle_corridor(x,y,x1,y1,WATER,RS_COUNTRYSIDE);
|
|
for(i=0;i<7;i++) {
|
|
x = random_range(Level->level_width);
|
|
x1 = random_range(Level->level_width);
|
|
y = 0;
|
|
y1 = Level->level_length;
|
|
straggle_corridor(x,y,x1,y1,WATER,RS_COUNTRYSIDE);
|
|
}
|
|
}
|
|
|
|
|
|
void make_swamp(void)
|
|
{
|
|
make_general_map("~~\".");
|
|
}
|
|
|
|
|
|
|
|
/* builds a room. Then, for each successive room, sends off at least one
|
|
corridor which is guaranteed to connect up to another room, thus guaranteeing
|
|
fully connected level. */
|
|
|
|
void room_level(void)
|
|
{
|
|
int i,fx,fy,tx,ty,t,l,e;
|
|
char rsi;
|
|
|
|
Level->numrooms = random_range(8)+9;
|
|
|
|
do {
|
|
t = random_range((Level->level_length)-10)+1;
|
|
l = random_range((Level->level_width)-10)+1;
|
|
e = 4+random_range(5);
|
|
} while ((Level->site[l][t].roomnumber != RS_WALLSPACE) ||
|
|
(Level->site[l+e][t].roomnumber != RS_WALLSPACE) ||
|
|
(Level->site[l][t+e].roomnumber != RS_WALLSPACE) ||
|
|
(Level->site[l+e][t+e].roomnumber != RS_WALLSPACE));
|
|
if (Current_Dungeon == E_SEWERS) {
|
|
if (random_range(2)) rsi = RS_SEWER_CONTROL;
|
|
else rsi = ROOMBASE+random_range(NUMROOMNAMES);
|
|
}
|
|
else rsi = ROOMBASE+random_range(NUMROOMNAMES);
|
|
build_room(l,t,e,rsi,1);
|
|
|
|
|
|
for (i=2;i<=Level->numrooms;i++) {
|
|
do {
|
|
t = random_range((Level->level_length)-10)+1;
|
|
l = random_range((Level->level_width)-10)+1;
|
|
e = 4+random_range(5);
|
|
} while ((Level->site[l][t].roomnumber != RS_WALLSPACE) ||
|
|
(Level->site[l+e][t].roomnumber != RS_WALLSPACE) ||
|
|
(Level->site[l][t+e].roomnumber != RS_WALLSPACE) ||
|
|
(Level->site[l+e][t+e].roomnumber != RS_WALLSPACE));
|
|
if (Current_Dungeon == E_SEWERS) {
|
|
if (random_range(2)) rsi = RS_SEWER_CONTROL;
|
|
else rsi = ROOMBASE+random_range(NUMROOMNAMES);
|
|
}
|
|
else rsi = ROOMBASE+random_range(NUMROOMNAMES);
|
|
build_room(l,t,e,rsi,i);
|
|
|
|
|
|
/* corridor which is guaranteed to connect */
|
|
findspace(&tx,&ty,i);
|
|
|
|
/* figure out where to start corridor from */
|
|
if ((ty <= t) && (tx <= l+e)) {
|
|
fx = l+1+random_range(e-1);
|
|
fy = t;
|
|
}
|
|
else if ((tx >= l+e) && (ty <= t+e)) {
|
|
fx = l+e;
|
|
fy = t+1+random_range(e-1);
|
|
}
|
|
else if ((ty >= t+e) && (tx >= l)) {
|
|
fx = l+1+random_range(e-1);
|
|
fy = t+e;
|
|
}
|
|
else {
|
|
fx = l;
|
|
fy = t+1+random_range(e-1);
|
|
}
|
|
|
|
room_corridor(fx,fy,tx,ty,i);
|
|
|
|
|
|
/* corridor which may not go anywhere */
|
|
if (random_range(2)) {
|
|
findspace(&tx,&ty,i);
|
|
if ((ty <= t) && (tx <= l+e)) {
|
|
fx = l+1+random_range(e-1);
|
|
fy = t;
|
|
}
|
|
else if ((tx >= l+e) && (ty <= t+e)) {
|
|
fx = l+e;
|
|
fy = t+1+random_range(e-1);
|
|
}
|
|
else if ((ty >= t+e) && (tx >= l)) {
|
|
fx = l+1+random_range(e-1);
|
|
fy = t+e;
|
|
}
|
|
else {
|
|
fx = l;
|
|
fy = t+1+random_range(e-1);
|
|
}
|
|
room_corridor(fx,fy,tx,ty,i);
|
|
}
|
|
}
|
|
|
|
if (Current_Dungeon == E_SEWERS) {
|
|
if (Level->depth == SEWERLEVELS) {
|
|
findspace(&tx,&ty,-1);
|
|
Level->mlist = ((pml) checkmalloc(sizeof(mltype)));
|
|
Level->mlist->next = NULL;
|
|
Level->mlist->m =
|
|
Level->site[tx][ty].creature =
|
|
((pmt) make_creature(GREAT_WYRM)); /* The Great Wyrm */
|
|
Level->mlist->m->x = tx;
|
|
Level->mlist->m->y = ty;
|
|
}
|
|
}
|
|
|
|
if (Current_Dungeon == E_PALACE) { /* PGM TODO */
|
|
if (Level->depth == PALACELEVELS) {
|
|
findspace(&tx,&ty,-1);
|
|
Level->mlist = ((pml) checkmalloc(sizeof(mltype)));
|
|
Level->mlist->next = NULL;
|
|
Level->mlist->m =
|
|
Level->site[tx][ty].creature =
|
|
((pmt) make_creature(MAHARAJA)); /* The Maharaja */
|
|
Level->mlist->m->x = tx;
|
|
Level->mlist->m->y = ty;
|
|
}
|
|
}
|
|
|
|
else if (Current_Environment == E_CASTLE) {
|
|
if (Level->depth == CASTLELEVELS) {
|
|
findspace(&tx,&ty,-1);
|
|
Level->site[tx][ty].locchar = STAIRS_DOWN;
|
|
Level->site[tx][ty].p_locf = L_ENTER_COURT;
|
|
}
|
|
}
|
|
else if (Current_Environment == E_VOLCANO) {
|
|
if (Level->depth == VOLCANOLEVELS && !gamestatusp(COMPLETED_VOLCANO)) {
|
|
findspace(&tx,&ty,-1);
|
|
Level->mlist = ((pml) checkmalloc(sizeof(mltype)));
|
|
Level->mlist->next = NULL;
|
|
Level->mlist->m =
|
|
Level->site[tx][ty].creature =
|
|
((pmt) make_creature(DEMON_EMP)); /* The demon emp */
|
|
Level->mlist->m->x = tx;
|
|
Level->mlist->m->y = ty;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* goes from f to t unless it hits a site which is not a wall and doesn't
|
|
have buildaux field == baux */
|
|
void room_corridor(int fx, int fy, int tx, int ty, int baux)
|
|
{
|
|
int dx,dy,continuing = TRUE;
|
|
|
|
dx = sign(tx-fx);
|
|
dy = sign(ty-fy);
|
|
|
|
makedoor(fx,fy);
|
|
|
|
fx+=dx;
|
|
fy+=dy;
|
|
|
|
while(continuing) {
|
|
Level->site[fx][fy].locchar = FLOOR;
|
|
Level->site[fx][fy].roomnumber = RS_CORRIDOR;
|
|
Level->site[fx][fy].buildaux = baux;
|
|
dx = sign(tx-fx);
|
|
dy = sign(ty-fy);
|
|
if ((dx != 0) && (dy != 0)) {
|
|
if (random_range(2)) dx = 0;
|
|
else if (random_range(2)) dy = 0;
|
|
}
|
|
fx+=dx;
|
|
fy+=dy;
|
|
continuing = (((fx != tx) || (fy != ty)) &&
|
|
((Level->site[fx][fy].buildaux == 0) ||
|
|
(Level->site[fx][fy].buildaux == baux)));
|
|
}
|
|
makedoor(fx,fy);
|
|
}
|
|
|
|
void maze_level (void)
|
|
{
|
|
int mid;
|
|
int y_idx;
|
|
int x_idx;
|
|
int tx, ty;
|
|
|
|
char rsi = RS_VOLCANO;
|
|
|
|
if (E_ASTRAL == Current_Environment)
|
|
{
|
|
switch (Level->depth)
|
|
{
|
|
case 1: rsi = RS_EARTHPLANE; break;
|
|
case 2: rsi = RS_AIRPLANE; break;
|
|
case 3: rsi = RS_WATERPLANE; break;
|
|
case 4: rsi = RS_FIREPLANE; break;
|
|
case 5: rsi = RS_HIGHASTRAL; break;
|
|
}
|
|
|
|
maze_corridor(1 + random_range(Level->level_width - 1),
|
|
1 + random_range(Level->level_length - 1),
|
|
1 + random_range(Level->level_width - 1),
|
|
1 + random_range(Level->level_length - 1),
|
|
rsi,
|
|
0);
|
|
|
|
if (E_ASTRAL == Current_Dungeon)
|
|
{
|
|
for (x_idx = 0; x_idx < Level->level_width; ++x_idx)
|
|
{
|
|
for (y_idx = 0; y_idx < Level->level_length; ++y_idx)
|
|
{
|
|
if (WALL == Level->site[x_idx][y_idx].locchar)
|
|
{
|
|
switch (Level->depth)
|
|
{
|
|
case 1:
|
|
Level->site[x_idx][y_idx].aux = 500;
|
|
break;
|
|
|
|
case 2:
|
|
Level->site[x_idx][y_idx].locchar = WHIRLWIND;
|
|
Level->site[x_idx][y_idx].p_locf = L_WHIRLWIND;
|
|
break;
|
|
|
|
case 3:
|
|
Level->site[x_idx][y_idx].locchar = WATER;
|
|
Level->site[x_idx][y_idx].p_locf = L_WATER;
|
|
break;
|
|
|
|
case 4:
|
|
Level->site[x_idx][y_idx].locchar = FIRE;
|
|
Level->site[x_idx][y_idx].p_locf = L_FIRE;
|
|
break;
|
|
|
|
case 5:
|
|
Level->site[x_idx][y_idx].locchar = ABYSS;
|
|
Level->site[x_idx][y_idx].p_locf = L_ABYSS;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (Level->depth)
|
|
{
|
|
case 1: mid = LORD_EARTH; break; /* Elemental Lord of Earth */
|
|
case 2: mid = LORD_AIR; break; /* Elemental Lord of Air */
|
|
case 3: mid = LORD_WATER; break; /* Elemental Lord of Water */
|
|
case 4: mid = LORD_FIRE; break; /* Elemental Lord of Fire */
|
|
case 5: mid = ELEM_MASTER; break; /* Elemental Master */
|
|
default: mid = ELEM_MASTER; assert(FALSE); /* bomb if this happens */
|
|
}
|
|
|
|
if (5 == Level->depth)
|
|
{
|
|
findspace(&tx, &ty, -1);
|
|
Level->site[tx][ty].p_locf = L_ENTER_CIRCLE;
|
|
Level->site[tx][ty].locchar = STAIRS_DOWN;
|
|
}
|
|
|
|
if (!gamestatusp(COMPLETED_ASTRAL))
|
|
{
|
|
findspace(&tx, &ty, -1);
|
|
Level->mlist = checkmalloc(sizeof(mltype));
|
|
Level->mlist->next = NULL;
|
|
Level->mlist->m = make_creature(mid);
|
|
Level->mlist->m->x = tx;
|
|
Level->mlist->m->y = ty;
|
|
Level->site[tx][ty].creature = Level->mlist->m;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (E_VOLCANO == Current_Environment)
|
|
{
|
|
if (VOLCANOLEVELS == Level->depth && !gamestatusp(COMPLETED_VOLCANO))
|
|
{
|
|
findspace(&tx, &ty, -1);
|
|
Level->mlist = checkmalloc(sizeof(mltype));
|
|
Level->mlist->next = NULL;
|
|
Level->mlist->m = make_creature(DEMON_EMP);
|
|
Level->mlist->m->x = tx;
|
|
Level->mlist->m->y = ty;
|
|
Level->site[tx][ty].creature = Level->mlist->m;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* keep drawing corridors recursively for 2^5 endpoints */
|
|
void maze_corridor(int fx, int fy, int tx, int ty, char rsi, char num)
|
|
{
|
|
if (num < 6) {
|
|
straggle_corridor(fx,fy,tx,ty,FLOOR,rsi);
|
|
maze_corridor(tx,ty,
|
|
random_range((Level->level_width)-1)+1,
|
|
random_range((Level->level_length)-1)+1,
|
|
rsi,num+1);
|
|
|
|
}
|
|
}
|