nethack-gwaa-kiwi/nethack
1
0
Fork 0
Code Pull Requests Activity
Files
6586cc84b2ee98c8f124a50b9ceb879b4d64e7b4
nethack/src/extralev.c
nhmall 02a48aa8cf split g into multiple structures 
The consolidation of global variables from scattered source
files into decl.c and declared in decl.h was begun in 3.7.0.
Their placement in common files was done for centralized
initialization and potential re-initialization during a
"play again" scenario.

It wasn't really necessary for all of them to be housed in a
single huge structure to meet the "play again" requirement,
and the single huge structure has been a little unwieldy when
it comes to maintenance.

Following this commit, instead of one single extremely large structure
named 'g' to house all of the relocated global variables, they
are distributed into several ga through gz.

To make things easy for the developer, each variable is placed
into the struct corresponding to the starting letter of the variable.
That way, no lookup is required in order to know which struct houses
a particular variable, it is a simple match to the starting letter
for all the centralized global variables.

A global variable named 'amulets', would be found in ga.
    ga.amulets
     ^ ^
A global varable named 'move', would be found in gm.
    gm.moves
     ^ ^
A global variable named 'val_for_n_or_more' would be found in gv.
    gv.val_for_n_or_more
     ^ ^
A global variable named 'youmonst' would be found in gy.
    gy.youmonst
     ^ ^
2022-11-29 21:53:21 -05:00

358 lines
11 KiB
C
Raw Blame History

