/*
* move_flyer:
* Update the position of a player in flight
*/
static void
move_flyer(PLAYER *pp)
{
int x, y;
if (pp->p_undershot) {
fixshots(pp->p_y, pp->p_x, pp->p_over);
pp->p_undershot = FALSE;
}
/* Restore what the flier was flying over */
Maze[pp->p_y][pp->p_x] = pp->p_over;
/* Fly: */
x = pp->p_x + pp->p_flyx;
y = pp->p_y + pp->p_flyy;
/* Bouncing off the edges of the maze: */
if (x < 1) {
x = 1 - x;
pp->p_flyx = -pp->p_flyx;
}
else if (x > WIDTH - 2) {
x = (WIDTH - 2) - (x - (WIDTH - 2));
pp->p_flyx = -pp->p_flyx;
}
if (y < 1) {
y = 1 - y;
pp->p_flyy = -pp->p_flyy;
}
else if (y > HEIGHT - 2) {
y = (HEIGHT - 2) - (y - (HEIGHT - 2));
pp->p_flyy = -pp->p_flyy;
}
/* Make sure we don't land on something we can't: */
again:
switch (Maze[y][x]) {
default:
/*
* Flier is over something other than space, a wall
* or a door. Randomly move (drift) the flier a little bit
* and then try again:
*/
switch (rand_num(4)) {
case 0:
PLUS_DELTA(x, WIDTH - 2);
break;
case 1:
MINUS_DELTA(x, 1);
break;
case 2:
PLUS_DELTA(y, HEIGHT - 2);
break;
case 3:
MINUS_DELTA(y, 1);
break;
}
goto again;
/* Give a little boost when about to land on a wall or door: */
case WALL1:
case WALL2:
case WALL3:
case WALL4:
case WALL5:
case DOOR:
if (pp->p_flying == 0)
pp->p_flying++;
break;
/* Spaces are okay: */
case SPACE:
break;
}
/* Update flier's coordinates: */
pp->p_y = y;
pp->p_x = x;
/* Consume 'flying' time: */
if (pp->p_flying-- == 0) {
/* Land: */
if (pp->p_face != BOOT && pp->p_face != BOOT_PAIR) {
/* Land a player - they stustain a fall: */
checkdam(pp, NULL, NULL,
rand_num(pp->p_damage / conf_fall_frac), FALL);
pp->p_face = rand_dir();
showstat(pp);
} else {
/* Land boots: */
if (Maze[y][x] == BOOT)
pp->p_face = BOOT_PAIR;
Maze[y][x] = SPACE;
}
}
/* Save under the flier: */
pp->p_over = Maze[y][x];
/* Draw in the flier: */
Maze[y][x] = pp->p_face;
showexpl(y, x, pp->p_face);
}
/*
* zap:
* Kill off a player and take them out of the game.
* The 'was_player' flag indicates that the player was not
* a monitor and needs extra cleaning up.
*/
static void
zap(PLAYER *pp, FLAG was_player)
{
int len;
BULLET *bp;
PLAYER *np;
int x, y;
int savefd;
if (was_player) {
/* If they died from a shot, clean up shrapnel */
if (pp->p_undershot)
fixshots(pp->p_y, pp->p_x, pp->p_over);
/* Let the player see their last position: */
drawplayer(pp, FALSE);
/* Remove from game: */
Nplayer--;
}
/* Display the cause of death in the centre of the screen: */
len = strlen(pp->p_death);
x = (WIDTH - len) / 2;
outyx(pp, HEIGHT / 2, x, "%s", pp->p_death);
/* Put some horizontal lines around and below the death message: */
memset(pp->p_death + 1, '-', len - 2);
pp->p_death[0] = '+';
pp->p_death[len - 1] = '+';
outyx(pp, HEIGHT / 2 - 1, x, "%s", pp->p_death);
outyx(pp, HEIGHT / 2 + 1, x, "%s", pp->p_death);
/* Move to bottom left */
cgoto(pp, HEIGHT, 0);
savefd = pp->p_fd;
if (was_player) {
int expl_charge;
int expl_type;
int ammo_exploding;
/* Check all the bullets: */
for (bp = Bullets; bp != NULL; bp = bp->b_next) {
if (bp->b_owner == pp)
/* Zapped players can't own bullets: */
bp->b_owner = NULL;
if (bp->b_x == pp->p_x && bp->b_y == pp->p_y)
/* Bullets over the player are now over air: */
bp->b_over = SPACE;
}
/* Explode a random fraction of the player's ammo: */
ammo_exploding = rand_num(pp->p_ammo);
/* Determine the type and amount of detonation: */
expl_charge = rand_num(ammo_exploding + 1);
if (pp->p_ammo == 0)
/* Ignore the no-ammo case: */
expl_charge = expl_type = 0;
else if (ammo_exploding >= pp->p_ammo - 1) {
/* Maximal explosions always appear as slime: */
expl_charge = pp->p_ammo;
expl_type = SLIME;
} else {
/*
* Figure out the best effective explosion
* type to use, given the amount of charge
*/
int btype, stype;
for (btype = MAXBOMB - 1; btype > 0; btype--)
if (expl_charge >= shot_req[btype])
break;
for (stype = MAXSLIME - 1; stype > 0; stype--)
if (expl_charge >= slime_req[stype])
break;
/* Pick the larger of the bomb or slime: */
if (btype >= 0 && stype >= 0) {
if (shot_req[btype] > slime_req[btype])
btype = -1;
}
if (btype >= 0) {
expl_type = shot_type[btype];
expl_charge = shot_req[btype];
} else
expl_type = SLIME;
}
if (expl_charge > 0) {
char buf[BUFSIZ];
/* Detonate: */
(void) add_shot(expl_type, pp->p_y, pp->p_x,
pp->p_face, expl_charge, NULL,
TRUE, SPACE);
/* Explain what the explosion is about. */
snprintf(buf, sizeof buf, "%s detonated.",
pp->p_ident->i_name);
message(ALL_PLAYERS, buf);
while (pp->p_nboots-- > 0) {
/* Throw one of the boots away: */
for (np = Boot; np < &Boot[NBOOTS]; np++)
if (np->p_flying < 0)
break;
#ifdef DIAGNOSTIC
if (np >= &Boot[NBOOTS])
err(1, "Too many boots");
#endif
/* Start the boots from where the player is */
np->p_undershot = FALSE;
np->p_x = pp->p_x;
np->p_y = pp->p_y;
/* Throw for up to 20 steps */
np->p_flying = rand_num(20);
np->p_flyx = 2 * rand_num(6) - 5;
np->p_flyy = 2 * rand_num(6) - 5;
np->p_over = SPACE;
np->p_face = BOOT;
showexpl(np->p_y, np->p_x, BOOT);
}
}
/* No explosion. Leave the player's boots behind. */
else if (pp->p_nboots > 0) {
if (pp->p_nboots == 2)
Maze[pp->p_y][pp->p_x] = BOOT_PAIR;
else
Maze[pp->p_y][pp->p_x] = BOOT;
if (pp->p_undershot)
fixshots(pp->p_y, pp->p_x,
Maze[pp->p_y][pp->p_x]);
}
/* Any unexploded ammo builds up in the volcano: */
volcano += pp->p_ammo - expl_charge;
/* Volcano eruption: */
if (conf_volcano && rand_num(100) < volcano /
conf_volcano_max) {
/* Erupt near the middle of the map */
do {
x = rand_num(WIDTH / 2) + WIDTH / 4;
y = rand_num(HEIGHT / 2) + HEIGHT / 4;
} while (Maze[y][x] != SPACE);
/* Convert volcano charge into lava: */
(void) add_shot(LAVA, y, x, LEFTS, volcano,
NULL, TRUE, SPACE);
volcano = 0;
/* Tell eveyone what's happening */
message(ALL_PLAYERS, "Volcano eruption.");
}
/* Drone: */
if (conf_drone && rand_num(100) < 2) {
/* Find a starting place near the middle of the map: */
do {
x = rand_num(WIDTH / 2) + WIDTH / 4;
y = rand_num(HEIGHT / 2) + HEIGHT / 4;
} while (Maze[y][x] != SPACE);
/* Start the drone going: */
add_shot(DSHOT, y, x, rand_dir(),
shot_req[conf_mindshot +
rand_num(MAXBOMB - conf_mindshot)],
NULL, FALSE, SPACE);
}
/* Tell the zapped player's client to shut down. */
sendcom(pp, ENDWIN, ' ');
(void) fclose(pp->p_output);
/* Close up the gap in the Player array: */
End_player--;
if (pp != End_player) {
/* Move the last player into the gap: */
memcpy(pp, End_player, sizeof *pp);
outyx(ALL_PLAYERS,
STAT_PLAY_ROW + 1 + (pp - Player),
STAT_NAME_COL,
"%5.2f%c%-10.10s %c",
pp->p_ident->i_score, stat_char(pp),
pp->p_ident->i_name, pp->p_ident->i_team);
}
/* Erase the last player from the display: */
cgoto(ALL_PLAYERS, STAT_PLAY_ROW + 1 + Nplayer, STAT_NAME_COL);
ce(ALL_PLAYERS);
}
else {
/* Zap a monitor */
/* Close the session: */
sendcom(pp, ENDWIN, LAST_PLAYER);
(void) fclose(pp->p_output);
/* shuffle the monitor table */
End_monitor--;
if (pp != End_monitor) {
memcpy(pp, End_monitor, sizeof *pp);
outyx(ALL_PLAYERS,
STAT_MON_ROW + 1 + (pp - Player), STAT_NAME_COL,
"%5.5s %-10.10s %c", " ",
pp->p_ident->i_name, pp->p_ident->i_team);
}
/* Erase the last monitor in the list */
cgoto(ALL_PLAYERS,
STAT_MON_ROW + 1 + (End_monitor - Monitor),
STAT_NAME_COL);
ce(ALL_PLAYERS);
}
/* Update the file descriptor sets used by select: */
FD_CLR(savefd, &Fds_mask);
if (Num_fds == savefd + 1) {
Num_fds = Socket;
if (Server_socket > Socket)
Num_fds = Server_socket;
for (np = Player; np < End_player; np++)
if (np->p_fd > Num_fds)
Num_fds = np->p_fd;
for (np = Monitor; np < End_monitor; np++)
if (np->p_fd > Num_fds)
Num_fds = np->p_fd;
Num_fds++;
}
}
/*
* move_player:
* Execute a move in the given direction
*/
static void
move_player(PLAYER *pp, int dir)
{
PLAYER *newp;
int x, y;
bool moved;
BULLET *bp;
y = pp->p_y;
x = pp->p_x;
switch (dir) {
case LEFTS:
x--;
break;
case RIGHT:
x++;
break;
case ABOVE:
y--;
break;
case BELOW:
y++;
break;
}
moved = false;
switch (Maze[y][x]) {
case SPACE:
#ifdef RANDOM
case DOOR:
#endif
moved = true;
break;
case WALL1:
case WALL2:
case WALL3:
#ifdef REFLECT
case WALL4:
case WALL5:
#endif
break;
case MINE:
case GMINE:
if (dir == pp->p_face)
pickup(pp, y, x, 2, Maze[y][x]);
else if (opposite(dir, pp->p_face))
pickup(pp, y, x, 95, Maze[y][x]);
else
pickup(pp, y, x, 50, Maze[y][x]);
Maze[y][x] = SPACE;
moved = true;
break;
case SHOT:
case GRENADE:
case SATCHEL:
case BOMB:
#ifdef OOZE
case SLIME:
#endif
#ifdef DRONE
case DSHOT:
#endif
bp = is_bullet(y, x);
if (bp != NULL)
bp->b_expl = true;
Maze[y][x] = SPACE;
moved = true;
break;
case LEFTS:
case RIGHT:
case ABOVE:
case BELOW:
if (dir != pp->p_face)
sendcom(pp, BELL);
else {
newp = play_at(y, x);
checkdam(newp, pp, pp->p_ident, STABDAM, KNIFE);
}
break;
#ifdef FLY
case FLYER:
newp = play_at(y, x);
message(newp, "Oooh, there's a short guy waving at you!");
message(pp, "You couldn't quite reach him!");
break;
#endif
#ifdef BOOTS
case BOOT:
case BOOT_PAIR:
if (Maze[y][x] == BOOT)
pp->p_nboots++;
else
pp->p_nboots += 2;
for (newp = Boot; newp < &Boot[NBOOTS]; newp++) {
if (newp->p_flying < 0)
continue;
if (newp->p_y == y && newp->p_x == x) {
newp->p_flying = -1;
if (newp->p_undershot)
fixshots(y, x, newp->p_over);
}
}
if (pp->p_nboots == 2)
message(pp, "Wow! A pair of boots!");
else
message(pp, "You can hobble around on one boot.");
Maze[y][x] = SPACE;
moved = true;
break;
#endif
}
if (moved) {
if (pp->p_ncshot > 0)
if (--pp->p_ncshot == MAXNCSHOT) {
cgoto(pp, STAT_GUN_ROW, STAT_VALUE_COL);
outstr(pp, " ok", 3);
}
if (pp->p_undershot) {
fixshots(pp->p_y, pp->p_x, pp->p_over);
pp->p_undershot = false;
}
drawplayer(pp, false);
pp->p_over = Maze[y][x];
pp->p_y = y;
pp->p_x = x;
drawplayer(pp, true);
}
}
/*
* move_player:
* Try to move player 'pp' in direction 'dir'.
*/
static void
move_player(PLAYER *pp, int dir)
{
PLAYER *newp;
int x, y;
FLAG moved;
BULLET *bp;
y = pp->p_y;
x = pp->p_x;
switch (dir) {
case LEFTS:
x--;
break;
case RIGHT:
x++;
break;
case ABOVE:
y--;
break;
case BELOW:
y++;
break;
}
moved = FALSE;
/* What would the player move over: */
switch (Maze[y][x]) {
/* Players can move through spaces and doors, no problem: */
case SPACE:
case DOOR:
moved = TRUE;
break;
/* Can't move through walls: */
case WALL1:
case WALL2:
case WALL3:
case WALL4:
case WALL5:
break;
/* Moving over a mine - try to pick it up: */
case MINE:
case GMINE:
if (dir == pp->p_face)
/* facing it: 2% chance of trip */
pickup(pp, y, x, conf_ptrip_face, Maze[y][x]);
else if (opposite(dir, pp->p_face))
/* facing away: 95% chance of trip */
pickup(pp, y, x, conf_ptrip_back, Maze[y][x]);
else
/* facing sideways: 50% chance of trip */
pickup(pp, y, x, conf_ptrip_side, Maze[y][x]);
/* Remove the mine: */
Maze[y][x] = SPACE;
moved = TRUE;
break;
/* Moving into a bullet: */
case SHOT:
case GRENADE:
case SATCHEL:
case BOMB:
case SLIME:
case DSHOT:
/* Find which bullet: */
bp = is_bullet(y, x);
if (bp != NULL)
/* Detonate it: */
bp->b_expl = TRUE;
/* Remove it: */
Maze[y][x] = SPACE;
moved = TRUE;
break;
/* Moving into another player: */
case LEFTS:
case RIGHT:
case ABOVE:
case BELOW:
if (dir != pp->p_face)
/* Can't walk backwards/sideways into another player: */
sendcom(pp, BELL);
else {
/* Stab the other player */
newp = play_at(y, x);
checkdam(newp, pp, pp->p_ident, conf_stabdam, KNIFE);
}
break;
/* Moving into a player flying overhead: */
case FLYER:
newp = play_at(y, x);
message(newp, "Oooh, there's a short guy waving at you!");
message(pp, "You couldn't quite reach him!");
break;
/* Picking up a boot, or two: */
case BOOT_PAIR:
pp->p_nboots++;
case BOOT:
pp->p_nboots++;
for (newp = Boot; newp < &Boot[NBOOTS]; newp++) {
if (newp->p_flying < 0)
continue;
if (newp->p_y == y && newp->p_x == x) {
newp->p_flying = -1;
if (newp->p_undershot)
fixshots(y, x, newp->p_over);
}
}
if (pp->p_nboots == 2)
message(pp, "Wow! A pair of boots!");
else
message(pp, "You can hobble around on one boot.");
Maze[y][x] = SPACE;
moved = TRUE;
break;
}
/* Can the player be moved? */
if (moved) {
/* Check the gun status: */
if (pp->p_ncshot > 0)
if (--pp->p_ncshot == conf_maxncshot)
outyx(pp, STAT_GUN_ROW, STAT_VALUE_COL, " ok");
/* Check for bullets flying past: */
if (pp->p_undershot) {
fixshots(pp->p_y, pp->p_x, pp->p_over);
pp->p_undershot = FALSE;
}
/* Erase the player: */
drawplayer(pp, FALSE);
/* Save under: */
pp->p_over = Maze[y][x];
/* Move the player: */
pp->p_y = y;
pp->p_x = x;
/* Draw the player in their new position */
drawplayer(pp, TRUE);
}
}
