Early Roguelike Collection: xrogue/util.c comparison

comparison xrogue/util.c @ 220:f54901b9c39b

XRogue: convert to ANSI-style function declarations.

author	John "Elwin" Edwards
date	Wed, 02 Mar 2016 21:13:26 -0500
parents	ce0cf824c192
children	7c1cb43f346e

comparison

equal deleted inserted replaced

-:f9ef86cf22b2
+:f54901b9c39b
 /*
 * this routine computes the players current AC without dex bonus's
 */
 int
-ac_compute(ignoremetal)
+ac_compute(bool ignoremetal)
-bool ignoremetal;
 {
 register int ac;
 ac = pstats.s_arm; /* base armor of "skin" */
 if (cur_armor) {
 /*
 * aggravate:
 *      aggravate all the monsters on this level
 */
-aggravate(do_uniques, do_good)
+void
-bool do_uniques, do_good;
+aggravate(bool do_uniques, bool do_good)
 {
 register struct linked_list *mi;
 register struct thing *thingptr;
 for (mi = mlist; mi != NULL; mi = next(mi)) {
 /*
 * cansee:
 *      returns true if the hero can see a certain coordinate.
 */
-cansee(y, x)
+bool
-register int y, x;
+cansee(int y, int x)
 {
 register struct room *rer;
 register int radius;
 coord tp;
 * up through MAXDOUBLE. Then the cap is added in to compute
 * further levels
 */
 long
-check_level()
+check_level(void)
 {
 register int i, j, add = 0;
 register unsigned long exp;
 long retval;        /* Return value */
 int nsides;
 /*
 * Used to modify the players strength
 * it keeps track of the highest it has been, just in case
 */
-chg_str(amt)
+void
-register int amt;
+chg_str(int amt)
 {
 register int ring_str;              /* ring strengths */
 register struct stats *ptr;         /* for speed */
 ptr = &pstats;
 /*
 * let's confuse the player
 */
-confus_player()
+void
+confus_player(void)
 {
 if (off(player, ISCLEAR))
 {
 msg("Wait, what's going on here!  Huh? What? Who?");
 if (find_slot(unconfuse))
 /*
 * this routine computes the players current dexterity
 */
-dex_compute()
+int
+dex_compute(void)
 {
 if (cur_misc[WEAR_GAUNTLET] != NULL         &&
 cur_misc[WEAR_GAUNTLET]->o_which == MM_G_DEXTERITY) {
 if (cur_misc[WEAR_GAUNTLET]->o_flags & ISCURSED)
 return (3);
 /*
 * diag_ok:
 *      Check to see if the move is legal if it is diagonal
 */
-diag_ok(sp, ep, flgptr)
+bool
-register coord *sp, *ep;
+diag_ok(coord *sp, coord *ep, struct thing *flgptr)
-struct thing *flgptr;
 {
 register int numpaths = 0;
 /* Horizontal and vertical moves are always ok */
 if (ep->x == sp->x || ep->y == sp->y)
 /*
 * pick a random position around the give (y, x) coordinates
 */
 coord *
-fallpos(pos, be_clear, range)
+fallpos(coord *pos, bool be_clear, int range)
-register coord *pos;
-bool be_clear;
-int range;
 {
 register int tried, i, j;
 register char ch;
 static coord ret;
 static short masks[] = {
 /*
 * findmindex:
 *      Find the index into the monster table of a monster given its name.
 */
-findmindex(name)
+int
-char *name;
+findmindex(char *name)
 {
 int which;
 for (which=1; which<NUMMONST; which++) {
 if (strcmp(name, monsters[which].m_name) == 0)
 * find_mons:
 *      Find the monster from his coordinates
 */
 struct linked_list *
-find_mons(y, x)
+find_mons(int y, int x)
-register int y;
-register int x;
 {
 register struct linked_list *item;
 register struct thing *th;
 for (item = mlist; item != NULL; item = next(item))
 * find_obj:
 *      find the unclaimed object at y, x
 */
 struct linked_list *
-find_obj(y, x)
+find_obj(int y, int x)
-register int y;
-register int x;
 {
 register struct linked_list *obj;
 register struct object *op;
 for (obj = lvl_obj; obj != NULL; obj = next(obj))
 /*
 * get coordinates from the player using the cursor keys (or mouse)
 */
 coord
-get_coordinates()
+get_coordinates(void)
 {
 register int which;
 coord c;
 c = hero;
 /*
 * set up the direction co_ordinate for use in various "prefix" commands
 */
 bool
-get_dir(direction)
+get_dir(coord *direction)
-coord *direction;
 {
 register char *prompt;
 register bool gotit;
 int x,y;
 * get_worth:
 *      Calculate an objects worth in gold
 */
 long
-get_worth(obj)
+get_worth(struct object *obj)
-reg struct object *obj;
 {
 reg long worth, wh;
 worth = 0;
 wh = obj->o_which;
 /*
 *      invisible()
 */
 bool
-invisible(monst)
+invisible(struct thing *monst)
-register struct thing *monst;
 {
 register bool   ret_code;
 ret_code  = on(*monst, CANSURPRISE);
 ret_code &= !ISWEARING(R_ALERT);
 /*
 * see if the object is one of the currently used items
 */
-is_current(obj)
+bool
-register struct object *obj;
+is_current(struct object *obj)
 {
 if (obj == NULL)
 return FALSE;
 if (obj == cur_armor         || obj == cur_weapon        ||
 obj == cur_ring[LEFT_1]  || obj == cur_ring[LEFT_2]  ||
 /*
 * Look:
 *      A quick glance all around the player
-*/
+*	wakeup: Should we wake up monsters
+*	runend: At end of a run -- for mazes
-look(wakeup, runend)
+*/
-bool wakeup;    /* Should we wake up monsters */
-bool runend;    /* At end of a run -- for mazes */
+void
+look(bool wakeup, bool runend)
 {
 register int x, y, radius;
 register unsigned char ch, och;
 register int oldx, oldy;
 register bool inpass, horiz, vert, do_light = FALSE, do_blank = FALSE;
 /*
 * Lower a level of experience
 */
-lower_level(who)
+void
-short who;
+lower_level(short who)
 {
 int fewer, nsides;
 	unsigned long exp;
 msg("You suddenly feel less skillful.");
 /*
 * print out the name of a monster
 */
 char *
-monster_name(tp)
+monster_name(struct thing *tp)
-register struct thing *tp;
 {
 prbuf[0] = '\0';
 if (on(*tp, ISFLEE) || on(*tp, WASTURNED))
 strcat(prbuf, "terrified ");
 if (on(*tp, ISHUH))
 *      Try to move the hero somplace besides next to where he is.  We ask him
 *      where.  There can be restrictions based on why he is moving.
 */
 bool
-move_hero(why)
+move_hero(int why)
-int why;
 {
 char *action = NULL;
 unsigned char which;
 coord c;
 /*
 * raise_level:
 *      The guy just magically went up a level.
 */
-raise_level()
+void
+raise_level(void)
 {
 unsigned long test;  /* Next level -- be sure it is not an overflow */
 test = check_level();       /* Get next boundary */
 };
 /*
 * save:
 *      See if a creature saves against something
-*/
+* which: which type of save
+* who: who is saving
-save(which, who, adj)
+* adj: saving throw adjustment
-int which;              /* which type of save */
+*/
-struct thing *who;      /* who is saving */
-int adj;                /* saving throw adjustment */
+bool
+save(int which, struct thing *who, int adj)
 {
 register int need, level, protect;
 protect = 0;
 level = who->t_stats.s_lvl;
 /*
 * secret_door:
 *      Figure out what a secret door looks like.
 */
-secretdoor(y, x)
+char
-register int y, x;
+secretdoor(int y, int x)
 {
 register int i;
 register struct room *rp;
 register coord *cpp;
 static coord cp;
 /*
 * this routine computes the players current strength
 */
-str_compute()
+int
+str_compute(void)
 {
 if (cur_misc[WEAR_GAUNTLET] != NULL         &&
 cur_misc[WEAR_GAUNTLET]->o_which == MM_G_OGRE) {
 if (cur_misc[WEAR_GAUNTLET]->o_flags & ISCURSED)
 return (3);
 /*
 * copy string using unctrl for things
 */
-strucpy(s1, s2, len)
+void
-register char *s1, *s2;
+strucpy(char *s1, char *s2, int len)
-register int len;
 {
 register char *sp;
 while (len--)
 {
 strcpy(s1, (sp = unctrl(*s2)));
 * tr_name:
 *      print the name of a trap
 */
 char *
-tr_name(ch)
+tr_name(char ch)
-char ch;
 {
 register char *s = NULL;
 switch (ch)
 {
 /*
 * for printfs: if string starts with a vowel, return "n" for an "an"
 */
 char *
-vowelstr(str)
+vowelstr(char *str)
-register char *str;
 {
 switch (*str)
 {
 case 'a':
 case 'e':
 /*
 * wake up a room full (hopefully) of creatures
 */
-wake_room(rp)
+void
-register struct room *rp;
+wake_room(struct room *rp)
 {
 register struct linked_list *item;
 register struct thing *tp;
 for (item=mlist; item!=NULL; item=next(item)) {
 /*
 * waste_time:
 *      Do nothing but let other things happen
 */
-waste_time()
+void
+waste_time(void)
 {
 if (inwhgt)                 /* if from wghtchk then done */
 return;
 do_daemons(BEFORE);
 do_fuses(BEFORE);

Mercurial > hg > early-roguelike

comparison xrogue/util.c @ 220:f54901b9c39b