nethack-gwaa-kiwi/nethack
1
0
Fork 0
Code Pull Requests Activity

Remove src and unix VISION_TABLES

Browse Source 
Remove all references to the unused vision tables in the main source
and unix build.  Leave makedefs able to generate the vision tables.
makdefs will be cleaned up in a different commit, once all ports
are clear of dependencies.
This commit is contained in:
Dean Luick
2020-12-28 19:16:34 -06:00
parent b735122c2c
commit a4e7646f4c
5 changed files with 13 additions and 744 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
include/config.h
View File

@@ -457,24 +457,15 @@ typedef unsigned char uchar;
/* #define STRNCMPI */ /* compiler/library has the strncmpi function */
/*
* There are various choices for the NetHack vision system. There is a
* choice of two algorithms with the same behavior. Defining VISION_TABLES
* creates huge (60K) tables at compile time, drastically increasing data
* size, but runs slightly faster than the alternate algorithm. (MSDOS in
* particular cannot tolerate the increase in data size; other systems can
* flip a coin weighted to local conditions.)
* Vision choices.
*
* If VISION_TABLES is not defined, things will be faster if you can use
* MACRO_CPATH. Some cpps, however, cannot deal with the size of the
* functions that have been macroized.
* Things will be faster if you can use MACRO_CPATH. Some cpps, however,
* cannot deal with the size of the functions that have been macroized.
*/
/* #define VISION_TABLES */ /* use vision tables generated at compile time */
#ifndef VISION_TABLES
#ifndef NO_MACRO_CPATH
#define MACRO_CPATH /* use clear_path macros instead of functions */
#endif
#endif
#if !defined(MAC)
#if !defined(NOCLIPPING)

6
include/extern.h
View File

@@ -2852,12 +2852,6 @@ E int FDECL(assign_videoshades, (char *));
E int FDECL(assign_videocolors, (char *));
#endif
/* ### vis_tab.c ### */
#ifdef VISION_TABLES
E void NDECL(vis_tab_init);
#endif
/* ### vision.c ### */
E void NDECL(vision_init);

715
src/vision.c
View File

