-/* $NetBSD: hit.c,v 1.9 2008/01/14 00:23:51 dholland Exp $ */
+/* $NetBSD: hit.c,v 1.10 2008/01/14 03:50:01 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)hit.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: hit.c,v 1.9 2008/01/14 00:23:51 dholland Exp $");
+__RCSID("$NetBSD: hit.c,v 1.10 2008/01/14 03:50:01 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
-object *fight_monster = 0;
+static int damage_for_strength(void);
+static int get_w_damage(const object *);
+static int to_hit(const object *);
+
+static object *fight_monster = NULL;
char hit_message[HIT_MESSAGE_SIZE] = "";
void
-mon_hit(monster)
- object *monster;
+mon_hit(object *monster)
{
short damage, hit_chance;
const char *mn;
}
void
-rogue_hit(monster, force_hit)
- object *monster;
- boolean force_hit;
+rogue_hit(object *monster, boolean force_hit)
{
short damage, hit_chance;
}
void
-rogue_damage(d, monster, other)
- short d;
- object *monster;
- short other;
+rogue_damage(short d, object *monster, short other)
{
if (d >= rogue.hp_current) {
rogue.hp_current = 0;
}
int
-get_damage(ds, r)
- const char *ds;
- boolean r;
+get_damage(const char *ds, boolean r)
{
int i = 0, j, n, d, total = 0;
return(total);
}
-int
-get_w_damage(obj)
- const object *obj;
+static int
+get_w_damage(const object *obj)
{
char new_damage[32];
int tmp_to_hit, tmp_damage;
}
int
-get_number(s)
- const char *s;
+get_number(const char *s)
{
int i = 0;
int total = 0;
}
long
-lget_number(s)
- const char *s;
+lget_number(const char *s)
{
short i = 0;
long total = 0;
return(total);
}
-int
-to_hit(obj)
- const object *obj;
+static int
+to_hit(const object *obj)
{
if (!obj) {
return(1);
return(get_number(obj->damage) + obj->hit_enchant);
}
-int
-damage_for_strength()
+static int
+damage_for_strength(void)
{
short strength;
}
int
-mon_damage(monster, damage)
- object *monster;
- short damage;
+mon_damage(object *monster, short damage)
{
const char *mn;
short row, col;
row = monster->row;
col = monster->col;
dungeon[row][col] &= ~MONSTER;
- mvaddch(row, col, (int)get_dungeon_char(row, col));
+ mvaddch(row, col, get_dungeon_char(row, col));
fight_monster = 0;
cough_up(monster);
}
void
-fight(to_the_death)
- boolean to_the_death;
+fight(boolean to_the_death)
{
short ch, c, d;
short row, col;
}
void
-get_dir_rc(dir, row, col, allow_off_screen)
- short dir;
- short *row, *col;
- short allow_off_screen;
+get_dir_rc(short dir, short *row, short *col, short allow_off_screen)
{
switch(dir) {
case LEFT:
}
int
-get_hit_chance(weapon)
- const object *weapon;
+get_hit_chance(const object *weapon)
{
short hit_chance;
}
int
-get_weapon_damage(weapon)
- const object *weapon;
+get_weapon_damage(const object *weapon)
{
short damage;
}
void
-s_con_mon(monster)
- object *monster;
+s_con_mon(object *monster)
{
if (con_mon) {
monster->m_flags |= CONFUSED;
-/* $NetBSD: init.c,v 1.16 2008/01/14 00:23:51 dholland Exp $ */
+/* $NetBSD: init.c,v 1.17 2008/01/14 03:50:01 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)init.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: init.c,v 1.16 2008/01/14 00:23:51 dholland Exp $");
+__RCSID("$NetBSD: init.c,v 1.17 2008/01/14 03:50:01 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
+static void do_args(int, char **);
+static void do_opts(void);
+static void env_get_value(char **, char *, boolean);
+static void init_str(char **, const char *);
+static void player_init(void);
+
+static char *rest_file = NULL;
+static boolean init_curses = 0;
+
char login_name[MAX_OPT_LEN];
-char *nick_name = (char *)0;
-char *rest_file = 0;
+char *nick_name = NULL;
boolean cant_int = 0;
boolean did_int = 0;
boolean score_only;
-boolean init_curses = 0;
boolean save_is_interactive = 1;
boolean ask_quit = 1;
boolean no_skull = 0;
gid_t gid, egid;
int
-init(argc, argv)
- int argc;
- char *argv[];
+init(int argc, char *argv[])
{
const char *pn;
int seed;
initscr();
if ((LINES < DROWS) || (COLS < DCOLS)) {
- clean_up("must be played on 24 x 80 screen");
+ clean_up("must be played on at least 80 x 24 screen");
}
start_window();
init_curses = 1;
md_heed_signals();
if (score_only) {
- put_scores((object *)0, 0);
+ put_scores(NULL, 0);
}
seed = md_gseed();
(void)srrandom(seed);
get_wand_and_ring_materials();
make_scroll_titles();
- level_objects.next_object = (object *)0;
- level_monsters.next_monster = (object *)0;
+ level_objects.next_object = NULL;
+ level_monsters.next_monster = NULL;
player_init();
ring_stats(0);
return(0);
}
-void
-player_init()
+static void
+player_init(void)
{
object *obj;
- rogue.pack.next_object = (object *)0;
+ rogue.pack.next_object = NULL;
obj = alloc_object();
get_food(obj, 1);
}
void
-clean_up(estr)
- const char *estr;
+clean_up(const char *estr)
{
if (save_is_interactive) {
if (init_curses) {
}
void
-start_window()
+start_window(void)
{
cbreak();
noecho();
}
void
-stop_window()
+stop_window(void)
{
endwin();
}
void
-byebye(dummy)
- int dummy __unused;
+byebye(int dummy __unused)
{
md_ignore_signals();
if (ask_quit) {
}
void
-onintr(dummy)
- int dummy __unused;
+onintr(int dummy __unused)
{
md_ignore_signals();
if (cant_int) {
}
void
-error_save(dummy)
- int dummy __unused;
+error_save(int dummy __unused)
{
save_is_interactive = 0;
save_into_file(error_file);
clean_up("");
}
-void
-do_args(argc, argv)
- int argc;
- char *argv[];
+static void
+do_args(int argc, char *argv[])
{
- short i, j;
+ int i, j;
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
}
}
-void
-do_opts()
+static void
+do_opts(void)
{
char *eptr;
init_str(&fruit, "slime-mold");
}
-void
-env_get_value(s, e, add_blank)
- char **s, *e;
- boolean add_blank;
+static void
+env_get_value(char **s, char *e, boolean add_blank)
{
short i = 0;
const char *t;
(*s)[i] = '\0';
}
-void
-init_str(str, dflt)
- char **str;
- const char *dflt;
+static void
+init_str(char **str, const char *dflt)
{
if (!(*str)) {
/* note: edit_opts() in room.c depends on this size */
-/* $NetBSD: inventory.c,v 1.12 2008/01/14 00:23:51 dholland Exp $ */
+/* $NetBSD: inventory.c,v 1.13 2008/01/14 03:50:01 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)inventory.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: inventory.c,v 1.12 2008/01/14 00:23:51 dholland Exp $");
+__RCSID("$NetBSD: inventory.c,v 1.13 2008/01/14 03:50:01 dholland Exp $");
#endif
#endif /* not lint */
boolean is_wood[WANDS];
const char *press_space = " --press space to continue--";
-const char *const wand_materials[WAND_MATERIALS] = {
+static const char *const wand_materials[WAND_MATERIALS] = {
"steel ",
"bronze ",
"gold ",
"wooden "
};
-const char *const gems[GEMS] = {
+static const char *const gems[GEMS] = {
"diamond ",
"stibotantalite ",
"lapi-lazuli ",
"garnet "
};
-const char *const syllables[MAXSYLLABLES] = {
+static const char *const syllables[MAXSYLLABLES] = {
"blech ",
"foo ",
"barf ",
const char *com_desc;
};
-const struct id_com_s com_id_tab[COMS] = {
+static const struct id_com_s com_id_tab[COMS] = {
{'?', "? prints help"},
{'r', "r read scroll"},
{'/', "/ identify object"},
};
void
-inventory(pack, mask)
- const object *pack;
- unsigned short mask;
+inventory(const object *pack, unsigned short mask)
{
object *obj;
short i = 0, j;
}
void
-id_com()
+id_com(void)
{
int ch = 0;
short i, j, k;
}
int
-pr_com_id(ch)
- int ch;
+pr_com_id(int ch)
{
int i;
}
int
-get_com_id(indexp, ch)
- int *indexp;
- short ch;
+get_com_id(int *indexp, short ch)
{
short i;
}
int
-pr_motion_char(ch)
- int ch;
+pr_motion_char(int ch)
{
if ( (ch == 'J') ||
(ch == 'K') ||
}
void
-mix_colors()
+mix_colors(void)
{
short i, j, k;
char t[MAX_ID_TITLE_LEN];
}
void
-make_scroll_titles()
+make_scroll_titles(void)
{
short i, j, n;
short sylls, s;
size_t maxlen;
};
-static void sbuf_init __P((struct sbuf *s, char *buf, size_t maxlen));
-static void sbuf_addstr __P((struct sbuf *s, const char *str));
-static void sbuf_addf __P((struct sbuf *s, const char *fmt, ...));
-static void desc_count __P((struct sbuf *s, int n));
-static void desc_called __P((struct sbuf *s, const object *));
+static void sbuf_init(struct sbuf *s, char *buf, size_t maxlen);
+static void sbuf_addstr(struct sbuf *s, const char *str);
+static void sbuf_addf(struct sbuf *s, const char *fmt, ...)
+ __attribute__((__format__(__printf__, 2, 3)));
+static void desc_count(struct sbuf *s, int n);
+static void desc_called(struct sbuf *s, const object *);
static
void
-sbuf_init(s, buf, maxlen)
- struct sbuf *s;
- char *buf;
- size_t maxlen;
+sbuf_init(struct sbuf *s, char *buf, size_t maxlen)
{
s->buf = buf;
s->maxlen = maxlen;
static
void
-sbuf_addstr(s, str)
- struct sbuf *s;
- const char *str;
+sbuf_addstr(struct sbuf *s, const char *str)
{
strlcat(s->buf, str, s->maxlen);
}
-static void sbuf_addf(struct sbuf *s, const char *fmt, ...)
- __attribute__((__format__(__printf__, 2, 3)));
-
static
void
sbuf_addf(struct sbuf *s, const char *fmt, ...)
static
void
-desc_count(s, n)
- struct sbuf *s;
- int n;
+desc_count(struct sbuf *s, int n)
{
if (n == 1) {
sbuf_addstr(s, "an ");
static
void
-desc_called(s, obj)
- struct sbuf *s;
- const object *obj;
+desc_called(struct sbuf *s, const object *obj)
{
struct id *id_table;
}
void
-get_desc(obj, desc, desclen)
- const object *obj;
- char *desc;
- size_t desclen;
+get_desc(const object *obj, char *desc, size_t desclen)
{
const char *item_name;
struct id *id_table;
}
void
-get_wand_and_ring_materials()
+get_wand_and_ring_materials(void)
{
short i, j;
boolean used[WAND_MATERIALS];
}
void
-single_inv(ichar)
- short ichar;
+single_inv(short ichar)
{
short ch, ch2;
char desc[DCOLS];
}
struct id *
-get_id_table(obj)
- const object *obj;
+get_id_table(const object *obj)
{
switch(obj->what_is) {
case SCROL:
}
void
-inv_armor_weapon(is_weapon)
- boolean is_weapon;
+inv_armor_weapon(boolean is_weapon)
{
if (is_weapon) {
if (rogue.weapon) {
}
void
-id_type()
+id_type(void)
{
const char *id;
int ch;
-/* $NetBSD: level.c,v 1.9 2008/01/14 00:23:51 dholland Exp $ */
+/* $NetBSD: level.c,v 1.10 2008/01/14 03:50:01 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)level.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: level.c,v 1.9 2008/01/14 00:23:51 dholland Exp $");
+__RCSID("$NetBSD: level.c,v 1.10 2008/01/14 03:50:01 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
-#define swap(x,y) {t = x; x = y; y = t;}
+#define SWAP(x,y) (t = (x), (x) = (y), (y) = t)
+
+static void add_mazes(void);
+static int connect_rooms(short, short);
+static void draw_simple_passage(short, short, short, short, short);
+static void fill_it(int, boolean);
+static void fill_out_level(void);
+static int get_exp_level(long);
+static void hide_boxed_passage(short, short, short, short, short);
+static void make_maze(short, short, short, short, short, short);
+static void make_room(short, short, short, short);
+static boolean mask_room(short, short *, short *, unsigned short);
+static void mix_random_rooms(void);
+static void put_door(room *, short, short *, short *);
+static void recursive_deadend(short, const short *, short, short);
+static int same_col(int, int);
+static int same_row(int, int);
short cur_level = 0;
short max_level = 1;
short cur_room;
-const char *new_level_message = 0;
+const char *new_level_message = NULL;
short party_room = NO_ROOM;
-short r_de;
+
+static short r_de;
const long level_points[MAX_EXP_LEVEL] = {
10L,
99900000L
};
-short random_rooms[MAXROOMS] = {3, 7, 5, 2, 0, 6, 1, 4, 8};
+static short random_rooms[MAXROOMS] = {3, 7, 5, 2, 0, 6, 1, 4, 8};
void
-make_level()
+make_level(void)
{
short i, j;
short must_1, must_2, must_3;
}
}
-void
-make_room(rn, r1, r2, r3)
- short rn, r1, r2, r3;
+static void
+make_room(short rn, short r1, short r2, short r3)
{
short left_col, right_col, top_row, bottom_row;
short width, height;
rooms[rn].right_col = right_col;
}
-int
-connect_rooms(room1, room2)
- short room1, room2;
+static int
+connect_rooms(short room1, short room2)
{
short row1, col1, row2, col2, dir;
}
void
-clear_level()
+clear_level(void)
{
short i, j;
clear();
}
-void
-put_door(rm, dir, row, col)
- room *rm;
- short dir;
- short *row, *col;
+static void
+put_door(room *rm, short dir, short *row, short *col)
{
short wall_width;
rm->doors[dir/2].door_col = *col;
}
-void
-draw_simple_passage(row1, col1, row2, col2, dir)
- short row1, col1, row2, col2, dir;
+static void
+draw_simple_passage(short row1, short col1, short row2, short col2, short dir)
{
short i, middle, t;
if ((dir == LEFT) || (dir == RIGHT)) {
if (col1 > col2) {
- swap(row1, row2);
- swap(col1, col2);
+ SWAP(row1, row2);
+ SWAP(col1, col2);
}
middle = get_rand(col1+1, col2-1);
for (i = col1+1; i != middle; i++) {
}
} else {
if (row1 > row2) {
- swap(row1, row2);
- swap(col1, col2);
+ SWAP(row1, row2);
+ SWAP(col1, col2);
}
middle = get_rand(row1+1, row2-1);
for (i = row1+1; i != middle; i++) {
}
}
-int
-same_row(room1, room2)
- int room1, room2;
+static int
+same_row(int room1, int room2)
{
return((room1 / 3) == (room2 / 3));
}
-int
-same_col(room1, room2)
- int room1, room2;
+static int
+same_col(int room1, int room2)
{
return((room1 % 3) == (room2 % 3));
}
-void
-add_mazes()
+static void
+add_mazes(void)
{
short i, j;
short start;
}
}
-void
-fill_out_level()
+static void
+fill_out_level(void)
{
short i, rn;
}
}
-void
-fill_it(rn, do_rec_de)
- int rn;
- boolean do_rec_de;
+static void
+fill_it(int rn, boolean do_rec_de)
{
short i, tunnel_dir, door_dir, drow, dcol;
short target_room, rooms_found = 0;
}
}
-void
-recursive_deadend(rn, offsets, srow, scol)
- short rn;
- const short *offsets;
- short srow, scol;
+static void
+recursive_deadend(short rn, const short *offsets, short srow, short scol)
{
short i, de;
short drow, dcol, tunnel_dir;
}
}
-boolean
-mask_room(rn, row, col, mask)
- short rn;
- short *row, *col;
- unsigned short mask;
+static boolean
+mask_room(short rn, short *row, short *col, unsigned short mask)
{
short i, j;
return(0);
}
-void
-make_maze(r, c, tr, br, lc, rc)
- short r, c, tr, br, lc, rc;
+static void
+make_maze(short r, short c, short tr, short br, short lc, short rc)
{
char dirs[4];
short i, t;
t1 = get_rand(0, 3);
t2 = get_rand(0, 3);
- swap(dirs[t1], dirs[t2]);
+ SWAP(dirs[t1], dirs[t2]);
}
}
for (i = 0; i < 4; i++) {
}
}
-void
-hide_boxed_passage(row1, col1, row2, col2, n)
- short row1, col1, row2, col2, n;
+static void
+hide_boxed_passage(short row1, short col1, short row2, short col2, short n)
{
short i, j, t;
short row, col, row_cut, col_cut;
if (cur_level > 2) {
if (row1 > row2) {
- swap(row1, row2);
+ SWAP(row1, row2);
}
if (col1 > col2) {
- swap(col1, col2);
+ SWAP(col1, col2);
}
h = row2 - row1;
w = col2 - col1;
}
}
+/*
+ * try not to put in room NR
+ */
void
-put_player(nr)
- short nr; /* try not to put in this room */
+put_player(short nr)
{
short rn = nr, misses;
short row, col;
}
int
-drop_check()
+drop_check(void)
{
if (wizard) {
return(1);
}
int
-check_up()
+check_up(void)
{
if (!wizard) {
if (!(dungeon[rogue.row][rogue.col] & STAIRS)) {
}
void
-add_exp(e, promotion)
- int e;
- boolean promotion;
+add_exp(int e, boolean promotion)
{
short new_exp;
short i, hp;
}
}
-int
-get_exp_level(e)
- long e;
+static int
+get_exp_level(long e)
{
short i;
}
int
-hp_raise()
+hp_raise(void)
{
int hp;
}
void
-show_average_hp()
+show_average_hp(void)
{
float real_average;
float effective_average;
effective_average, extra_hp, less_hp);
}
-void
-mix_random_rooms()
+static void
+mix_random_rooms(void)
{
short i, t;
short x, y;
x = get_rand(0, (MAXROOMS-1));
y = get_rand(0, (MAXROOMS-1));
} while (x == y);
- swap(random_rooms[x], random_rooms[y]);
+ SWAP(random_rooms[x], random_rooms[y]);
}
}
-/* $NetBSD: machdep.c,v 1.16 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: machdep.c,v 1.17 2008/01/14 03:50:01 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)machdep.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: machdep.c,v 1.16 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: machdep.c,v 1.17 2008/01/14 03:50:01 dholland Exp $");
#endif
#endif /* not lint */
*/
void
-md_slurp()
+md_slurp(void)
{
(void)fpurge(stdin);
}
*/
void
-md_heed_signals()
+md_heed_signals(void)
{
signal(SIGINT, onintr);
signal(SIGQUIT, byebye);
*/
void
-md_ignore_signals()
+md_ignore_signals(void)
{
signal(SIGQUIT, SIG_IGN);
signal(SIGINT, SIG_IGN);
*/
int
-md_get_file_id(fname)
- const char *fname;
+md_get_file_id(const char *fname)
{
struct stat sbuf;
*/
int
-md_link_count(fname)
- const char *fname;
+md_link_count(const char *fname)
{
struct stat sbuf;
*/
void
-md_gct(rt_buf)
- struct rogue_time *rt_buf;
+md_gct(struct rogue_time *rt_buf)
{
struct tm *t;
time_t seconds;
*/
void
-md_gfmt(fname, rt_buf)
- const char *fname;
- struct rogue_time *rt_buf;
+md_gfmt(const char *fname, struct rogue_time *rt_buf)
{
struct stat sbuf;
time_t seconds;
struct tm *t;
stat(fname, &sbuf);
- seconds = (long)sbuf.st_mtime;
+ seconds = sbuf.st_mtime;
t = localtime(&seconds);
rt_buf->year = t->tm_year;
*/
boolean
-md_df(fname)
- const char *fname;
+md_df(const char *fname)
{
if (unlink(fname)) {
return(0);
*/
const char *
-md_gln()
+md_gln(void)
{
struct passwd *p;
if (!(p = getpwuid(getuid())))
- return((char *)NULL);
- return(p->pw_name);
+ return NULL;
+ return p->pw_name;
}
/* md_sleep:
*/
void
-md_sleep(nsecs)
- int nsecs;
+md_sleep(int nsecs)
{
(void)sleep(nsecs);
}
*/
char *
-md_getenv(name)
- const char *name;
+md_getenv(const char *name)
{
char *value;
* when no more memory can be allocated.
*/
-char *
-md_malloc(n)
- int n;
+void *
+md_malloc(size_t n)
{
char *t;
*/
int
-md_gseed()
+md_gseed(void)
{
time_t seconds;
*/
void
-md_exit(status)
- int status;
+md_exit(int status)
{
exit(status);
}
*/
void
-md_lock(l)
- boolean l;
+md_lock(boolean l)
{
- static int fd;
+ static int fd = -1;
short tries;
if (l) {
if (!flock(fd, LOCK_EX|LOCK_NB))
return;
} else {
- (void)flock(fd, LOCK_NB);
+ (void)flock(fd, LOCK_UN|LOCK_NB);
(void)close(fd);
}
}
*/
void
-md_shell(shell)
- const char *shell;
+md_shell(const char *shell)
{
int w;
pid_t pid;
case -1:
break;
case 0:
- execl(shell, shell, (char *)0);
+ execl(shell, shell, (char *)NULL);
_exit(255);
default:
waitpid(pid, &w, 0);
}
}
-#endif
+#endif /* UNIX */
-/* $NetBSD: main.c,v 1.7 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: main.c,v 1.8 2008/01/14 03:50:01 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)main.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: main.c,v 1.7 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: main.c,v 1.8 2008/01/14 03:50:01 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
-int main(int, char **);
-
int
-main(argc, argv)
- int argc;
- char *argv[];
+main(int argc, char *argv[])
{
if (init(argc, argv)) { /* restored game */
goto PL;
-/* $NetBSD: message.c,v 1.12 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: message.c,v 1.13 2008/01/14 03:50:01 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)message.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: message.c,v 1.12 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: message.c,v 1.13 2008/01/14 03:50:01 dholland Exp $");
#endif
#endif /* not lint */
#include <termios.h>
#include <stdarg.h>
#include "rogue.h"
+#include "pathnames.h"
-char msgs[NMESSAGES][DCOLS] = {"", "", "", "", ""};
-short msg_col = 0, imsg = -1;
-boolean msg_cleared = 1, rmsg = 0;
+static char msgs[NMESSAGES][DCOLS] = {"", "", "", "", ""};
+static short msg_col = 0, imsg = -1;
+static boolean rmsg = 0;
+
+boolean msg_cleared = 1;
char hunger_str[HUNGER_STR_LEN] = "";
const char *more = "-more-";
-static void message __P((const char *, boolean));
-
static
void
-message(msg, intrpt)
- const char *msg;
- boolean intrpt;
+message(const char *msg, boolean intrpt)
{
cant_int = 1;
}
void
-remessage(c)
- short c;
+remessage(short c)
{
if (imsg != -1) {
check_message();
}
void
-check_message()
+check_message(void)
{
if (msg_cleared) {
return;
}
int
-get_input_line(prompt, insert, buf, buflen, if_cancelled, add_blank, do_echo)
- const char *prompt, *insert;
- char *buf;
- size_t buflen;
- const char *if_cancelled;
- boolean add_blank;
- boolean do_echo;
+get_input_line(const char *prompt, const char *insert,
+ char *buf, size_t buflen,
+ const char *if_cancelled,
+ boolean add_blank, boolean do_echo)
{
short ch;
- short i = 0, n;
+ size_t i = 0, n;
message(prompt, 0);
n = strlen(prompt);
}
int
-rgetchar()
+rgetchar(void)
{
int ch;
ch = getchar();
switch(ch) {
- case '\022':
+ case '\022': /* ^R */
wrefresh(curscr);
break;
#ifdef UNIX_BSD4_2
- case '\032':
+ case '\032': /* ^Z */
printf("%s", CL);
fflush(stdout);
tstp();
*/
void
-print_stats(stat_mask)
- int stat_mask;
+print_stats(int stat_mask)
{
char buf[16];
boolean label;
}
void
-save_screen()
+save_screen(void)
{
FILE *fp;
short i, j;
char buf[DCOLS+2];
- if ((fp = fopen("rogue.screen", "w")) != NULL) {
+ if ((fp = fopen(_PATH_SCREENDUMP, "w")) != NULL) {
for (i = 0; i < DROWS; i++) {
for (j=0; j<DCOLS; j++) {
buf[j] = mvinch(i, j);
}
void
-sound_bell()
+sound_bell(void)
{
putchar(7);
fflush(stdout);
}
boolean
-is_digit(ch)
- short ch;
+is_digit(int ch)
{
return((ch >= '0') && (ch <= '9'));
}
int
-r_index(str, ch, last)
- const char *str;
- int ch;
- boolean last;
+r_index(const char *str, int ch, boolean last)
{
int i = 0;
-/* $NetBSD: monster.c,v 1.13 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: monster.c,v 1.14 2008/01/14 03:50:01 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)monster.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: monster.c,v 1.13 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: monster.c,v 1.14 2008/01/14 03:50:01 dholland Exp $");
#endif
#endif /* not lint */
"zombie"
};
-object mon_tab[MONSTERS] = {
+static object mon_tab[MONSTERS] = {
{(ASLEEP|WAKENS|WANDERS|RUSTS),"0d0",25,'A',20,9,18,100,0,0,0,0,0},
{(ASLEEP|WANDERS|FLITS|FLIES),"1d3",10,'B',2,1,8,60,0,0,0,0,0},
{(ASLEEP|WANDERS),"3d3/2d5",32,'C',15,7,16,85,0,10,0,0,0},
};
void
-put_mons()
+put_mons(void)
{
short i;
short n;
n = get_rand(4, 6);
for (i = 0; i < n; i++) {
- monster = gr_monster((object *)0, 0);
+ monster = gr_monster(NULL, 0);
if ((monster->m_flags & WANDERS) && coin_toss()) {
wake_up(monster);
}
}
object *
-gr_monster(monster, mn)
- object *monster;
- int mn;
+gr_monster(object *monster, int mn)
{
if (!monster) {
monster = alloc_object();
}
void
-mv_mons()
+mv_mons(void)
{
object *monster, *next_monster, *test_mons;
boolean flew;
}
void
-party_monsters(rn, n)
- int rn, n;
+party_monsters(int rn, int n)
{
short i, j;
short row, col;
}
char
-gmc_row_col(row, col)
- int row, col;
+gmc_row_col(int row, int col)
{
object *monster;
}
char
-gmc(monster)
- object *monster;
+gmc(object *monster)
{
if ((!(detect_monster || see_invisible || r_see_invisible) &&
(monster->m_flags & INVISIBLE))
}
void
-mv_1_monster(monster, row, col)
- object *monster;
- short row, col;
+mv_1_monster(object *monster, short row, short col)
{
short i, n;
boolean tried[6];
}
int
-mtry(monster, row, col)
- object *monster;
- short row, col;
+mtry(object *monster, short row, short col)
{
if (mon_can_go(monster, row, col)) {
move_mon_to(monster, row, col);
}
void
-move_mon_to(monster, row, col)
- object *monster;
- short row, col;
+move_mon_to(object *monster, short row, short col)
{
short c;
int mrow, mcol;
}
int
-mon_can_go(monster, row, col)
- const object *monster;
- short row, col;
+mon_can_go(const object *monster, short row, short col)
{
object *obj;
short dr, dc;
}
void
-wake_up(monster)
- object *monster;
+wake_up(object *monster)
{
if (!(monster->m_flags & NAPPING)) {
monster->m_flags &= (~(ASLEEP | IMITATES | WAKENS));
}
void
-wake_room(rn, entering, row, col)
- short rn;
- boolean entering;
- short row, col;
+wake_room(short rn, boolean entering, short row, short col)
{
object *monster;
short wake_percent;
}
const char *
-mon_name(monster)
- const object *monster;
+mon_name(const object *monster)
{
short ch;
}
int
-rogue_is_around(row, col)
- int row, col;
+rogue_is_around(int row, int col)
{
short rdif, cdif, retval;
}
void
-wanderer()
+wanderer(void)
{
object *monster;
short row, col, i;
monster = NULL; /* XXXGCC -Wuninitialized [powerpc] */
for (i = 0; ((i < 15) && (!found)); i++) {
- monster = gr_monster((object *)0, 0);
+ monster = gr_monster(NULL, 0);
if (!(monster->m_flags & (WAKENS | WANDERS))) {
free_object(monster);
} else {
}
void
-show_monsters()
+show_monsters(void)
{
object *monster;
}
void
-create_monster()
+create_monster(void)
{
short row, col;
short i;
}
void
-put_m_at(row, col, monster)
- short row, col;
- object *monster;
+put_m_at(short row, short col, object *monster)
{
monster->row = row;
monster->col = col;
}
void
-aim_monster(monster)
- object *monster;
+aim_monster(object *monster)
{
short i, rn, d, r;
}
int
-rogue_can_see(row, col)
- int row, col;
+rogue_can_see(int row, int col)
{
int retval;
}
int
-move_confused(monster)
- object *monster;
+move_confused(object *monster)
{
short i, row, col;
}
int
-flit(monster)
- object *monster;
+flit(object *monster)
{
short i, row, col;
}
char
-gr_obj_char()
+gr_obj_char(void)
{
short r;
const char *rs = "%!?]=/):*";
}
int
-no_room_for_monster(rn)
- int rn;
+no_room_for_monster(int rn)
{
short i, j;
}
void
-aggravate()
+aggravate(void)
{
object *monster;
}
boolean
-mon_sees(monster, row, col)
- const object *monster;
- int row, col;
+mon_sees(const object *monster, int row, int col)
{
short rn, rdif, cdif, retval;
}
void
-mv_aquatars()
+mv_aquatars(void)
{
object *monster;
-/* $NetBSD: move.c,v 1.10 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: move.c,v 1.11 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)move.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: move.c,v 1.10 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: move.c,v 1.11 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
const char *you_can_move_again = "you can move again";
int
-one_move_rogue(dirch, pickup)
- short dirch, pickup;
+one_move_rogue(short dirch, short pickup)
{
short row, col;
object *obj;
}
void
-multiple_move_rogue(dirch)
- short dirch;
+multiple_move_rogue(short dirch)
{
short row, col;
short m;
}
boolean
-is_passable(row, col)
- int row, col;
+is_passable(int row, int col)
{
if ((row < MIN_ROW) || (row > (DROWS - 2)) || (col < 0) ||
(col > (DCOLS-1))) {
}
boolean
-next_to_something(drow, dcol)
- int drow, dcol;
+next_to_something(int drow, int dcol)
{
short i, j, i_end, j_end, row, col;
short pass_count = 0;
}
boolean
-can_move(row1, col1, row2, col2)
- int row1, col1, row2, col2;
+can_move(int row1, int col1, int row2, int col2)
{
if (!is_passable(row2, col2)) {
return(0);
}
void
-move_onto()
+move_onto(void)
{
short ch, d;
boolean first_miss = 1;
}
boolean
-is_direction(c, d)
- short c;
- short *d;
+is_direction(short c, short *d)
{
switch(c) {
case 'h':
}
boolean
-check_hunger(msg_only)
- boolean msg_only;
+check_hunger(boolean msg_only)
{
short i, n;
boolean fainted = 0;
return(fainted);
}
if (rogue.moves_left <= STARVE) {
- killed_by((object *)0, STARVATION);
+ killed_by(NULL, STARVATION);
}
switch(e_rings) {
}
boolean
-reg_move()
+reg_move(void)
{
boolean fainted;
}
void
-rest(count)
- int count;
+rest(int count)
{
int i;
}
char
-gr_dir()
+gr_dir(void)
{
short d;
}
void
-heal()
+heal(void)
{
static short heal_exp = -1, n, c = 0;
static boolean alt;
}
boolean
-can_turn(nrow, ncol)
- short nrow, ncol;
+can_turn(short nrow, short ncol)
{
if ((dungeon[nrow][ncol] & TUNNEL) && is_passable(nrow, ncol)) {
return(1);
}
void
-turn_passage(dir, fast)
- short dir;
- boolean fast;
+turn_passage(short dir, boolean fast)
{
short crow = rogue.row, ccol = rogue.col, turns = 0;
short ndir = 0;
-/* $NetBSD: object.c,v 1.12 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: object.c,v 1.13 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)object.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: object.c,v 1.12 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: object.c,v 1.13 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
object level_objects;
unsigned short dungeon[DROWS][DCOLS];
short foods = 0;
-object *free_list = (object *)0;
-char *fruit = (char *)0;
+char *fruit = NULL;
+
+static object *free_list = NULL;
fighter rogue = {
INIT_AW, /* armor */
};
void
-put_objects()
+put_objects(void)
{
short i, n;
object *obj;
}
void
-put_gold()
+put_gold(void)
{
short i, j;
short row,col;
}
void
-plant_gold(row, col, is_maze)
- short row, col;
- boolean is_maze;
+plant_gold(short row, short col, boolean is_maze)
{
object *obj;
}
void
-place_at(obj, row, col)
- object *obj;
- int row, col;
+place_at(object *obj, int row, int col)
{
obj->row = row;
obj->col = col;
}
object *
-object_at(pack, row, col)
- object *pack;
- short row, col;
+object_at(object *pack, short row, short col)
{
- object *obj = (object *)0;
+ object *obj = NULL;
if (dungeon[row][col] & (MONSTER | OBJECT)) {
obj = pack->next_object;
}
object *
-get_letter_object(ch)
- int ch;
+get_letter_object(int ch)
{
object *obj;
}
void
-free_stuff(objlist)
- object *objlist;
+free_stuff(object *objlist)
{
object *obj;
}
const char *
-name_of(obj)
- const object *obj;
+name_of(const object *obj)
{
const char *retstring;
}
object *
-gr_object()
+gr_object(void)
{
object *obj;
}
unsigned short
-gr_what_is()
+gr_what_is(void)
{
short percent;
unsigned short what_is;
}
void
-gr_scroll(obj)
- object *obj;
+gr_scroll(object *obj)
{
short percent;
}
void
-gr_potion(obj)
- object *obj;
+gr_potion(object *obj)
{
short percent;
}
void
-gr_weapon(obj, assign_wk)
- object *obj;
- int assign_wk;
+gr_weapon(object *obj, int assign_wk)
{
short percent;
short i;
obj->which_kind = get_rand(0, (WEAPONS - 1));
}
if ((obj->which_kind == ARROW) || (obj->which_kind == DAGGER) ||
- (obj->which_kind == SHURIKEN) | (obj->which_kind == DART)) {
+ (obj->which_kind == SHURIKEN) || (obj->which_kind == DART)) {
obj->quantity = get_rand(3, 15);
obj->quiver = get_rand(0, 126);
} else {
}
void
-gr_armor(obj)
- object *obj;
+gr_armor(object *obj)
{
short percent;
short blessing;
}
void
-gr_wand(obj)
- object *obj;
+gr_wand(object *obj)
{
obj->what_is = WAND;
obj->which_kind = get_rand(0, (WANDS - 1));
}
void
-get_food(obj, force_ration)
- object *obj;
- boolean force_ration;
+get_food(object *obj, boolean force_ration)
{
obj->what_is = FOOD;
}
void
-put_stairs()
+put_stairs(void)
{
short row, col;
}
int
-get_armor_class(obj)
- const object *obj;
+get_armor_class(const object *obj)
{
if (obj) {
return(obj->class + obj->d_enchant);
}
object *
-alloc_object()
+alloc_object(void)
{
object *obj;
if (free_list) {
obj = free_list;
free_list = free_list->next_object;
- } else if (!(obj = (object *)md_malloc(sizeof(object)))) {
+ } else if (!(obj = md_malloc(sizeof(object)))) {
messagef(0, "cannot allocate object, saving game");
save_into_file(error_file);
clean_up("alloc_object: save failed");
}
void
-free_object(obj)
- object *obj;
+free_object(object *obj)
{
obj->next_object = free_list;
free_list = obj;
}
void
-make_party()
+make_party(void)
{
short n;
}
void
-show_objects()
+show_objects(void)
{
object *obj;
short mc, rc, row, col;
}
void
-put_amulet()
+put_amulet(void)
{
object *obj;
}
void
-rand_place(obj)
- object *obj;
+rand_place(object *obj)
{
short row, col;
}
void
-c_object_for_wizard()
+c_object_for_wizard(void)
{
short ch, max, wk;
object *obj;
char buf[80];
max = 0;
- if (pack_count((object *)0) >= MAX_PACK_COUNT) {
+ if (pack_count(NULL) >= MAX_PACK_COUNT) {
messagef(0, "pack full");
return;
}
if (get_input_line("which kind?", "", buf, sizeof(buf), "", 0, 1)) {
wk = get_number(buf);
if ((wk >= 0) && (wk <= max)) {
- obj->which_kind = (unsigned short)wk;
+ obj->which_kind = wk;
if (obj->what_is == RING) {
gr_ring(obj, 0);
}
-/* $NetBSD: pack.c,v 1.9 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: pack.c,v 1.10 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)pack.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: pack.c,v 1.9 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: pack.c,v 1.10 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
const char *curse_message = "you can't, it appears to be cursed";
object *
-add_to_pack(obj, pack, condense)
- object *obj, *pack;
- int condense;
+add_to_pack(object *obj, object *pack, int condense)
{
object *op;
}
void
-take_from_pack(obj, pack)
- object *obj, *pack;
+take_from_pack(object *obj, object *pack)
{
while (pack->next_object != obj) {
pack = pack->next_object;
*/
object *
-pick_up(row, col, status)
- short *status;
- int row, col;
+pick_up(int row, int col, short *status)
{
object *obj;
if (levitate) {
messagef(0, "you're floating in the air!");
- return((object *)0);
+ return NULL;
}
obj = object_at(&level_objects, row, col);
if (!obj) {
if (id_scrolls[SCARE_MONSTER].id_status == UNIDENTIFIED) {
id_scrolls[SCARE_MONSTER].id_status = IDENTIFIED;
}
- return((object *)0);
+ return NULL;
}
if (obj->what_is == GOLD) {
rogue.gold += obj->quantity;
}
if (pack_count(obj) >= MAX_PACK_COUNT) {
messagef(1, "pack too full");
- return((object *)0);
+ return NULL;
}
dungeon[row][col] &= ~(OBJECT);
take_from_pack(obj, &level_objects);
}
void
-drop()
+drop(void)
{
object *obj, *new;
short ch;
}
object *
-check_duplicate(obj, pack)
- object *obj, *pack;
+check_duplicate(object *obj, object *pack)
{
object *op;
}
short
-next_avail_ichar()
+next_avail_ichar(void)
{
object *obj;
int i;
}
void
-wait_for_ack()
+wait_for_ack(void)
{
while (rgetchar() != ' ')
;
}
short
-pack_letter(prompt, mask)
- const char *prompt;
- unsigned short mask;
+pack_letter(const char *prompt, unsigned short mask)
{
short ch;
unsigned short tmask = mask;
}
void
-take_off()
+take_off(void)
{
char desc[DCOLS];
object *obj;
}
void
-wear()
+wear(void)
{
short ch;
object *obj;
}
void
-unwear(obj)
- object *obj;
+unwear(object *obj)
{
if (obj) {
obj->in_use_flags &= (~BEING_WORN);
}
- rogue.armor = (object *)0;
+ rogue.armor = NULL;
}
void
-do_wear(obj)
- object *obj;
+do_wear(object *obj)
{
rogue.armor = obj;
obj->in_use_flags |= BEING_WORN;
}
void
-wield()
+wield(void)
{
short ch;
object *obj;
}
void
-do_wield(obj)
- object *obj;
+do_wield(object *obj)
{
rogue.weapon = obj;
obj->in_use_flags |= BEING_WIELDED;
}
void
-unwield(obj)
- object *obj;
+unwield(object *obj)
{
if (obj) {
obj->in_use_flags &= (~BEING_WIELDED);
}
- rogue.weapon = (object *)0;
+ rogue.weapon = NULL;
}
void
-call_it()
+call_it(void)
{
short ch;
object *obj;
}
short
-pack_count(new_obj)
- const object *new_obj;
+pack_count(const object *new_obj)
{
object *obj;
short count = 0;
}
boolean
-mask_pack(pack, mask)
- const object *pack;
- unsigned short mask;
+mask_pack(const object *pack, unsigned short mask)
{
while (pack->next_object) {
pack = pack->next_object;
}
boolean
-is_pack_letter(c, mask)
- short *c;
- unsigned short *mask;
+is_pack_letter(short *c, unsigned short *mask)
{
if (((*c == '?') || (*c == '!') || (*c == ':') || (*c == '=') ||
(*c == ')') || (*c == ']') || (*c == '/') || (*c == ','))) {
}
boolean
-has_amulet()
+has_amulet(void)
{
return(mask_pack(&rogue.pack, AMULET));
}
void
-kick_into_pack()
+kick_into_pack(void)
{
object *obj;
char desc[DCOLS];
-/* $NetBSD: pathnames.h,v 1.4 2003/08/07 09:37:39 agc Exp $ */
+/* $NetBSD: pathnames.h,v 1.5 2008/01/14 03:50:02 dholland Exp $ */
/*-
* Copyright (c) 1990, 1993
*/
#define _PATH_SCOREFILE "/var/games/rogue.scores"
+#define _PATH_SCREENDUMP "rogue.screen"
-/* $NetBSD: play.c,v 1.8 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: play.c,v 1.9 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)play.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: play.c,v 1.8 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: play.c,v 1.9 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
boolean interrupted = 0;
-const char *unknown_command = "unknown command";
+
+static const char unknown_command[] = "unknown command";
void
-play_level()
+play_level(void)
{
short ch;
int count;
-/* $NetBSD: random.c,v 1.6 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: random.c,v 1.7 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)random.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: random.c,v 1.6 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: random.c,v 1.7 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
static long *end_ptr = &rntb[32];
void
-srrandom(x)
- int x;
+srrandom(int x)
{
int i;
- state[0] = (long)x;
+ state[0] = x;
if (rand_type != 0) {
for (i = 1; i < rand_deg; i++) {
state[i] = 1103515245 * state[i - 1] + 12345;
}
long
-rrandom()
+rrandom(void)
{
long i;
}
int
-get_rand(x, y)
- int x, y;
+get_rand(int x, int y)
{
int r, t;
long lr;
x = t;
}
lr = rrandom();
- lr &= (long)0x00003fff;
+ lr &= 0x00003fffL;
r = (int)lr;
r = (r % ((y - x) + 1)) + x;
return(r);
}
int
-rand_percent(percentage)
- int percentage;
+rand_percent(int percentage)
{
return(get_rand(1, 100) <= percentage);
}
int
-coin_toss()
+coin_toss(void)
{
return(((rrandom() & 01) ? 1 : 0));
}
-/* $NetBSD: ring.c,v 1.8 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: ring.c,v 1.9 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)ring.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: ring.c,v 1.8 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: ring.c,v 1.9 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
-const char *left_or_right = "left or right hand?";
-const char *no_ring = "there's no ring on that hand";
+static const char left_or_right[] = "left or right hand?";
+static const char no_ring[] = "there's no ring on that hand";
+
short stealthy;
short r_rings;
short add_strength;
boolean maintain_armor;
void
-put_on_ring()
+put_on_ring(void)
{
short ch;
char desc[DCOLS];
*/
void
-do_put_on(ring, on_left)
- object *ring;
- boolean on_left;
+do_put_on(object *ring, boolean on_left)
{
if (on_left) {
ring->in_use_flags |= ON_LEFT_HAND;
}
void
-remove_ring()
+remove_ring(void)
{
boolean left = 0, right = 0;
short ch;
}
void
-un_put_on(ring)
- object *ring;
+un_put_on(object *ring)
{
if (ring && (ring->in_use_flags & ON_LEFT_HAND)) {
ring->in_use_flags &= (~ON_LEFT_HAND);
- rogue.left_ring = 0;
+ rogue.left_ring = NULL;
} else if (ring && (ring->in_use_flags & ON_RIGHT_HAND)) {
ring->in_use_flags &= (~ON_RIGHT_HAND);
- rogue.right_ring = 0;
+ rogue.right_ring = NULL;
}
ring_stats(1);
}
void
-gr_ring(ring, assign_wk)
- object *ring;
- boolean assign_wk;
+gr_ring(object *ring, boolean assign_wk)
{
ring->what_is = RING;
if (assign_wk) {
}
void
-inv_rings()
+inv_rings(void)
{
char buf[DCOLS];
}
void
-ring_stats(pr)
- boolean pr;
+ring_stats(boolean pr)
{
short i;
object *ring;
-/* $NetBSD: rogue.h,v 1.18 2007/12/27 23:53:00 dholland Exp $ */
+/* $NetBSD: rogue.h,v 1.19 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
typedef struct obj object;
-#define INIT_AW (object*)0
-#define INIT_RINGS (object*)0
+#define INIT_AW NULL
+#define INIT_RINGS NULL
#define INIT_HP 12
#define INIT_STR 16
#define INIT_EXPLEVEL 1
#define MAXROOMS 9
#define BIG_ROOM 10
-#define NO_ROOM -1
+#define NO_ROOM (-1)
-#define PASSAGE -3 /* cur_room value */
+#define PASSAGE (-3) /* cur_room value */
#define AMULET_LEVEL 26
extern struct id id_weapons[];
extern struct id id_armors[];
-extern object mon_tab[];
extern object level_monsters;
#define MONSTERS 26
const char *get_ench_color(void);
object *get_letter_object(int);
object *get_thrown_at_monster(object *, short, short *, short *);
-object *get_zapped_monster(short, short *, short *);
object *gr_monster(object *, int);
object *gr_object(void);
char *md_getenv(const char *);
const char *
md_gln(void);
-char *md_malloc(int);
+void *md_malloc(size_t);
const char *mon_name(const object *);
const char *name_of(const object *);
object *object_at(object *, short, short);
object *pick_up(int, int, short *);
void add_exp(int, boolean);
-void add_mazes(void);
void add_traps(void);
void aggravate(void);
void aim_monster(object *);
void c_object_for_wizard(void);
void call_it(void);
boolean can_move(int, int, int, int);
-boolean can_turn(int, int);
+boolean can_turn(short, short);
void center(short, const char *);
void check_gold_seeker(object *);
boolean check_hunger(boolean);
void clear_level(void);
void cnfs(void);
int coin_toss(void);
-int connect_rooms(short, short);
void cough_up(object *);
void create_monster(void);
-int damage_for_strength(void);
void darken_room(short);
-void disappear(object *);
-void do_args(int, char **);
-void do_opts(void);
void do_put_on(object *, boolean);
void do_shell(void);
void do_wear(object *);
void do_wield(object *);
void dr_course(object *, boolean, short, short);
-void drain_life(void);
void draw_magic_map(void);
-void draw_simple_passage(short, short, short, short, short);
void drop(void);
int drop_check(void);
-void drop_level(void);
void eat(void);
void edit_opts(void);
-void env_get_value(char **, char *, boolean);
void error_save(int) __attribute__((__noreturn__));
-void fight(int);
-void fill_it(int, boolean);
-void fill_out_level(void);
+void fight(boolean);
boolean flame_broil(object *);
int flit(object *);
void flop_weapon(object *, short, short);
void free_object(object *);
void free_stuff(object *);
-void freeze(object *);
int get_armor_class(const object *);
int get_com_id(int *, short);
int get_damage(const char *, boolean);
void get_desc(const object *, char *, size_t);
-int get_dir(short, short, short, short);
void get_dir_rc(short, short *, short *, short);
char get_dungeon_char(short, short);
-int get_exp_level(long);
void get_food(object *, boolean);
int get_hit_chance(const object *);
int get_input_line(const char *, const char *, char *, size_t, const char *, boolean, boolean);
int get_rand(int, int);
short get_room_number(int, int);
int get_value(const object *);
-int get_w_damage(const object *);
void get_wand_and_ring_materials(void);
int get_weapon_damage(const object *);
char gmc(object *);
char gmc_row_col(int, int);
void go_blind(void);
-boolean gold_at(int, int);
void gr_armor(object *);
char gr_dir(void);
char gr_obj_char(void);
void gr_weapon(object *, int);
void hallucinate(void);
boolean has_amulet(void);
-boolean has_been_touched(const struct rogue_time *, const struct rogue_time *);
void heal(void);
-void hide_boxed_passage(int, int, int, int, int);
void hold_monster(void);
int hp_raise(void);
void id_all(void);
void id_trap(void);
void id_type(void);
void idntfy(void);
-boolean imitating(int, int);
+boolean imitating(short, short);
int init(int, char **);
-void init_str(char **, const char *);
void insert_score(char [][82], char [][30], const char *, short, short, const object *, int);
void inv_armor_weapon(boolean);
void inv_rings(void);
void light_up_room(int);
boolean m_confuse(object *);
void make_level(void);
-void make_maze(short, short, short, short, short, short);
void make_party(void);
-void make_room(short, short, short, short);
void make_scroll_titles(void);
boolean mask_pack(const object *, unsigned short);
-boolean mask_room(short, short *, short *, unsigned short);
boolean md_df(const char *);
void md_exit(int) __attribute__((__noreturn__));
void md_gct(struct rogue_time *);
void messagef(boolean, const char *, ...)
__attribute__((__format__(__printf__, 2, 3)));
void mix_colors(void);
-void mix_random_rooms(void);
-int mon_can_go(const object *, int, int);
+int mon_can_go(const object *, short, short);
int mon_damage(object *, short);
void mon_hit(object *);
boolean mon_sees(const object *, int, int);
int move_confused(object *);
-void move_mon_to(object *, int, int);
+void move_mon_to(object *, short, short);
void move_onto(void);
-int mtry(object *, int, int);
+int mtry(object *, short, short);
void multiple_move_rogue(short);
-void mv_1_monster(object *, int, int);
+void mv_1_monster(object *, short, short);
void mv_aquatars(void);
void mv_mons(void);
int name_cmp(char *, const char *);
void party_monsters(int, int);
short party_objects(int);
void place_at(object *, int, int);
-void plant_gold(int, int, boolean);
+void plant_gold(short, short, boolean);
void play_level(void);
-void player_init(void);
void potion_heal(int);
int pr_com_id(int);
int pr_motion_char(int);
void print_stats(int);
void put_amulet(void);
-void put_door(room *, short, short *, short *);
void put_gold(void);
-void put_m_at(int, int, object *);
+void put_m_at(short, short, object *);
void put_mons(void);
void put_objects(void);
void put_on_ring(void);
void quaff(void);
void quit(boolean);
int r_index(const char *, int, boolean);
-void r_read(FILE *, char *, int);
-void r_write(FILE *, const char *, int);
void rand_around(short, short *, short *);
int rand_percent(int);
void rand_place(object *);
-void read_pack(object *, FILE *, boolean);
void read_scroll(void);
-void read_string(char *, FILE *, size_t);
-void recursive_deadend(short, const short *, short, short);
boolean reg_move(void);
void relight(void);
void remessage(short);
int rogue_is_around(int, int);
long rrandom(void);
void rust(object *);
-void rw_dungeon(FILE *, boolean);
-void rw_id(struct id *, FILE *, int, boolean);
-void rw_rooms(FILE *, boolean);
void s_con_mon(object *);
-int same_col(int, int);
-int same_row(int, int);
void save_game(void);
void save_into_file(const char *);
void save_screen(void);
void special_hit(object *);
void srrandom(int);
void start_window(void);
-void steal_gold(object *);
-void steal_item(object *);
-void sting(object *);
void stop_window(void);
void take_a_nap(void);
void take_from_pack(object *, object *);
void take_off(void);
void tele(void);
-void tele_away(object *);
void throw(void);
boolean throw_at_monster(object *, object *);
-int to_hit(const object *);
short trap_at(int, int);
-void trap_player(int, int);
-boolean try_to_cough(short, short, object *);
+void trap_player(short, short);
void turn_passage(short, boolean);
void un_put_on(object *);
void unblind(void);
void wake_room(short, boolean, short, short);
void wake_up(object *);
void wanderer(void);
-void wdrain_life(object *);
void wear(void);
void wield(void);
void win(void) __attribute__((__noreturn__));
void wizardize(void);
-void write_pack(const object *, FILE *);
-void write_string(char *, FILE *);
long xxx(boolean);
void xxxx(char *, short);
-void zap_monster(object *, unsigned short);
void zapp(void);
object *add_to_pack(object *, object *, int);
struct id *get_id_table(const object *);
-/* $NetBSD: room.c,v 1.11 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: room.c,v 1.12 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)room.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: room.c,v 1.11 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: room.c,v 1.12 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
room rooms[MAXROOMS];
-boolean rooms_visited[MAXROOMS];
-#define NOPTS 7
+static boolean rooms_visited[MAXROOMS];
-const struct option {
+#define NOPTS 7
+static const struct option {
const char *prompt;
boolean is_bool;
char **strval;
} options[NOPTS] = {
{
"Show position only at end of run (\"jump\"): ",
- 1, (char **)0, &jump
+ 1, NULL, &jump
},
{
"Follow turnings in passageways (\"passgo\"): ",
- 1, (char **)0, &passgo
+ 1, NULL, &passgo
},
{
"Don't print skull when killed (\"noskull\" or \"notombstone\"): ",
- 1, (char **)0, &no_skull
+ 1, NULL, &no_skull
},
{
"Ask player before saying 'Okay, bye-bye!' (\"askquit\"): ",
- 1, (char **)0, &ask_quit
+ 1, NULL, &ask_quit
},
{
"Name (\"name\"): ",
- 0, &nick_name, (boolean *)0
+ 0, &nick_name, NULL
},
{
"Fruit (\"fruit\"): ",
- 0, &fruit, (boolean *)0
+ 0, &fruit, NULL
},
{
"Save file (\"file\"): ",
- 0, &save_file, (boolean *)0
+ 0, &save_file, NULL
}
};
void
-light_up_room(rn)
- int rn;
+light_up_room(int rn)
{
short i, j;
}
void
-light_passage(row, col)
- int row, col;
+light_passage(int row, int col)
{
short i, j, i_end, j_end;
}
void
-darken_room(rn)
- short rn;
+darken_room(short rn)
{
short i, j;
}
char
-get_dungeon_char(row, col)
- short row, col;
+get_dungeon_char(short row, short col)
{
unsigned short mask = dungeon[row][col];
}
char
-get_mask_char(mask)
- unsigned short mask;
+get_mask_char(unsigned short mask)
{
switch(mask) {
case SCROL:
}
void
-gr_row_col(row, col, mask)
- short *row, *col;
- unsigned short mask;
+gr_row_col(short *row, short *col, unsigned short mask)
{
short rn;
short r, c;
}
short
-gr_room()
+gr_room(void)
{
short i;
}
short
-party_objects(rn)
- int rn;
+party_objects(int rn)
{
short i, j, nf = 0;
object *obj;
}
short
-get_room_number(row, col)
- int row, col;
+get_room_number(int row, int col)
{
short i;
}
boolean
-is_all_connected()
+is_all_connected(void)
{
short i, starting_room;
}
void
-visit_rooms(rn)
- int rn;
+visit_rooms(int rn)
{
short i;
short oth_rn;
}
void
-draw_magic_map()
+draw_magic_map(void)
{
short i, j, ch, och;
unsigned short mask = (HORWALL | VERTWALL | DOOR | TUNNEL | TRAP | STAIRS |
}
void
-dr_course(monster, entering, row, col)
- object *monster;
- boolean entering;
- short row, col;
+dr_course(object *monster, boolean entering, short row, short col)
{
short i, j, k, rn;
short r, rr;
}
boolean
-get_oth_room(rn, row, col)
- short rn, *row, *col;
+get_oth_room(short rn, short *row, short *col)
{
short d = -1;
}
void
-edit_opts()
+edit_opts(void)
{
char save[NOPTS+1][DCOLS];
short i, j;
}
void
-opt_show(i)
- int i;
+opt_show(int i)
{
const char *s;
const struct option *opt = &options[i];
}
void
-opt_erase(i)
- int i;
+opt_erase(int i)
{
const struct option *opt = &options[i];
}
void
-opt_go(i)
- int i;
+opt_go(int i)
{
move(i, strlen(options[i].prompt));
}
void
-do_shell()
+do_shell(void)
{
#ifdef UNIX
const char *sh;
-/* $NetBSD: save.c,v 1.12 2008/01/14 00:23:52 dholland Exp $ */
+/* $NetBSD: save.c,v 1.13 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)save.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: save.c,v 1.12 2008/01/14 00:23:52 dholland Exp $");
+__RCSID("$NetBSD: save.c,v 1.13 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
#include <stdio.h>
#include "rogue.h"
-short write_failed = 0;
-char *save_file = (char *)0;
+static boolean has_been_touched(const struct rogue_time *,
+ const struct rogue_time *);
+static void r_read(FILE *, void *, size_t);
+static void r_write(FILE *, const void *, size_t);
+static void read_pack(object *, FILE *, boolean);
+static void read_string(char *, FILE *, size_t);
+static void rw_dungeon(FILE *, boolean);
+static void rw_id(struct id *, FILE *, int, boolean);
+static void rw_rooms(FILE *, boolean);
+static void write_pack(const object *, FILE *);
+static void write_string(char *, FILE *);
+
+static short write_failed = 0;
+
+char *save_file = NULL;
void
-save_game()
+save_game(void)
{
char fname[64];
}
void
-save_into_file(sfile)
- const char *sfile;
+save_into_file(const char *sfile)
{
FILE *fp;
int file_id;
md_ignore_signals();
write_failed = 0;
(void)xxx(1);
- r_write(fp, (char *) &detect_monster, sizeof(detect_monster));
- r_write(fp, (char *) &cur_level, sizeof(cur_level));
- r_write(fp, (char *) &max_level, sizeof(max_level));
+ r_write(fp, &detect_monster, sizeof(detect_monster));
+ r_write(fp, &cur_level, sizeof(cur_level));
+ r_write(fp, &max_level, sizeof(max_level));
write_string(hunger_str, fp);
write_string(login_name, fp);
- r_write(fp, (char *) &party_room, sizeof(party_room));
+ r_write(fp, &party_room, sizeof(party_room));
write_pack(&level_monsters, fp);
write_pack(&level_objects, fp);
- r_write(fp, (char *) &file_id, sizeof(file_id));
+ r_write(fp, &file_id, sizeof(file_id));
rw_dungeon(fp, 1);
- r_write(fp, (char *) &foods, sizeof(foods));
- r_write(fp, (char *) &rogue, sizeof(fighter));
+ r_write(fp, &foods, sizeof(foods));
+ r_write(fp, &rogue, sizeof(fighter));
write_pack(&rogue.pack, fp);
rw_id(id_potions, fp, POTIONS, 1);
rw_id(id_scrolls, fp, SCROLS, 1);
rw_id(id_wands, fp, WANDS, 1);
rw_id(id_rings, fp, RINGS, 1);
- r_write(fp, (char *) traps, (MAX_TRAPS * sizeof(trap)));
- r_write(fp, (char *) is_wood, (WANDS * sizeof(boolean)));
- r_write(fp, (char *) &cur_room, sizeof(cur_room));
+ r_write(fp, traps, (MAX_TRAPS * sizeof(trap)));
+ r_write(fp, is_wood, (WANDS * sizeof(boolean)));
+ r_write(fp, &cur_room, sizeof(cur_room));
rw_rooms(fp, 1);
- r_write(fp, (char *) &being_held, sizeof(being_held));
- r_write(fp, (char *) &bear_trap, sizeof(bear_trap));
- r_write(fp, (char *) &halluc, sizeof(halluc));
- r_write(fp, (char *) &blind, sizeof(blind));
- r_write(fp, (char *) &confused, sizeof(confused));
- r_write(fp, (char *) &levitate, sizeof(levitate));
- r_write(fp, (char *) &haste_self, sizeof(haste_self));
- r_write(fp, (char *) &see_invisible, sizeof(see_invisible));
- r_write(fp, (char *) &detect_monster, sizeof(detect_monster));
- r_write(fp, (char *) &wizard, sizeof(wizard));
- r_write(fp, (char *) &score_only, sizeof(score_only));
- r_write(fp, (char *) &m_moves, sizeof(m_moves));
+ r_write(fp, &being_held, sizeof(being_held));
+ r_write(fp, &bear_trap, sizeof(bear_trap));
+ r_write(fp, &halluc, sizeof(halluc));
+ r_write(fp, &blind, sizeof(blind));
+ r_write(fp, &confused, sizeof(confused));
+ r_write(fp, &levitate, sizeof(levitate));
+ r_write(fp, &haste_self, sizeof(haste_self));
+ r_write(fp, &see_invisible, sizeof(see_invisible));
+ r_write(fp, &detect_monster, sizeof(detect_monster));
+ r_write(fp, &wizard, sizeof(wizard));
+ r_write(fp, &score_only, sizeof(score_only));
+ r_write(fp, &m_moves, sizeof(m_moves));
md_gct(&rt_buf);
rt_buf.second += 10; /* allow for some processing time */
- r_write(fp, (char *) &rt_buf, sizeof(rt_buf));
+ r_write(fp, &rt_buf, sizeof(rt_buf));
fclose(fp);
if (write_failed) {
}
void
-restore(fname)
- const char *fname;
+restore(const char *fname)
{
FILE *fp;
struct rogue_time saved_time, mod_time;
clean_up("file has link");
}
(void)xxx(1);
- r_read(fp, (char *) &detect_monster, sizeof(detect_monster));
- r_read(fp, (char *) &cur_level, sizeof(cur_level));
- r_read(fp, (char *) &max_level, sizeof(max_level));
+ r_read(fp, &detect_monster, sizeof(detect_monster));
+ r_read(fp, &cur_level, sizeof(cur_level));
+ r_read(fp, &max_level, sizeof(max_level));
read_string(hunger_str, fp, sizeof hunger_str);
(void)strlcpy(tbuf, login_name, sizeof tbuf);
clean_up("you're not the original player");
}
- r_read(fp, (char *) &party_room, sizeof(party_room));
+ r_read(fp, &party_room, sizeof(party_room));
read_pack(&level_monsters, fp, 0);
read_pack(&level_objects, fp, 0);
- r_read(fp, (char *) &saved_file_id, sizeof(saved_file_id));
+ r_read(fp, &saved_file_id, sizeof(saved_file_id));
if (new_file_id != saved_file_id) {
clean_up("sorry, saved game is not in the same file");
}
rw_dungeon(fp, 0);
- r_read(fp, (char *) &foods, sizeof(foods));
- r_read(fp, (char *) &rogue, sizeof(fighter));
+ r_read(fp, &foods, sizeof(foods));
+ r_read(fp, &rogue, sizeof(fighter));
read_pack(&rogue.pack, fp, 1);
rw_id(id_potions, fp, POTIONS, 0);
rw_id(id_scrolls, fp, SCROLS, 0);
rw_id(id_wands, fp, WANDS, 0);
rw_id(id_rings, fp, RINGS, 0);
- r_read(fp, (char *) traps, (MAX_TRAPS * sizeof(trap)));
- r_read(fp, (char *) is_wood, (WANDS * sizeof(boolean)));
- r_read(fp, (char *) &cur_room, sizeof(cur_room));
+ r_read(fp, traps, (MAX_TRAPS * sizeof(trap)));
+ r_read(fp, is_wood, (WANDS * sizeof(boolean)));
+ r_read(fp, &cur_room, sizeof(cur_room));
rw_rooms(fp, 0);
- r_read(fp, (char *) &being_held, sizeof(being_held));
- r_read(fp, (char *) &bear_trap, sizeof(bear_trap));
- r_read(fp, (char *) &halluc, sizeof(halluc));
- r_read(fp, (char *) &blind, sizeof(blind));
- r_read(fp, (char *) &confused, sizeof(confused));
- r_read(fp, (char *) &levitate, sizeof(levitate));
- r_read(fp, (char *) &haste_self, sizeof(haste_self));
- r_read(fp, (char *) &see_invisible, sizeof(see_invisible));
- r_read(fp, (char *) &detect_monster, sizeof(detect_monster));
- r_read(fp, (char *) &wizard, sizeof(wizard));
- r_read(fp, (char *) &score_only, sizeof(score_only));
- r_read(fp, (char *) &m_moves, sizeof(m_moves));
- r_read(fp, (char *) &saved_time, sizeof(saved_time));
-
- if (fread(buf, sizeof(char), 1, fp) > 0) {
+ r_read(fp, &being_held, sizeof(being_held));
+ r_read(fp, &bear_trap, sizeof(bear_trap));
+ r_read(fp, &halluc, sizeof(halluc));
+ r_read(fp, &blind, sizeof(blind));
+ r_read(fp, &confused, sizeof(confused));
+ r_read(fp, &levitate, sizeof(levitate));
+ r_read(fp, &haste_self, sizeof(haste_self));
+ r_read(fp, &see_invisible, sizeof(see_invisible));
+ r_read(fp, &detect_monster, sizeof(detect_monster));
+ r_read(fp, &wizard, sizeof(wizard));
+ r_read(fp, &score_only, sizeof(score_only));
+ r_read(fp, &m_moves, sizeof(m_moves));
+ r_read(fp, &saved_time, sizeof(saved_time));
+
+ if (fread(buf, 1, 1, fp) > 0) {
clear();
clean_up("extra characters in file");
}
fclose(fp);
}
-void
-write_pack(pack, fp)
- const object *pack;
- FILE *fp;
+static void
+write_pack(const object *pack, FILE *fp)
{
object t;
while ((pack = pack->next_object) != NULL) {
- r_write(fp, (const char *) pack, sizeof(object));
+ r_write(fp, pack, sizeof(object));
}
t.ichar = t.what_is = 0;
- r_write(fp, (const char *) &t, sizeof(object));
+ r_write(fp, &t, sizeof(object));
}
-void
-read_pack(pack, fp, is_rogue)
- object *pack;
- FILE *fp;
- boolean is_rogue;
+static void
+read_pack(object *pack, FILE *fp, boolean is_rogue)
{
object read_obj, *new_obj;
for (;;) {
- r_read(fp, (char *) &read_obj, sizeof(object));
+ r_read(fp, &read_obj, sizeof(object));
if (read_obj.ichar == 0) {
- pack->next_object = (object *)0;
+ pack->next_object = NULL;
break;
}
new_obj = alloc_object();
}
}
-void
-rw_dungeon(fp, rw)
- FILE *fp;
- boolean rw;
+static void
+rw_dungeon(FILE *fp, boolean rw)
{
short i, j;
char buf[DCOLS];
for (i = 0; i < DROWS; i++) {
if (rw) {
- r_write(fp, (char *) dungeon[i], (DCOLS * sizeof(dungeon[0][0])));
+ r_write(fp, dungeon[i], (DCOLS * sizeof(dungeon[0][0])));
for (j = 0; j < DCOLS; j++) {
buf[j] = mvinch(i, j);
}
r_write(fp, buf, DCOLS);
} else {
- r_read(fp, (char *) dungeon[i], (DCOLS * sizeof(dungeon[0][0])));
+ r_read(fp, dungeon[i], (DCOLS * sizeof(dungeon[0][0])));
r_read(fp, buf, DCOLS);
for (j = 0; j < DCOLS; j++) {
mvaddch(i, j, buf[j]);
}
}
-void
-rw_id(id_table, fp, n, wr)
- struct id id_table[];
- FILE *fp;
- int n;
- boolean wr;
+static void
+rw_id(struct id id_table[], FILE *fp, int n, boolean wr)
{
- short i;
+ int i;
for (i = 0; i < n; i++) {
if (wr) {
- r_write(fp, (const char *) &(id_table[i].value), sizeof(short));
- r_write(fp, (const char *) &(id_table[i].id_status),
+ r_write(fp, &id_table[i].value, sizeof(short));
+ r_write(fp, &id_table[i].id_status,
sizeof(unsigned short));
write_string(id_table[i].title, fp);
} else {
- r_read(fp, (char *) &(id_table[i].value), sizeof(short));
- r_read(fp, (char *) &(id_table[i].id_status),
+ r_read(fp, &id_table[i].value, sizeof(short));
+ r_read(fp, &id_table[i].id_status,
sizeof(unsigned short));
read_string(id_table[i].title, fp, MAX_ID_TITLE_LEN);
}
}
}
-void
-write_string(s, fp)
- char *s;
- FILE *fp;
+static void
+write_string(char *s, FILE *fp)
{
short n;
n = strlen(s) + 1;
xxxx(s, n);
- r_write(fp, (char *) &n, sizeof(short));
+ r_write(fp, &n, sizeof(short));
r_write(fp, s, n);
}
-void
-read_string(s, fp, len)
- char *s;
- FILE *fp;
- size_t len;
+static void
+read_string(char *s, FILE *fp, size_t len)
{
short n;
- r_read(fp, (char *) &n, sizeof(short));
+ r_read(fp, &n, sizeof(short));
if (n<=0 || (size_t)(unsigned short)n > len) {
clean_up("read_string: corrupt game file");
}
s[n-1] = 0;
}
-void
-rw_rooms(fp, rw)
- FILE *fp;
- boolean rw;
+static void
+rw_rooms(FILE *fp, boolean rw)
{
short i;
for (i = 0; i < MAXROOMS; i++) {
- rw ? r_write(fp, (char *) (rooms + i), sizeof(room)) :
- r_read(fp, (char *) (rooms + i), sizeof(room));
+ rw ? r_write(fp, (rooms + i), sizeof(room)) :
+ r_read(fp, (rooms + i), sizeof(room));
}
}
-void
-r_read(fp, buf, n)
- FILE *fp;
- char *buf;
- int n;
+static void
+r_read(FILE *fp, void *buf, size_t n)
{
- if (fread(buf, sizeof(char), n, fp) != (size_t)n) {
- clean_up("read() failed, don't know why");
+ if (fread(buf, 1, n, fp) != n) {
+ clean_up("fread() failed, don't know why");
}
}
-void
-r_write(fp, buf, n)
- FILE *fp;
- const char *buf;
- int n;
+static void
+r_write(FILE *fp, const void *buf, size_t n)
{
if (!write_failed) {
- if (fwrite(buf, sizeof(char), n, fp) != (size_t)n) {
+ if (fwrite(buf, 1, n, fp) != n) {
messagef(0, "write() failed, don't know why");
sound_bell();
write_failed = 1;
}
}
-boolean
-has_been_touched(saved_time, mod_time)
- const struct rogue_time *saved_time, *mod_time;
+static boolean
+has_been_touched(const struct rogue_time *saved_time,
+ const struct rogue_time *mod_time)
{
if (saved_time->year < mod_time->year) {
return(1);
-/* $NetBSD: score.c,v 1.13 2008/01/14 00:23:53 dholland Exp $ */
+/* $NetBSD: score.c,v 1.14 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)score.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: score.c,v 1.13 2008/01/14 00:23:53 dholland Exp $");
+__RCSID("$NetBSD: score.c,v 1.14 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
#include "pathnames.h"
void
-killed_by(monster, other)
- const object *monster;
- short other;
+killed_by(const object *monster, short other)
{
const char *mechanism = "killed by something unknown (?)";
char mechanism_buf[128];
}
void
-win()
+win(void)
{
unwield(rogue.weapon); /* disarm and relax */
unwear(rogue.armor);
messagef(0, "%s", ""); /* gcc objects to just "" */
id_all();
sell_pack();
- put_scores((object *)0, WIN);
+ put_scores(NULL, WIN);
}
void
-quit(from_intrpt)
- boolean from_intrpt;
+quit(boolean from_intrpt)
{
char buf[DCOLS];
short i, orow, ocol;
clean_up(byebye_string);
}
check_message();
- killed_by((object *)0, QUIT);
+ killed_by(NULL, QUIT);
}
/*
#define NUM_SCORE_ENTRIES 10
-static void pad_spaces __P((char *, size_t));
-static void unpad_spaces(char *);
-static int read_score_entry __P((struct score_entry *, FILE *));
-static void write_score_entry __P((const struct score_entry *, int, FILE *));
-static void make_score __P((struct score_entry *, const object *, int));
-
+static void make_score(struct score_entry *, const object *, int);
static
void
-pad_spaces(str, len)
- char *str;
- size_t len;
+pad_spaces(char *str, size_t len)
{
size_t x;
for (x=strlen(str); x<len-1; x++) {
static
void
-unpad_spaces(str)
- char *str;
+unpad_spaces(char *str)
{
size_t x;
for (x=strlen(str); x>0 && str[x-1]==' '; x--);
static
int
-read_score_entry(se, fp)
- struct score_entry *se;
- FILE *fp;
+read_score_entry(struct score_entry *se, FILE *fp)
{
char score_block[80];
char nickname_block[30];
static
void
-write_score_entry(se, rank, fp)
- const struct score_entry *se;
- int rank;
- FILE *fp;
+write_score_entry(const struct score_entry *se, int rank, FILE *fp)
{
char score_block[80];
char nickname_block[30];
}
void
-put_scores(monster, other)
- const object *monster;
- short other;
+put_scores(const object *monster, short other)
{
short i, rank=-1, found_player = -1, numscores = 0;
struct score_entry scores[NUM_SCORE_ENTRIES];
static
void
-make_score(se, monster, other)
- struct score_entry *se;
- const object *monster;
- int other;
+make_score(struct score_entry *se, const object *monster, int other)
{
const char *death = "bolts from the blue (?)";
const char *hasamulet;
}
boolean
-is_vowel(ch)
- short ch;
+is_vowel(short ch)
{
return( (ch == 'a') ||
(ch == 'e') ||
}
void
-sell_pack()
+sell_pack(void)
{
object *obj;
short row = 2, val;
}
int
-get_value(obj)
- const object *obj;
+get_value(const object *obj)
{
short wc;
int val;
}
void
-id_all()
+id_all(void)
{
short i;
}
void
-xxxx(buf, n)
- char *buf;
- short n;
+xxxx(char *buf, short n)
{
short i;
unsigned char c;
}
long
-xxx(st)
- boolean st;
+xxx(boolean st)
{
static long f, s;
long r;
}
void
-center(row, buf)
- short row;
- const char *buf;
+center(short row, const char *buf)
{
short margin;
}
void
-sf_error()
+sf_error(void)
{
md_lock(0);
messagef(1, "%s", ""); /* gcc objects to just "" */
-/* $NetBSD: spec_hit.c,v 1.7 2008/01/14 00:23:53 dholland Exp $ */
+/* $NetBSD: spec_hit.c,v 1.8 2008/01/14 03:50:02 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)spec_hit.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: spec_hit.c,v 1.7 2008/01/14 00:23:53 dholland Exp $");
+__RCSID("$NetBSD: spec_hit.c,v 1.8 2008/01/14 03:50:02 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
+static void disappear(object *);
+static void drain_life(void);
+static void drop_level(void);
+static void freeze(object *);
+static int get_dir(short, short, short, short);
+static boolean gold_at(short, short);
+static void steal_gold(object *);
+static void steal_item(object *);
+static void sting(object *);
+static boolean try_to_cough(short, short, object *);
+
short less_hp = 0;
boolean being_held;
void
-special_hit(monster)
- object *monster;
+special_hit(object *monster)
{
if ((monster->m_flags & CONFUSED) && rand_percent(66)) {
return;
}
void
-rust(monster)
- object *monster;
+rust(object *monster)
{
if ((!rogue.armor) || (get_armor_class(rogue.armor) <= 1) ||
(rogue.armor->which_kind == LEATHER)) {
}
void
-freeze(monster)
- object *monster;
+freeze(object *monster)
{
short freeze_percent = 99;
short i, n;
for (i = 0; i < 50; i++) {
mv_mons();
}
- killed_by((object *)0, HYPOTHERMIA);
+ killed_by(NULL, HYPOTHERMIA);
}
messagef(1, you_can_move_again);
monster->m_flags &= (~FREEZING_ROGUE);
}
void
-steal_gold(monster)
- object *monster;
+steal_gold(object *monster)
{
int amount;
}
void
-steal_item(monster)
- object *monster;
+steal_item(object *monster)
{
object *obj;
short i, n, t = 0;
disappear(monster);
}
-void
-disappear(monster)
- object *monster;
+static void
+disappear(object *monster)
{
short row, col;
}
void
-cough_up(monster)
- object *monster;
+cough_up(object *monster)
{
object *obj;
short row, col, i, n;
free_object(obj);
}
-boolean
-try_to_cough(row, col, obj)
- short row, col;
- object *obj;
+static boolean
+try_to_cough(short row, short col, object *obj)
{
if ((row < MIN_ROW) ||
(row > (DROWS-2)) || (col < 0) || (col>(DCOLS-1))) {
}
boolean
-seek_gold(monster)
- object *monster;
+seek_gold(object *monster)
{
short i, j, rn, s;
return(0);
}
-boolean
-gold_at(row, col)
- short row, col;
+static boolean
+gold_at(short row, short col)
{
if (dungeon[row][col] & OBJECT) {
object *obj;
}
void
-check_gold_seeker(monster)
- object *monster;
+check_gold_seeker(object *monster)
{
monster->m_flags &= (~SEEKS_GOLD);
}
boolean
-check_imitator(monster)
- object *monster;
+check_imitator(object *monster)
{
if (monster->m_flags & IMITATES) {
wake_up(monster);
}
boolean
-imitating(row, col)
- short row, col;
+imitating(short row, short col)
{
if (dungeon[row][col] & MONSTER) {
object *monster;
return(0);
}
-void
-sting(monster)
- object *monster;
+static void
+sting(object *monster)
{
short sting_chance = 35;
}
}
-void
-drop_level()
+static void
+drop_level(void)
{
int hp;
}
void
-drain_life()
+drain_life(void)
{
short n;
}
boolean
-m_confuse(monster)
- object *monster;
+m_confuse(object *monster)
{
if (!rogue_can_see(monster->row, monster->col)) {
return(0);
}
boolean
-flame_broil(monster)
- object *monster;
+flame_broil(object *monster)
{
short row, col, dir;
return(1);
}
-int
-get_dir(srow, scol, drow, dcol)
- short srow, scol, drow, dcol;
+static int
+get_dir(short srow, short scol, short drow, short dcol)
{
if (srow == drow) {
if (scol < dcol) {
-/* $NetBSD: throw.c,v 1.9 2008/01/14 00:23:53 dholland Exp $ */
+/* $NetBSD: throw.c,v 1.10 2008/01/14 03:50:03 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)throw.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: throw.c,v 1.9 2008/01/14 00:23:53 dholland Exp $");
+__RCSID("$NetBSD: throw.c,v 1.10 2008/01/14 03:50:03 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
void
-throw()
+throw(void)
{
short wch, d;
boolean first_miss = 1;
}
boolean
-throw_at_monster(monster, weapon)
- object *monster, *weapon;
+throw_at_monster(object *monster, object *weapon)
{
short damage, hit_chance;
short t;
}
object *
-get_thrown_at_monster(obj, dir, row, col)
- object *obj;
- short dir;
- short *row, *col;
+get_thrown_at_monster(object *obj, short dir, short *row, short *col)
{
short orow, ocol;
short i, ch;
}
void
-flop_weapon(weapon, row, col)
- object *weapon;
- short row, col;
+flop_weapon(object *weapon, short row, short col)
{
object *new_weapon, *monster;
short i = 0;
}
void
-rand_around(i, r, c)
- short i, *r, *c;
+rand_around(short i, short *r, short *c)
{
static char pos[] = "\010\007\001\003\004\005\002\006\0";
static short row, col;
-/* $NetBSD: trap.c,v 1.8 2008/01/14 00:23:53 dholland Exp $ */
+/* $NetBSD: trap.c,v 1.9 2008/01/14 03:50:03 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)trap.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: trap.c,v 1.8 2008/01/14 00:23:53 dholland Exp $");
+__RCSID("$NetBSD: trap.c,v 1.9 2008/01/14 03:50:03 dholland Exp $");
#endif
#endif /* not lint */
boolean trap_door = 0;
short bear_trap = 0;
-const char *const trap_strings[TRAPS * 2] = {
+static const char *const trap_strings[TRAPS * 2] = {
"trap door",
"you fell down a trap",
"bear trap",
};
short
-trap_at(row, col)
- int row, col;
+trap_at(int row, int col)
{
short i;
}
void
-trap_player(row, col)
- short row, col;
+trap_player(short row, short col)
{
short t;
break;
case RUST_TRAP:
messagef(1, "%s", trap_strings[(t*2)+1]);
- rust((object *)0);
+ rust(NULL);
break;
}
}
void
-add_traps()
+add_traps(void)
{
short i, n, tries = 0;
short row, col;
}
void
-id_trap()
+id_trap(void)
{
short dir, row, col, d, t;
}
void
-show_traps()
+show_traps(void)
{
short i, j;
}
void
-search(n, is_auto)
- short n;
- boolean is_auto;
+search(short n, boolean is_auto)
{
short s, i, j, row, col, t;
short shown = 0, found = 0;
-/* $NetBSD: use.c,v 1.8 2008/01/14 00:23:53 dholland Exp $ */
+/* $NetBSD: use.c,v 1.9 2008/01/14 03:50:03 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)use.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: use.c,v 1.8 2008/01/14 00:23:53 dholland Exp $");
+__RCSID("$NetBSD: use.c,v 1.9 2008/01/14 03:50:03 dholland Exp $");
#endif
#endif /* not lint */
short extra_hp = 0;
boolean detect_monster = 0;
boolean con_mon = 0;
-const char *strange_feeling = "you have a strange feeling for a moment, then it passes";
+
+static const char strange_feeling[] =
+ "you have a strange feeling for a moment, then it passes";
void
-quaff()
+quaff(void)
{
short ch;
object *obj;
}
void
-read_scroll()
+read_scroll(void)
{
short ch;
object *obj;
*/
void
-vanish(obj, rm, pack)
- object *obj;
- short rm;
- object *pack;
+vanish(object *obj, short rm, object *pack)
{
if (obj->quantity > 1) {
obj->quantity--;
}
void
-potion_heal(extra)
- int extra;
+potion_heal(int extra)
{
float ratio;
short add;
if (extra) {
ratio += ratio;
}
- add = (short)(ratio * ((float)rogue.hp_max - rogue.hp_current));
+ add = (short)(ratio * (rogue.hp_max - rogue.hp_current));
rogue.hp_current += add;
if (rogue.hp_current > rogue.hp_max) {
rogue.hp_current = rogue.hp_max;
unblind();
}
if (confused && extra) {
- unconfuse();
+ unconfuse();
} else if (confused) {
confused = (confused / 2) + 1;
}
}
void
-idntfy()
+idntfy(void)
{
short ch;
object *obj;
}
void
-eat()
+eat(void)
{
short ch;
short moves;
}
void
-hold_monster()
+hold_monster(void)
{
short i, j;
short mcount = 0;
}
void
-tele()
+tele(void)
{
mvaddch(rogue.row, rogue.col, get_dungeon_char(rogue.row, rogue.col));
}
void
-hallucinate()
+hallucinate(void)
{
object *obj, *monster;
short ch;
}
void
-unhallucinate()
+unhallucinate(void)
{
halluc = 0;
relight();
}
void
-unblind()
+unblind(void)
{
blind = 0;
messagef(1, "the veil of darkness lifts");
}
void
-relight()
+relight(void)
{
if (cur_room == PASSAGE) {
light_passage(rogue.row, rogue.col);
}
void
-take_a_nap()
+take_a_nap(void)
{
short i;
}
void
-go_blind()
+go_blind(void)
{
short i, j;
}
const char *
-get_ench_color()
+get_ench_color(void)
{
if (halluc) {
return(id_potions[get_rand(0, POTIONS-1)].title);
}
void
-cnfs()
+cnfs(void)
{
confused += get_rand(12, 22);
}
void
-unconfuse()
+unconfuse(void)
{
confused = 0;
messagef(1, "you feel less %s now", (halluc ? "trippy" : "confused"));
}
void
-uncurse_all()
+uncurse_all(void)
{
object *obj;
-/* $NetBSD: zap.c,v 1.8 2008/01/14 00:23:53 dholland Exp $ */
+/* $NetBSD: zap.c,v 1.9 2008/01/14 03:50:03 dholland Exp $ */
/*
* Copyright (c) 1988, 1993
#if 0
static char sccsid[] = "@(#)zap.c 8.1 (Berkeley) 5/31/93";
#else
-__RCSID("$NetBSD: zap.c,v 1.8 2008/01/14 00:23:53 dholland Exp $");
+__RCSID("$NetBSD: zap.c,v 1.9 2008/01/14 03:50:03 dholland Exp $");
#endif
#endif /* not lint */
#include "rogue.h"
+static object *get_zapped_monster(short, short *, short *);
+static void tele_away(object *);
+static void wdrain_life(object *);
+static void zap_monster(object *, unsigned short);
+
boolean wizard = 0;
void
-zapp()
+zapp(void)
{
short wch;
boolean first_miss = 1;
(void)reg_move();
}
-object *
-get_zapped_monster(dir, row, col)
- short dir;
- short *row, *col;
+static object *
+get_zapped_monster(short dir, short *row, short *col)
{
short orow, ocol;
}
}
-void
-zap_monster(monster, kind)
- object *monster;
- unsigned short kind;
+static void
+zap_monster(object *monster, unsigned short kind)
{
short row, col;
object *nm;
}
}
-void
-tele_away(monster)
- object *monster;
+static void
+tele_away(object *monster)
{
short row, col;
}
void
-wizardize()
+wizardize(void)
{
char buf[100];
}
}
-void
-wdrain_life(monster)
- object *monster;
+static void
+wdrain_life(object *monster)
{
short hp;
object *lmon, *nm;
}
void
-bounce(ball, dir, row, col, r)
- short ball, dir, row, col, r;
+bounce(short ball, short dir, short row, short col, short r)
{
short orow, ocol;
const char *s;
damage = (damage * 3) / 2;
damage -= get_armor_class(rogue.armor);
}
- rogue_damage(damage, (object *)0,
+ rogue_damage(damage, NULL,
((ball == FIRE) ? KFIRE : HYPOTHERMIA));
messagef(0, "the %s hits", s);
}
git.ckatri.com / bsdgames-darwin.git / commitdiff