Early Roguelike Collection: xrogue/move.c comparison

comparison xrogue/move.c @ 220:f54901b9c39b

XRogue: convert to ANSI-style function declarations.

author	John "Elwin" Edwards
date	Wed, 02 Mar 2016 21:13:26 -0500
parents	a0a57cf42810
children	e52a8a7ad4c5

comparison

equal deleted inserted replaced

-:f9ef86cf22b2
+:f54901b9c39b
 See the file LICENSE.TXT for full copyright and licensing information.
 */
 #include <curses.h>
 #include <ctype.h>
+#include <string.h>
 #include "rogue.h"
 /*
 * Used to hold the new hero position
 */
 /*
 * be_trapped:
 *      The guy stepped on a trap.... Make him pay.
 */
-be_trapped(th, tc)
+char
-register struct thing *th;
+be_trapped(struct thing *th, coord *tc)
-register coord *tc;
 {
 register struct trap *tp;
 register char ch, *mname = NULL;
 register bool is_player = (th == &player),
 can_see;
 * blue_light:
 *      magically light up a room (or level or make it dark)
 */
 bool
-blue_light(blessed, cursed)
+blue_light(bool blessed, bool cursed)
-bool blessed, cursed;
 {
 register struct room *rp;
 bool ret_val=FALSE; /* Whether or not affect is known */
 rp = roomin(&hero); /* What room is hero in? */
 * corr_move:
 *      Check to see that a move is legal.  If so, return correct character.
 *      If not, if player came from a legal place, then try to turn him.
 */
-corr_move(dy, dx)
+void
-int dy, dx;
+corr_move(int dy, int dx)
 {
 int legal=0;                /* Number of legal alternatives */
 register int y, x,          /* Indexes though possible positions */
 locy = 0, locx = 0;    /* Hold delta of chosen location */
 /*
 * dip_it:
 *      Dip an object into a magic pool
 */
-dip_it()
+void
+dip_it(void)
 {
 reg struct linked_list *what;
 reg struct object *ob;
 reg struct trap *tp;
 reg int wh, i;
 * do_move:
 *      Check to see that a move is legal.  If it is handle the
 * consequences (fighting, picking up, etc.)
 */
-do_move(dy, dx)
+void
-int dy, dx;
+do_move(int dy, int dx)
 {
 register struct room *rp, *orp;
 register unsigned char ch;
 struct linked_list *item;
 register struct thing *tp = NULL;
 /*
 * do_run:
 *      Start the hero running
 */
-do_run(ch)
+void
-char ch;
+do_run(char ch)
 {
 firstmove = TRUE;
 running = TRUE;
 after = FALSE;
 runch = ch;
 *      y and x delta corresponding to it in the remaining arguments.
 *      Returns TRUE if it could find it, FALSE otherwise.
 */
 bool
-getdelta(match, dy, dx)
+getdelta(char match, int *dy, int *dx)
-char match;
-int *dy, *dx;
 {
 register int y, x;
 for (y = 0; y < 3; y++)
 for (x = 0; x < 3; x++)
 /*
 * isatrap:
 *      Returns TRUE if this character is some kind of trap
 */
-isatrap(ch)
+bool
-reg char ch;
+isatrap(char ch)
 {
 switch(ch) {
 case WORMHOLE:
 case DARTTRAP:
 case TELTRAP:
 /*
 * Called to illuminate a room.
 * If it is dark, remove anything that might move.
 */
-light(cp)
+void
-coord *cp;
+light(coord *cp)
 {
 register struct room *rp;
 register int j, k, x, y;
 register unsigned char ch, rch, sch;
 register struct linked_list *item;
 * lit_room:
 *      Called to see if the specified room is lit up or not.
 */
 bool
-lit_room(rp)
+lit_room(struct room *rp)
-register struct room *rp;
 {
 register struct linked_list *fire_item;
 register struct thing *fire_creature;
 if (!(rp->r_flags & ISDARK)) return(TRUE);  /* A definitely lit room */
 *      Given a pointer to a player/monster structure, calculate the
 *      movement rate for that character.
 */
 short
-movement(tp)
+movement(struct thing *tp)
-register struct thing *tp;
 {
 register int result;
 register int carry;         /* Percentage carried */
 result = 0;
 * rndmove:
 *      move in a random direction if the monster/person is confused
 */
 coord
-rndmove(who)
+rndmove(struct thing *who)
-struct thing *who;
 {
 register int x, y;
 register int ex, ey, nopen = 0;
 coord ret;  /* what we will be returning */
 coord dest;
 /*
 * set_trap:
 *      set a trap at (y, x) on screen.
 */
-set_trap(tp, y, x)
+void
-register struct thing *tp;
+set_trap(struct thing *tp, int y, int x)
-register int y, x;
 {
 register bool is_player = (tp == &player);
 register int selection = rnd(TRAPTYPES-WIZARDTRAPS) + '1';
 register int i, num_traps;
 register unsigned char ch = 0, och;
 if (menu_overlay)
 /*
 * Put out the selection.  The longest line is
 * the prompt line (39 characters long).
 */
-over_win(cw, hw, num_traps + 3, 41, 0, 39, NULL);
+over_win(cw, hw, num_traps + 3, 41, 0, 39, '\0');
 else
 draw(hw);
 state = 1;      /* Now in prompt window */
 }
 break;
 if (menu_overlay)
 /*
 * Put out the selection.  The longest line is
 * the prompt line (43 characters long).
 */
-over_win(cw, hw, num_traps+3, 45, 0, 43, NULL);
+over_win(cw, hw, num_traps+3, 45, 0, 43, '\0');
 else
 draw(hw);
 }
 else {  /* Normal window */
 mpos = 0;
 /*
 * show:
 *      returns what a certain thing will display as to the un-initiated
 */
-show(y, x)
+char
-register int y, x;
+show(int y, int x)
 {
 register unsigned char ch = winat(y, x);
 register struct linked_list *it;
 register struct thing *tp;
 * trap_at:
 *      find the trap at (y,x) on screen.
 */
 struct trap *
-trap_at(y, x)
+trap_at(int y, int x)
-register int y, x;
 {
 register struct trap *tp, *ep;
 ep = &traps[ntraps];
 for (tp = traps; tp < ep; tp++)
 /*
 * weap_move:
 *      Calculate how many segments it will take to swing the given
 *      weapon (note that the weapon may actually be a stick or
 *      even something else).
+* wielder: Who's wielding the weapon
+* weap: The weapon
 */
-weap_move(wielder, weap)
+int
-register struct thing *wielder; /* Who's wielding the weapon */
+weap_move(struct thing *wielder, struct object *weap)
-register struct object *weap;   /* The weapon */
 {
 register int weap_rate;
 int          dexterity;
 int          strength;

Mercurial > hg > early-roguelike

comparison xrogue/move.c @ 220:f54901b9c39b