@@ -127,15 +127,8 @@ vision_init()
g.vision_full_recalc = 0;
(void) memset((genericptr_t) could_see, 0, sizeof(could_see));
/* Initialize the vision algorithm (currently C or D). */
/* Initialize the vision algorithm (currently C). */
view_init();
#ifdef VISION_TABLES
/* Note: this initializer doesn't do anything except guarantee that
* we're linked properly.
*/
vis_tab_init();
#endif
}
/*
@@ -1083,11 +1076,9 @@ int row, col;
/*==========================================================================*/
/*==========================================================================*/
/* Use either algorithm C or D. See the config.h for more details.
* =========*/
/*
* Variables local to both Algorithms C and D.
* Variables local to Algorithm C.
*/
static int start_row;
static int start_col;
@@ -1100,7 +1091,7 @@ static void FDECL((*vis_func), (int, int, genericptr_t));
static genericptr_t varg;
/*
* Both Algorithms C and D use the following macros.
* Algorithm C uses the following macros:
*
* good_row(z) - Return TRUE if the argument is a legal row.
* set_cs(rowp,col) - Set the local could see array.
@@ -1583,704 +1574,6 @@ cleardone:
return (boolean) result;
}
#ifdef VISION_TABLES
/*==========================================================================*\
GENERAL LINE OF SIGHT
Algorithm D
\*==========================================================================*/
/*
* Indicate caller for the shadow routines.
*/
#define FROM_RIGHT 0
#define FROM_LEFT 1
/*
* Include the table definitions.
*/
#include "vis_tab.h"
/* 3D table pointers. */
static close2d *close_dy[CLOSE_MAX_BC_DY];
static far2d *far_dy[FAR_MAX_BC_DY];
static void FDECL(right_side, (int, int, int, int, int,
int, int, const xchar *));
static void FDECL(left_side, (int, int, int, int, int, int, int,
const xchar *));
static int FDECL(close_shadow, (int, int, int, int));
static int FDECL(far_shadow, (int, int, int, int));
/*
* Initialize algorithm D's table pointers. If we don't have these,
* then we do 3D table lookups. Verrrry slow.
*/
static void
view_init()
{
int i;
for (i = 0; i < CLOSE_MAX_BC_DY; i++)
close_dy[i] = &close_table[i];
for (i = 0; i < FAR_MAX_BC_DY; i++)
far_dy[i] = &far_table[i];
}
/*
* If the far table has an entry of OFF_TABLE, then the far block prevents
* us from seeing the location just above/below it. I.e. the first visible
* location is one *before* the block.
*/
#define OFF_TABLE 0xff
static int
close_shadow(side, this_row, block_row, block_col)
int side, this_row, block_row, block_col;
{
register int sdy, sdx, pdy, offset;
/*
* If on the same column (block_row = -1), then we can see it.
*/
if (block_row < 0)
return block_col;
/* Take explicit absolute values. Adjust. */
if ((sdy = (start_row - block_row)) < 0)
sdy = -sdy;
--sdy; /* src dy */
if ((sdx = (start_col - block_col)) < 0)
sdx = -sdx; /* src dx */
if ((pdy = (block_row - this_row)) < 0)
pdy = -pdy; /* point dy */
if (sdy < 0 || sdy >= CLOSE_MAX_SB_DY || sdx >= CLOSE_MAX_SB_DX
|| pdy >= CLOSE_MAX_BC_DY) {
impossible("close_shadow: bad value");
return block_col;
}
offset = close_dy[sdy]->close[sdx][pdy];
if (side == FROM_RIGHT)
return block_col + offset;
return block_col - offset;
}
static int
far_shadow(side, this_row, block_row, block_col)
int side, this_row, block_row, block_col;
{
register int sdy, sdx, pdy, offset;
/*
* Take care of a bug that shows up only on the borders.
*
* If the block is beyond the border, then the row is negative. Return
* the block's column number (should be 0 or COLNO-1).
*
* Could easily have the column be -1, but then wouldn't know if it was
* the left or right border.
*/
if (block_row < 0)
return block_col;
/* Take explicit absolute values. Adjust. */
if ((sdy = (start_row - block_row)) < 0)
sdy = -sdy; /* src dy */
if ((sdx = (start_col - block_col)) < 0)
sdx = -sdx;
--sdx; /* src dx */
if ((pdy = (block_row - this_row)) < 0)
pdy = -pdy;
--pdy; /* point dy */
if (sdy >= FAR_MAX_SB_DY || sdx < 0 || sdx >= FAR_MAX_SB_DX || pdy < 0
|| pdy >= FAR_MAX_BC_DY) {
impossible("far_shadow: bad value");
return block_col;
}
if ((offset = far_dy[sdy]->far_q[sdx][pdy]) == OFF_TABLE)
offset = -1;
if (side == FROM_RIGHT)
return block_col + offset;
return block_col - offset;
}
/*
* right_side()
*
* Figure out what could be seen on the right side of the source.
*/
static void
right_side(row, cb_row, cb_col, fb_row, fb_col, left, right_mark, limits)
int row; /* current row */
int cb_row, cb_col; /* close block row and col */
int fb_row, fb_col; /* far block row and col */
int left; /* left mark of the previous row */
int right_mark; /* right mark of previous row */
xchar *limits; /* points at range limit for current row, or NULL */
{
register int i;
register char *rowp = NULL;
int hit_stone = 0;
int left_shadow, right_shadow, loc_right;
int lblock_col; /* local block column (current row) */
int nrow, deeper;
char *row_min = NULL; /* left most */
char *row_max = NULL; /* right most */
int lim_max; /* right most limit of circle */
nrow = row + step;
deeper = good_row(nrow) && (!limits || (*limits >= *(limits + 1)));
if (!vis_func) {
rowp = cs_rows[row];
row_min = &cs_left[row];
row_max = &cs_right[row];
}
if (limits) {
lim_max = start_col + *limits;
if (lim_max > COLNO - 1)
lim_max = COLNO - 1;
if (right_mark > lim_max)
right_mark = lim_max;
limits++; /* prepare for next row */
} else
lim_max = COLNO - 1;
/*
* Get the left shadow from the close block. This value could be
* illegal.
*/
left_shadow = close_shadow(FROM_RIGHT, row, cb_row, cb_col);
/*
* Mark all stone walls as seen before the left shadow. All this work
* for a special case.
*
* NOTE. With the addition of this code in here, it is now *required*
* for the algorithm to work correctly. If this is commented out,
* change the above assignment so that left and not left_shadow is the
* variable that gets the shadow.
*/
while (left <= right_mark) {
loc_right = right_ptrs[row][left];
if (loc_right > lim_max)
loc_right = lim_max;
if (viz_clear_rows[row][left]) {
if (loc_right >= left_shadow) {
left = left_shadow; /* opening ends beyond shadow */
break;
}
left = loc_right;
loc_right = right_ptrs[row][left];
if (loc_right > lim_max)
loc_right = lim_max;
if (left == loc_right)
return; /* boundary */
/* Shadow covers opening, beyond right mark */
if (left == right_mark && left_shadow > right_mark)
return;
}
if (loc_right > right_mark) /* can't see stone beyond the mark */
loc_right = right_mark;
if (vis_func) {
for (i = left; i <= loc_right; i++)
(*vis_func)(i, row, varg);
} else {
for (i = left; i <= loc_right; i++)
set_cs(rowp, i);
set_min(left);
set_max(loc_right);
}
if (loc_right == right_mark)
return; /* all stone */
if (loc_right >= left_shadow)
hit_stone = 1;
left = loc_right + 1;
}
/*
* At this point we are at the first visible clear spot on or beyond
* the left shadow, unless the left shadow is an illegal value. If we
* have "hit stone" then we have a stone wall just to our left.
*/
/*
* Get the right shadow. Make sure that it is a legal value.
*/
if ((right_shadow = far_shadow(FROM_RIGHT, row, fb_row, fb_col)) >= COLNO)
right_shadow = COLNO - 1;
/*
* Make vertical walls work the way we want them. In this case, we
* note when the close block blocks the column just above/beneath
* it (right_shadow < fb_col [actually right_shadow == fb_col-1]). If
* the location is filled, then we want to see it, so we put the
* right shadow back (same as fb_col).
*/
if (right_shadow < fb_col && !viz_clear_rows[row][fb_col])
right_shadow = fb_col;
if (right_shadow > lim_max)
right_shadow = lim_max;
/*
* Main loop. Within the range of sight of the previous row, mark all
* stone walls as seen. Follow open areas recursively.
*/
while (left <= right_mark) {
/* Get the far right of the opening or wall */
loc_right = right_ptrs[row][left];
if (loc_right > lim_max)
loc_right = lim_max;
if (!viz_clear_rows[row][left]) {
hit_stone = 1; /* use stone on this row as close block */
/*
* We can see all of the wall until the next open spot or the
* start of the shadow caused by the far block (right).
*
* Can't see stone beyond the right mark.
*/
if (loc_right > right_mark)
loc_right = right_mark;
if (vis_func) {
for (i = left; i <= loc_right; i++)
(*vis_func)(i, row, varg);
} else {
for (i = left; i <= loc_right; i++)
set_cs(rowp, i);
set_min(left);
set_max(loc_right);
}
if (loc_right == right_mark)
return; /* hit the end */
left = loc_right + 1;
loc_right = right_ptrs[row][left];
if (loc_right > lim_max)
loc_right = lim_max;
/* fall through... we know at least one position is visible */
}
/*
* We are in an opening.
*
* If this is the first open spot since the could see area (this is
* true if we have hit stone), get the shadow generated by the wall
* just to our left.
*/
if (hit_stone) {
lblock_col = left - 1; /* local block column */
left = close_shadow(FROM_RIGHT, row, row, lblock_col);
if (left > lim_max)
break; /* off the end */
}
/*
* Check if the shadow covers the opening. If it does, then
* move to end of the opening. A shadow generated on from a
* wall on this row does *not* cover the wall on the right
* of the opening.
*/
if (left >= loc_right) {
if (loc_right == lim_max) { /* boundary */
if (left == lim_max) {
if (vis_func)
(*vis_func)(lim_max, row, varg);
else {
set_cs(rowp, lim_max); /* last pos */
set_max(lim_max);
}
}
return; /* done */
}
left = loc_right;
continue;
}
/*
* If the far wall of the opening (loc_right) is closer than the
* shadow limit imposed by the far block (right) then use the far
* wall as our new far block when we recurse.
*
* If the limits are the same, and the far block really exists
* (fb_row >= 0) then do the same as above.
*
* Normally, the check would be for the far wall being closer OR EQUAL
* to the shadow limit. However, there is a bug that arises from the
* fact that the clear area pointers end in an open space (if it
* exists) on a boundary. This then makes a far block exist where it
* shouldn't --- on a boundary. To get around that, I had to
* introduce the concept of a non-existent far block (when the
* row < 0). Next I have to check for it. Here is where that check
* exists.
*/
if ((loc_right < right_shadow)
|| (fb_row >= 0 && loc_right == right_shadow)) {
if (vis_func) {
for (i = left; i <= loc_right; i++)
(*vis_func)(i, row, varg);
} else {
for (i = left; i <= loc_right; i++)
set_cs(rowp, i);
set_min(left);
set_max(loc_right);
}
if (deeper) {
if (hit_stone)
right_side(nrow, row, lblock_col, row, loc_right, left,
loc_right, limits);
else
right_side(nrow, cb_row, cb_col, row, loc_right, left,
loc_right, limits);
}
/*
* The following line, setting hit_stone, is needed for those
* walls that are only 1 wide. If hit stone is *not* set and
* the stone is only one wide, then the close block is the old
* one instead one on the current row. A way around having to
* set it here is to make left = loc_right (not loc_right+1) and
* let the outer loop take care of it. However, if we do that
* then we then have to check for boundary conditions here as
* well.
*/
hit_stone = 1;
left = loc_right + 1;
/*
* The opening extends beyond the right mark. This means that
* the next far block is the current far block.
*/
} else {
if (vis_func) {
for (i = left; i <= right_shadow; i++)
(*vis_func)(i, row, varg);
} else {
for (i = left; i <= right_shadow; i++)
set_cs(rowp, i);
set_min(left);
set_max(right_shadow);
}
if (deeper) {
if (hit_stone)
right_side(nrow, row, lblock_col, fb_row, fb_col, left,
right_shadow, limits);
else
right_side(nrow, cb_row, cb_col, fb_row, fb_col, left,
right_shadow, limits);
}
return; /* we're outta here */
}
}
}
/*
* left_side()
*
* This routine is the mirror image of right_side(). Please see right_side()
* for blow by blow comments.
*/
static void
left_side(row, cb_row, cb_col, fb_row, fb_col, left_mark, right, limits)
int row; /* the current row */
int cb_row, cb_col; /* close block row and col */
int fb_row, fb_col; /* far block row and col */
int left_mark; /* left mark of previous row */
int right; /* right mark of the previous row */
const xchar *limits;
{
register int i;
register char *rowp = NULL;
int hit_stone = 0;
int left_shadow, right_shadow, loc_left;
int lblock_col; /* local block column (current row) */
int nrow, deeper;
char *row_min = NULL; /* left most */
char *row_max = NULL; /* right most */
int lim_min;
nrow = row + step;
deeper = good_row(nrow) && (!limits || (*limits >= *(limits + 1)));
if (!vis_func) {
rowp = cs_rows[row];
row_min = &cs_left[row];
row_max = &cs_right[row];
}
if (limits) {
lim_min = start_col - *limits;
if (lim_min < 0)
lim_min = 0;
if (left_mark < lim_min)
left_mark = lim_min;
limits++; /* prepare for next row */
} else
lim_min = 0;
/* This value could be illegal. */
right_shadow = close_shadow(FROM_LEFT, row, cb_row, cb_col);
while (right >= left_mark) {
loc_left = left_ptrs[row][right];
if (loc_left < lim_min)
loc_left = lim_min;
if (viz_clear_rows[row][right]) {
if (loc_left <= right_shadow) {
right = right_shadow; /* opening ends beyond shadow */
break;
}
right = loc_left;
loc_left = left_ptrs[row][right];
if (loc_left < lim_min)
loc_left = lim_min;
if (right == loc_left)
return; /* boundary */
}
if (loc_left < left_mark) /* can't see beyond the left mark */
loc_left = left_mark;
if (vis_func) {
for (i = loc_left; i <= right; i++)
(*vis_func)(i, row, varg);
} else {
for (i = loc_left; i <= right; i++)
set_cs(rowp, i);
set_min(loc_left);
set_max(right);
}
if (loc_left == left_mark)
return; /* all stone */
if (loc_left <= right_shadow)
hit_stone = 1;
right = loc_left - 1;
}
/* At first visible clear spot on or beyond the right shadow. */
if ((left_shadow = far_shadow(FROM_LEFT, row, fb_row, fb_col)) < 0)
left_shadow = 0;
/* Do vertical walls as we want. */
if (left_shadow > fb_col && !viz_clear_rows[row][fb_col])
left_shadow = fb_col;
if (left_shadow < lim_min)
left_shadow = lim_min;
while (right >= left_mark) {
loc_left = left_ptrs[row][right];
if (!viz_clear_rows[row][right]) {
hit_stone = 1; /* use stone on this row as close block */
/* We can only see walls until the left mark */
if (loc_left < left_mark)
loc_left = left_mark;
if (vis_func) {
for (i = loc_left; i <= right; i++)
(*vis_func)(i, row, varg);
} else {
for (i = loc_left; i <= right; i++)
set_cs(rowp, i);
set_min(loc_left);
set_max(right);
}
if (loc_left == left_mark)
return; /* hit end */
right = loc_left - 1;
loc_left = left_ptrs[row][right];
if (loc_left < lim_min)
loc_left = lim_min;
/* fall through...*/
}
/* We are in an opening. */
if (hit_stone) {
lblock_col = right + 1; /* stone block (local) */
right = close_shadow(FROM_LEFT, row, row, lblock_col);
if (right < lim_min)
return; /* off the end */
}
/* Check if the shadow covers the opening. */
if (right <= loc_left) {
/* Make a boundary condition work. */
if (loc_left == lim_min) { /* at boundary */
if (right == lim_min) {
if (vis_func)
(*vis_func)(lim_min, row, varg);
else {
set_cs(rowp, lim_min); /* caught the last pos */
set_min(lim_min);
}
}
return; /* and break out the loop */
}
right = loc_left;
continue;
}
/* If the far wall of the opening is closer than the shadow limit. */
if ((loc_left > left_shadow)
|| (fb_row >= 0 && loc_left == left_shadow)) {
if (vis_func) {
for (i = loc_left; i <= right; i++)
(*vis_func)(i, row, varg);
} else {
for (i = loc_left; i <= right; i++)
set_cs(rowp, i);
set_min(loc_left);
set_max(right);
}
if (deeper) {
if (hit_stone)
left_side(nrow, row, lblock_col, row, loc_left, loc_left,
right, limits);
else
left_side(nrow, cb_row, cb_col, row, loc_left, loc_left,
right, limits);
}
hit_stone = 1; /* needed for walls of width 1 */
right = loc_left - 1;
/* The opening extends beyond the left mark. */
} else {
if (vis_func) {
for (i = left_shadow; i <= right; i++)
(*vis_func)(i, row, varg);
} else {
for (i = left_shadow; i <= right; i++)
set_cs(rowp, i);
set_min(left_shadow);
set_max(right);
}
if (deeper) {
if (hit_stone)
left_side(nrow, row, lblock_col, fb_row, fb_col,
left_shadow, right, limits);
else
left_side(nrow, cb_row, cb_col, fb_row, fb_col,
left_shadow, right, limits);
}
return; /* we're outta here */
}
}
}
/*
* view_from
*
* Calculate a view from the given location. Initialize and fill a
* ROWNOxCOLNO array (could_see) with all the locations that could be
* seen from the source location. Initialize and fill the left most
* and right most boundaries of what could be seen.
*/
static void
view_from(srow, scol, loc_cs_rows, left_most, right_most, range, func, arg)
int srow, scol; /* source row and column */
xchar **loc_cs_rows; /* could_see array (row pointers) */
xchar *left_most, *right_most; /* limits of what could be seen */
int range; /* 0 if unlimited */
void FDECL((*func), (int, int, genericptr_t));
genericptr_t arg;
{
register int i;
char *rowp;
int nrow, left, right, left_row, right_row;
char *limits;
/* Set globals for near_shadow(), far_shadow(), etc. to use. */
start_col = scol;
start_row = srow;
cs_rows = loc_cs_rows;
cs_left = left_most;
cs_right = right_most;
vis_func = func;
varg = arg;
/* Find the left and right limits of sight on the starting row. */
if (viz_clear_rows[srow][scol]) {
left = left_ptrs[srow][scol];
right = right_ptrs[srow][scol];
} else {
left = (!scol) ? 0 : (viz_clear_rows[srow][scol - 1]
? left_ptrs[srow][scol - 1]
: scol - 1);
right = (scol == COLNO - 1) ? COLNO - 1
: (viz_clear_rows[srow][scol + 1]
? right_ptrs[srow][scol + 1]
: scol + 1);
}
if (range) {
if (range > MAX_RADIUS || range < 1)
panic("view_from called with range %d", range);
limits = circle_ptr(range) + 1; /* start at next row */
if (left < scol - range)
left = scol - range;
if (right > scol + range)
right = scol + range;
} else
limits = (char *) 0;
if (func) {
for (i = left; i <= right; i++)
(*func)(i, srow, arg);
} else {
/* Row optimization */
rowp = cs_rows[srow];
/* We know that we can see our row. */
for (i = left; i <= right; i++)
set_cs(rowp, i);
cs_left[srow] = left;
cs_right[srow] = right;
}
/* The far block has a row number of -1 if we are on an edge. */
right_row = (right == COLNO - 1) ? -1 : srow;
left_row = (!left) ? -1 : srow;
/*
* Check what could be seen in quadrants.
*/
if ((nrow = srow + 1) < ROWNO) {
step = 1; /* move down */
if (scol < COLNO - 1)
right_side(nrow, -1, scol, right_row, right, scol, right, limits);
if (scol)
left_side(nrow, -1, scol, left_row, left, left, scol, limits);
}
if ((nrow = srow - 1) >= 0) {
step = -1; /* move up */
if (scol < COLNO - 1)
right_side(nrow, -1, scol, right_row, right, scol, right, limits);
if (scol)
left_side(nrow, -1, scol, left_row, left, left, scol, limits);
}
}
#else /*===== End of algorithm D =====*/
/*==========================================================================*\
GENERAL LINE OF SIGHT
Algorithm C
@@ -2723,7 +2016,7 @@ genericptr_t arg;
}
}
#endif /*===== End of algorithm C =====*/
/*===== End of algorithm C =====*/
/*
* AREA OF EFFECT "ENGINE"

17
sys/unix/Makefile.src
View File

@@ -534,7 +534,7 @@ SYSCSRC = ../sys/share/pcmain.c ../sys/share/pcsys.c \
SYSCXXSRC = ../sys/share/cppregex.cpp
# generated source files (tile.c is handled separately via WINxxxSRC)
GENCSRC = vis_tab.c #tile.c
GENCSRC = #tile.c
# all windowing-system-dependent .c (for dependencies and such)
WINCSRC = $(WINTTYSRC) $(WINCURSESSRC) $(WINX11SRC) $(WINGNOMESRC) $(WINGEMSRC) $(WINSHIMSRC)
@@ -554,7 +554,7 @@ VERSOURCES = $(HACKCSRC) $(SYSSRC) $(WINSRC) $(CHAINSRC) $(GENCSRC)
CSOURCES = $(HACKCSRC) $(SYSCSRC) $(WINCSRC) $(CHAINSRC) $(GENCSRC)
# all .h files except date.h, onames.h, pm.h, and vis_tab.h which would
# all .h files except date.h, onames.h, and pm.h which would
# cause dependency loops if run through "make depend"
# and dgn_file.h, special level & dungeon files.
#
@@ -569,7 +569,7 @@ HACKINCL = align.h artifact.h artilist.h attrib.h botl.h \
tradstdc.h trap.h unixconf.h vision.h vmsconf.h \
wintty.h wincurs.h winX.h winprocs.h wintype.h you.h youprop.h
HSOURCES = $(HACKINCL) date.h onames.h pm.h vis_tab.h dgn_file.h
HSOURCES = $(HACKINCL) date.h onames.h pm.h dgn_file.h
# the following .o's _must_ be made before any others (for makedefs)
FIRSTOBJ = monst.o objects.o
@@ -610,7 +610,7 @@ HOBJ = $(TARGETPFX)allmain.o $(TARGETPFX)alloc.o \
$(TARGETPFX)steed.o $(TARGETPFX)teleport.o $(TARGETPFX)timeout.o \
$(TARGETPFX)topten.o $(TARGETPFX)track.o $(TARGETPFX)trap.o \
$(TARGETPFX)u_init.o $(TARGETPFX)uhitm.o $(TARGETPFX)vault.o \
$(TARGETPFX)vision.o $(TARGETPFX)vis_tab.o $(TARGETPFX)weapon.o \
$(TARGETPFX)vision.o $(TARGETPFX)weapon.o \
$(TARGETPFX)were.o $(TARGETPFX)wield.o $(TARGETPFX)windows.o \
$(TARGETPFX)wizard.o $(TARGETPFX)worm.o $(TARGETPFX)worn.o \
$(TARGETPFX)write.o $(TARGETPFX)zap.o \
@@ -753,10 +753,6 @@ $(MAKEDEFS): $(FIRSTOBJ) \
@( cd ../util ; $(MAKE) ../include/onames.h )
../include/pm.h: $(MAKEDEFS) ../include/onames.h
@( cd ../util ; $(MAKE) ../include/pm.h )
../include/vis_tab.h: $(MAKEDEFS) ../include/pm.h
@( cd ../util ; $(MAKE) ../include/vis_tab.h )
# makedefs -z makes both vis_tab.h and vis_tab.c, but writes the .h first
vis_tab.c: ../include/vis_tab.h
# Created at build time for configurations which support tiles,
# but not by makedefs so not connected to the others.
tile.c: ../win/share/tilemap.c $(HACK_H)
@@ -804,7 +800,7 @@ spotless: clean
-rm -f a.out core $(GAMEBIN) Sys*
-rm -f ../lib/lua/liblua.a ../include/nhlua.h
-rm -f ../include/date.h ../include/onames.h ../include/pm.h
-rm -f ../include/vis_tab.h vis_tab.c tile.c *.moc
-rm -f tile.c *.moc
-rm -f ../win/gnome/gn_rip.h
package:
@@ -1065,7 +1061,6 @@ $(TARGETPFX)wc_chainout.o: ../win/chain/wc_chainout.c $(HACK_H)
$(TARGET_CC) $(TARGET_CFLAGS) -c -o $@ ../win/chain/wc_chainout.c
$(TARGETPFX)wc_trace.o: ../win/chain/wc_trace.c $(HACK_H) ../include/func_tab.h
$(TARGET_CC) $(TARGET_CFLAGS) -c -o $@ ../win/chain/wc_trace.c
$(TARGETPFX)vis_tab.o: vis_tab.c $(CONFIG_H) ../include/vis_tab.h
$(TARGETPFX)allmain.o: allmain.c $(HACK_H)
$(TARGETPFX)alloc.o: alloc.c $(CONFIG_H)
$(TARGETPFX)apply.o: apply.c $(HACK_H)
@@ -1187,7 +1182,7 @@ $(TARGETPFX)u_init.o: u_init.c $(HACK_H)
$(TARGETPFX)uhitm.o: uhitm.c $(HACK_H)
$(TARGETPFX)vault.o: vault.c $(HACK_H)
$(TARGETPFX)version.o: version.c $(HACK_H) ../include/dlb.h ../include/date.h
$(TARGETPFX)vision.o: vision.c $(HACK_H) ../include/vis_tab.h
$(TARGETPFX)vision.o: vision.c $(HACK_H)
$(TARGETPFX)weapon.o: weapon.c $(HACK_H)
$(TARGETPFX)were.o: were.c $(HACK_H)
$(TARGETPFX)wield.o: wield.c $(HACK_H)

4
sys/unix/Makefile.utl
View File

@@ -221,10 +221,6 @@ mdgreph: mdgrep.pl
./makedefs -o
../include/pm.h: makedefs
./makedefs -p
../include/vis_tab.h: makedefs
./makedefs -z
# makedefs -z makes both vis_tab.h and vis_tab.c, but writes the .h first
../src/vis_tab.c: ../include/vis_tab.h
lintdefs:
@lint -axbh -I../include -DLINT $(MAKESRC) $(CMONOBJ) | sed '/_flsbuf/d'