/*
* relocate:
* Make the monster's new location be the specified one, updating
* all the relevant state.
*/
void
relocate(THING *th, const coord *new_loc)
{
struct room *oroom;
if (!ce(*new_loc, th->t_pos))
{
mvaddch2(th->t_pos.y, th->t_pos.x, th->t_oldch);
th->t_room = roomin(new_loc);
set_oldch(th, new_loc);
oroom = th->t_room;
moat(th->t_pos.y, th->t_pos.x) = NULL;
if (oroom != th->t_room)
th->t_dest = find_dest(th);
th->t_pos = *new_loc;
moat(new_loc->y, new_loc->x) = th;
}
move(new_loc->y, new_loc->x);
if (see_monst(th))
addch2(th->t_disguise);
else if (on(player, SEEMONST))
{
standout();
addch2(th->t_type);
standend2();
}
}
/*
* runto:
* Set a monster running after the hero.
*/
void
runto(const coord *runner)
{
THING *tp;
/*
* If we couldn't find him, something is funny
*/
if ((tp = moat(runner->y, runner->x)) == NULL)
{
#ifdef MASTER
msg("couldn't find monster in runto at (%d,%d)", runner->y, runner->x);
#endif
return;
}
/*
* Start the beastie running
*/
tp->t_flags |= ISRUN;
tp->t_flags &= ~ISHELD;
tp->t_dest = find_dest(tp);
}
/*
* do_chase:
* Make one thing chase another.
*/
int
do_chase(THING *th)
{
coord *cp;
struct room *rer, *ree; /* room of chaser, room of chasee */
int mindist = 32767, curdist;
int stoprun = FALSE; /* TRUE means we are there */
int door;
THING *obj;
coord this; /* Temporary destination for chaser */
rer = th->t_room; /* Find room of chaser */
if (on(*th, ISGREED) && rer->r_goldval == 0)
th->t_dest = &hero; /* If gold has been taken, run after hero */
if (th->t_dest == &hero) /* Find room of chasee */
ree = proom;
else
ree = roomin(th->t_dest);
/*
* We don't count doors as inside rooms for this routine
*/
door = (chat(th->t_pos.y, th->t_pos.x) == DOOR);
/*
* If the object of our desire is in a different room,
* and we are not in a corridor, run to the door nearest to
* our goal.
*/
over:
if (rer != ree)
{
for (cp = rer->r_exit; cp < &rer->r_exit[rer->r_nexits]; cp++)
{
curdist = dist_cp(th->t_dest, cp);
if (curdist < mindist)
{
this = *cp;
mindist = curdist;
}
}
if (door)
{
rer = &passages[flat(th->t_pos.y, th->t_pos.x) & F_PNUM];
door = FALSE;
goto over;
}
}
else
{
this = *th->t_dest;
/*
* For dragons check and see if (a) the hero is on a straight
* line from it, and (b) that it is within shooting distance,
* but outside of striking range.
*/
if (th->t_type == 'D' && (th->t_pos.y == hero.y || th->t_pos.x == hero.x
|| abs(th->t_pos.y - hero.y) == abs(th->t_pos.x - hero.x))
&& dist_cp(&th->t_pos, &hero) <= BOLT_LENGTH * BOLT_LENGTH
&& !on(*th, ISCANC) && rnd(DRAGONSHOT) == 0)
{
delta.y = sign(hero.y - th->t_pos.y);
delta.x = sign(hero.x - th->t_pos.x);
if (has_hit)
endmsg();
fire_bolt(&th->t_pos, &delta, "flame");
running = FALSE;
count = 0;
quiet = 0;
if (to_death && !on(*th, ISTARGET))
{
to_death = FALSE;
kamikaze = FALSE;
}
return(0);
}
}
/*
* This now contains what we want to run to this time
* so we run to it. If we hit it we either want to fight it
* or stop running
*/
if (!chase(th, &this))
{
if (ce(this, hero))
{
return( attack(th) );
}
else if (ce(this, *th->t_dest))
{
for (obj = lvl_obj; obj != NULL; obj = next(obj))
if (th->t_dest == &obj->o_pos)
{
detach(lvl_obj, obj);
attach(th->t_pack, obj);
chat(obj->o_pos.y, obj->o_pos.x) =
(th->t_room->r_flags & ISGONE) ? PASSAGE : FLOOR;
th->t_dest = find_dest(th);
break;
}
if (th->t_type != 'F')
stoprun = TRUE;
}
}
else
{
if (th->t_type == 'F')
return(0);
}
relocate(th, &ch_ret);
/*
* And stop running if need be
*/
if (stoprun && ce(th->t_pos, *(th->t_dest)))
th->t_flags &= ~ISRUN;
return(0);
}
void read_log(void)
{
struct stat statdata;
uschar buffer[log_buffer_len];
/* If log is not yet open, skip all of this. */
if (LOG != NULL)
{
fseek(LOG, log_position, SEEK_SET);
while (Ufgets(buffer, log_buffer_len, LOG) != NULL)
{
uschar *id;
uschar *p = buffer;
void *reset_point;
int length = Ustrlen(buffer);
int i;
/* Skip totally blank lines (paranoia: there shouldn't be any) */
while (*p == ' ' || *p == '\t') p++;
if (*p == '\n') continue;
/* We should now have a complete log entry in the buffer; check
it for various regular expression matches and take appropriate
action. Get the current store point so we can reset to it. */
reset_point = store_get(0);
/* First, update any stripchart data values, noting that the zeroth
stripchart is the queue length, which is handled elsewhere, and the
1st may the a size monitor. */
for (i = stripchart_varstart; i < stripchart_number; i++)
{
if (pcre_exec(stripchart_regex[i], NULL, CS buffer, length, 0, PCRE_EOPT,
NULL, 0) >= 0)
stripchart_total[i]++;
}
/* Munge the log entry and display shortened form on one line.
We omit the date and show only the time. Remove any time zone offset.
Take note of the presence of [pid]. */
if (pcre_exec(yyyymmdd_regex,NULL,CS buffer,length,0,PCRE_EOPT,NULL,0) >= 0)
{
int pidlength = 0;
if ((buffer[20] == '+' || buffer[20] == '-') &&
isdigit(buffer[21]) && buffer[25] == ' ')
memmove(buffer + 20, buffer + 26, Ustrlen(buffer + 26) + 1);
if (buffer[20] == '[')
{
while (Ustrchr("[]0123456789", buffer[20+pidlength++]) != NULL);
}
id = string_copyn(buffer + 20 + pidlength, MESSAGE_ID_LENGTH);
show_log("%s", buffer+11);
}
else
{
id = US"";
show_log("%s", buffer);
}
/* Deal with frozen and unfrozen messages */
if (strstric(buffer, US"frozen", FALSE) != NULL)
{
queue_item *qq = find_queue(id, queue_noop, 0);
if (qq != NULL)
{
if (strstric(buffer, US"unfrozen", FALSE) != NULL)
qq->frozen = FALSE;
else qq->frozen = TRUE;
}
}
/* Notice defer messages, and add the destination if it
isn't already on the list for this message, with a pointer
to the parent if we can. */
if ((p = Ustrstr(buffer, "==")) != NULL)
{
queue_item *qq = find_queue(id, queue_noop, 0);
if (qq != NULL)
{
dest_item *d;
uschar *q, *r;
p += 2;
while (isspace(*p)) p++;
q = p;
while (*p != 0 && !isspace(*p))
{
if (*p++ != '\"') continue;
while (*p != 0)
{
if (*p == '\\') p += 2;
else if (*p++ == '\"') break;
}
}
*p++ = 0;
if ((r = strstric(q, qualify_domain, FALSE)) != NULL &&
*(--r) == '@') *r = 0;
/* If we already have this destination, as tested case-insensitively,
do not add it to the destinations list. */
d = find_dest(qq, q, dest_add, TRUE);
if (d->parent == NULL)
{
while (isspace(*p)) p++;
if (*p == '<')
{
dest_item *dd;
q = ++p;
while (*p != 0 && *p != '>') p++;
*p = 0;
if ((p = strstric(q, qualify_domain, FALSE)) != NULL &&
*(--p) == '@') *p = 0;
dd = find_dest(qq, q, dest_noop, FALSE);
if (dd != NULL && dd != d) d->parent = dd;
}
}
}
}
store_reset(reset_point);
}
}
/* We have to detect when the log file is changed, and switch to the new file.
In practice, for non-datestamped files, this means that some deliveries might
go unrecorded, since they'll be written to the old file, but this usually
happens in the middle of the night, and I don't think the hassle of keeping
track of two log files is worth it.
First we check the datestamped name of the log file if necessary; if it is
different to the file we currently have open, go for the new file. As happens
in Exim itself, we leave in the following inode check, even when datestamping
because it does no harm and will cope should a file actually be renamed for
some reason.
The test for a changed log file is to look up the inode of the file by name and
compare it with the saved inode of the file we currently are processing. This
accords with the usual interpretation of POSIX and other Unix specs that imply
"one file, one inode". However, it appears that on some Digital systems, if an
open file is unlinked, a new file may be created with the same inode while the
old file remains in existence. This can happen if the old log file is renamed,
processed in some way, and then deleted. To work round this, also test for a
link count of zero on the currently open file. */
if (log_datestamping)
{
uschar log_file_wanted[256];
string_format(log_file_wanted, sizeof(log_file_wanted), CS log_file);
if (Ustrcmp(log_file_wanted, log_file_open) != 0)
{
if (LOG != NULL)
{
fclose(LOG);
LOG = NULL;
}
Ustrcpy(log_file_open, log_file_wanted);
}
}
if (LOG == NULL ||
(fstat(fileno(LOG), &statdata) == 0 && statdata.st_nlink == 0) ||
(Ustat(log_file, &statdata) == 0 && log_inode != statdata.st_ino))
{
FILE *TEST;
/* Experiment shows that sometimes you can't immediately open
the new log file - presumably immediately after the old one
is renamed and before the new one exists. Therefore do a
trial open first to be sure. */
if ((TEST = fopen(CS log_file_open, "r")) != NULL)
{
if (LOG != NULL) fclose(LOG);
LOG = TEST;
fstat(fileno(LOG), &statdata);
log_inode = statdata.st_ino;
}
}
/* Save the position we have got to in the log. */
if (LOG != NULL) log_position = ftell(LOG);
}