/* NetHack 3.7 extralev.c $NHDT-Date: 1596498169 2020/08/03 23:42:49 $ $NHDT-Branch: NetHack-3.7 $:$NHDT-Revision: 1.19 $ */
/* Copyright 1988, 1989 by Ken Arromdee */
/* NetHack may be freely redistributed. See license for details. */
/*
* Support code for "rogue"-style level.
*/
#include "hack.h"
#define XL_UP 1
#define XL_DOWN 2
#define XL_LEFT 4
#define XL_RIGHT 8
static void roguejoin(coordxy, coordxy, coordxy, coordxy, int);
static void roguecorr(coordxy, coordxy, int);
static void miniwalk(coordxy, coordxy);
static
void
roguejoin(coordxy x1, coordxy y1, coordxy x2, coordxy y2, int horiz)
{
register coordxy x, y, middle;
if (horiz) {
middle = x1 + rn2(x2 - x1 + 1);
for (x = min(x1, middle); x <= max(x1, middle); x++)
corr(x, y1);
for (y = min(y1, y2); y <= max(y1, y2); y++)
corr(middle, y);
for (x = min(middle, x2); x <= max(middle, x2); x++)
corr(x, y2);
} else {
middle = y1 + rn2(y2 - y1 + 1);
for (y = min(y1, middle); y <= max(y1, middle); y++)
corr(x1, y);
for (x = min(x1, x2); x <= max(x1, x2); x++)
corr(x, middle);
for (y = min(middle, y2); y <= max(middle, y2); y++)
corr(x2, y);
}
}
static
void
roguecorr(coordxy x, coordxy y, int dir)
{
register coordxy fromx, fromy, tox, toy;
if (dir == XL_DOWN) {
gr.r[x][y].doortable &= ~XL_DOWN;
if (!gr.r[x][y].real) {
fromx = gr.r[x][y].rlx;
fromy = gr.r[x][y].rly;
fromx += 1 + 26 * x;
fromy += 7 * y;
} else {
fromx = gr.r[x][y].rlx + rn2(gr.r[x][y].dx);
fromy = gr.r[x][y].rly + gr.r[x][y].dy;
fromx += 1 + 26 * x;
fromy += 7 * y;
if (!IS_WALL(levl[fromx][fromy].typ))
impossible("down: no wall at %d,%d?", fromx, fromy);
dodoor(fromx, fromy, &gr.rooms[gr.r[x][y].nroom]);
levl[fromx][fromy].doormask = D_NODOOR;
fromy++;
}
if (y >= 2) {
impossible("down door from %d,%d going nowhere?", x, y);
return;
}
y++;
gr.r[x][y].doortable &= ~XL_UP;
if (!gr.r[x][y].real) {
tox = gr.r[x][y].rlx;
toy = gr.r[x][y].rly;
tox += 1 + 26 * x;
toy += 7 * y;
} else {
tox = gr.r[x][y].rlx + rn2(gr.r[x][y].dx);
toy = gr.r[x][y].rly - 1;
tox += 1 + 26 * x;
toy += 7 * y;
if (!IS_WALL(levl[tox][toy].typ))
impossible("up: no wall at %d,%d?", tox, toy);
dodoor(tox, toy, &gr.rooms[gr.r[x][y].nroom]);
levl[tox][toy].doormask = D_NODOOR;
toy--;
}
roguejoin(fromx, fromy, tox, toy, FALSE);
return;
} else if (dir == XL_RIGHT) {
gr.r[x][y].doortable &= ~XL_RIGHT;
if (!gr.r[x][y].real) {
fromx = gr.r[x][y].rlx;
fromy = gr.r[x][y].rly;
fromx += 1 + 26 * x;
fromy += 7 * y;
} else {
fromx = gr.r[x][y].rlx + gr.r[x][y].dx;
fromy = gr.r[x][y].rly + rn2(gr.r[x][y].dy);
fromx += 1 + 26 * x;
fromy += 7 * y;
if (!IS_WALL(levl[fromx][fromy].typ))
impossible("down: no wall at %d,%d?", fromx, fromy);
dodoor(fromx, fromy, &gr.rooms[gr.r[x][y].nroom]);
levl[fromx][fromy].doormask = D_NODOOR;
fromx++;
}
if (x >= 2) {
impossible("right door from %d,%d going nowhere?", x, y);
return;
}
x++;
gr.r[x][y].doortable &= ~XL_LEFT;
if (!gr.r[x][y].real) {
tox = gr.r[x][y].rlx;
toy = gr.r[x][y].rly;
tox += 1 + 26 * x;
toy += 7 * y;
} else {
tox = gr.r[x][y].rlx - 1;
toy = gr.r[x][y].rly + rn2(gr.r[x][y].dy);
tox += 1 + 26 * x;
toy += 7 * y;
if (!IS_WALL(levl[tox][toy].typ))
impossible("left: no wall at %d,%d?", tox, toy);
dodoor(tox, toy, &gr.rooms[gr.r[x][y].nroom]);
levl[tox][toy].doormask = D_NODOOR;
tox--;
}
roguejoin(fromx, fromy, tox, toy, TRUE);
return;
} else
impossible("corridor in direction %d?", dir);
}
/* Modified walkfrom() from mkmaze.c */
static
void
miniwalk(coordxy x, coordxy y)
{
register int q, dir;
int dirs[4];
while (1) {
q = 0;
#define doorhere (gr.r[x][y].doortable)
if (x > 0 && (!(doorhere & XL_LEFT))
&& (!gr.r[x - 1][y].doortable || !rn2(10)))
dirs[q++] = 0;
if (x < 2 && (!(doorhere & XL_RIGHT))
&& (!gr.r[x + 1][y].doortable || !rn2(10)))
dirs[q++] = 1;
if (y > 0 && (!(doorhere & XL_UP))
&& (!gr.r[x][y - 1].doortable || !rn2(10)))
dirs[q++] = 2;
if (y < 2 && (!(doorhere & XL_DOWN))
&& (!gr.r[x][y + 1].doortable || !rn2(10)))
dirs[q++] = 3;
/* Rogue levels aren't just 3 by 3 mazes; they have some extra
* connections, thus that 1/10 chance
*/
if (!q)
return;
dir = dirs[rn2(q)];
switch (dir) { /* Move in direction */
case 0:
doorhere |= XL_LEFT;
x--;
doorhere |= XL_RIGHT;
break;
case 1:
doorhere |= XL_RIGHT;
x++;
doorhere |= XL_LEFT;
break;
case 2:
doorhere |= XL_UP;
y--;
doorhere |= XL_DOWN;
break;
case 3:
doorhere |= XL_DOWN;
y++;
doorhere |= XL_UP;
break;
}
miniwalk(x, y);
}
#undef doorhere
}
void
makeroguerooms(void)
{
register coordxy x, y;
/* Rogue levels are structured 3 by 3, with each section containing
* a room or an intersection. The minimum width is 2 each way.
* One difference between these and "real" Rogue levels: real Rogue
* uses 24 rows and NetHack only 23. So we cheat a bit by making the
* second row of rooms not as deep.
*
* Each normal space has 6/7 rows and 25 columns in which a room may
* actually be placed. Walls go from rows 0-5/6 and columns 0-24.
* Not counting walls, the room may go in
* rows 1-5 and columns 1-23 (numbering starting at 0). A room
* coordinate of this type may be converted to a level coordinate
* by adding 1+28*x to the column, and 7*y to the row. (The 1
* is because column 0 isn't used [we only use 1-78]).
* Room height may be 2-4 (2-5 on last row), length 2-23 (not
* counting walls).
*/
#define here gr.r[x][y]
gn.nroom = 0;
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++) {
/* Note: we want to insure at least 1 room. So, if the
* first 8 are all dummies, force the last to be a room.
*/
if (!rn2(5) && (gn.nroom || (x < 2 && y < 2))) {
/* Arbitrary: dummy rooms may only go where real
* ones do.
*/
here.real = FALSE;
here.rlx = rn1(22, 2);
here.rly = rn1((y == 2) ? 4 : 3, 2);
} else {
here.real = TRUE;
here.dx = rn1(22, 2); /* 2-23 long, plus walls */
here.dy = rn1((y == 2) ? 4 : 3, 2); /* 2-5 high, plus walls */
/* boundaries of room floor */
here.rlx = rnd(23 - here.dx + 1);
here.rly = rnd(((y == 2) ? 5 : 4) - here.dy + 1);
gn.nroom++;
}
here.doortable = 0;
}
miniwalk(rn2(3), rn2(3));
gn.nroom = 0;
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++) {
if (here.real) { /* Make a room */
coordxy lowx, lowy, hix, hiy;
gr.r[x][y].nroom = gn.nroom;
gs.smeq[gn.nroom] = gn.nroom;
lowx = 1 + 26 * x + here.rlx;
lowy = 7 * y + here.rly;
hix = 1 + 26 * x + here.rlx + here.dx - 1;
hiy = 7 * y + here.rly + here.dy - 1;
/* Strictly speaking, it should be lit only if above
* level 10, but since Rogue rooms are only
* encountered below level 10, use !rn2(7).
*/
add_room(lowx, lowy, hix, hiy, (boolean) !rn2(7), OROOM,
FALSE);
}
}
/* Now, add connecting corridors. */
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++) {
if (here.doortable & XL_DOWN)
roguecorr(x, y, XL_DOWN);
if (here.doortable & XL_RIGHT)
roguecorr(x, y, XL_RIGHT);
if (here.doortable & XL_LEFT)
impossible("left end of %d, %d never connected?", x, y);
if (here.doortable & XL_UP)
impossible("up end of %d, %d never connected?", x, y);
}
#undef here
}
void
corr(coordxy x, coordxy y)
{
if (rn2(50)) {
levl[x][y].typ = CORR;
} else {
levl[x][y].typ = SCORR;
}
}
void
makerogueghost(void)
{
register struct monst *ghost;
struct obj *ghostobj;
struct mkroom *croom;
coordxy x, y;
if (!gn.nroom)
return; /* Should never happen */
croom = &gr.rooms[rn2(gn.nroom)];
x = somex(croom);
y = somey(croom);
if (!(ghost = makemon(&mons[PM_GHOST], x, y, NO_MM_FLAGS)))
return;
ghost->msleeping = 1;
ghost = christen_monst(ghost, roguename());
if (rn2(4)) {
ghostobj = mksobj_at(FOOD_RATION, x, y, FALSE, FALSE);
ghostobj->quan = (long) rnd(7);
ghostobj->owt = weight(ghostobj);
}
if (rn2(2)) {
ghostobj = mksobj_at(MACE, x, y, FALSE, FALSE);
ghostobj->spe = rnd(3);
if (rn2(4))
curse(ghostobj);
} else {
ghostobj = mksobj_at(TWO_HANDED_SWORD, x, y, FALSE, FALSE);
ghostobj->spe = rnd(5) - 2;
if (rn2(4))
curse(ghostobj);
}
ghostobj = mksobj_at(BOW, x, y, FALSE, FALSE);
ghostobj->spe = 1;
if (rn2(4))
curse(ghostobj);
ghostobj = mksobj_at(ARROW, x, y, FALSE, FALSE);
ghostobj->spe = 0;
ghostobj->quan = (long) rn1(10, 25);
ghostobj->owt = weight(ghostobj);
if (rn2(4))
curse(ghostobj);
if (rn2(2)) {
ghostobj = mksobj_at(RING_MAIL, x, y, FALSE, FALSE);
ghostobj->spe = rn2(3);
if (!rn2(3))
ghostobj->oerodeproof = TRUE;
if (rn2(4))
curse(ghostobj);
} else {
ghostobj = mksobj_at(PLATE_MAIL, x, y, FALSE, FALSE);
ghostobj->spe = rnd(5) - 2;
if (!rn2(3))
ghostobj->oerodeproof = TRUE;
if (rn2(4))
curse(ghostobj);
}
if (rn2(2)) {
ghostobj = mksobj_at(FAKE_AMULET_OF_YENDOR, x, y, TRUE, FALSE);
ghostobj->known = TRUE;
}
}
/*extralev.c*/
View Git Blame Copy Permalink