Early Roguelike Collection: arogue7/move.c comparison

comparison arogue7/move.c @ 219:f9ef86cf22b2

Advanced Rogue 7: convert to ANSI-style function declarations. Almost 1500 lines of compiler warnings remain, and the GCC developers are already working on a new version with even more warnings turned on by default.

author	John "Elwin" Edwards
date	Fri, 19 Feb 2016 21:02:28 -0500
parents	1cd604c827a3
children	e52a8a7ad4c5

comparison

equal deleted inserted replaced

-:56e748983fa8
+:f9ef86cf22b2
 *
 */
 #include "curses.h"
 #include <ctype.h>
+#include <string.h>
 #include "rogue.h"
 #ifdef PC7300
 #include "menu.h"
 #endif
 /*
 * 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 = "";
 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, locx;	/* 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 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;
 *	Takes a movement character (eg. h, j, k, l) and returns the
 *	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 y, x;
+int y, x;
 for (y = 0; y < 3; y++)
 	for (x = 0; x < 3; x++)
 	    if (Moves[y][x] == match) {
 		*dy = y - 1;
 /*
 * isatrap:
 *	Returns TRUE if this character is some kind of trap
 */
-isatrap(ch)
+bool
-reg char ch;
+isatrap(char ch)
 {
 	switch(ch) {
 		case DARTTRAP:
 		case TELTRAP:
 		case TRAPDOOR:
 /*
 * 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 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;
 static coord ret;  /* what we will be returning */
 static 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 char ch, 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 char ch = CCHAR( 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 arogue7/move.c @ 219:f9ef86cf22b2