Full ANSIfication with prototypes.

This seems to fix the core dump when a satellite bounced off the world edge,
What had been happening was that the bounce() gfunction was somehow getting
passed the unsigned ppositive values of the negative integer constants in its
actuals.

diff --git a/attack.c b/attack.c
index 7ffa41e6209890f3ce6b1219576d69850662311a..bce6f549b66e9b4c7f574cc1c2ba2b14b0fc64d9 100644 (file)
--- a/attack.c
+++ b/attack.c
@@ -27,9 +27,7 @@ if any.
 #include "extern.h"
 
 void
-attack_city (att_obj, loc)
-piece_info_t *att_obj;
-loc_t loc;
+attack_city(piece_info_t *att_obj, loc_t loc)
 {
        city_info_t *cityp;
        int att_owner, city_owner;
@@ -79,9 +77,7 @@ First we have to figure out what is being attacked.
 */
 
 void
-attack_obj (att_obj, loc)
-piece_info_t *att_obj;
-loc_t loc;
+attack_obj(piece_info_t *att_obj, loc_t loc)
 {
        void describe(), survive();
        
@@ -116,9 +112,7 @@ loc_t loc;
 }
 
 void
-attack (att_obj, loc)
-piece_info_t *att_obj;
-loc_t loc;
+attack(piece_info_t *att_obj, loc_t loc)
 {
        if (map[loc].contents == '*') /* attacking a city? */
                attack_city (att_obj, loc);
@@ -133,9 +127,7 @@ location.
 */
 
 void
-survive (obj, loc)
-piece_info_t *obj;
-loc_t loc;
+survive(piece_info_t *obj, loc_t loc)
 {
        while (obj_capacity (obj) < obj->count)
                kill_obj (obj->cargo, loc);
@@ -144,9 +136,7 @@ loc_t loc;
 }
 
 void
-describe (win_obj, lose_obj, loc)
-piece_info_t *win_obj, *lose_obj;
-loc_t loc;
+describe(piece_info_t *win_obj, piece_info_t *lose_obj, loc_t loc)
 {
        char buf[STRSIZE];
        char buf2[STRSIZE];

diff --git a/compmove.c b/compmove.c
index 1a9b627ebe0322ffdbaa5015e71a5971e1d06f79..cd4c99d21229ae1fedf947deadda263ebfda8a5b 100644 (file)
--- a/compmove.c
+++ b/compmove.c
@@ -30,7 +30,7 @@ int nearby_count( loc_t loc );
 void move_objective(piece_info_t *obj,path_map_t pathmap[],loc_t new_loc,char *adj_list);
 
 void
-comp_move (nmoves) 
+comp_move(nmoves) 
 int nmoves;
 {
        void do_cities(), do_pieces(), check_endgame();
@@ -77,7 +77,7 @@ build carriers, as we don't have a good strategy for moving these.
 */
 
 void
-do_cities () {
+do_cities(void) {
        void comp_prod();
        
        int i;
@@ -131,9 +131,7 @@ The algorithm below contains three parts:
 */
 
 void
-comp_prod (cityp, is_lake)
-city_info_t *cityp;
-int is_lake;
+comp_prod(city_info_t *cityp, int is_lake)
 {
        void comp_set_prod(), comp_set_needed();
        
@@ -262,9 +260,7 @@ reset production if it is already correct.
 */
 
 void
-comp_set_prod (cityp, type)
-city_info_t *cityp;
-int type;
+comp_set_prod(city_info_t *cityp, int type)
 {
        if (cityp->prod == type) return;
        
@@ -278,9 +274,7 @@ See if a city is producing an object which is being overproduced.
 */
 
 int
-overproduced (cityp, city_count)
-city_info_t *cityp;
-int *city_count;
+overproduced(city_info_t *cityp, int *city_count)
 {
        int i;
 
@@ -300,9 +294,7 @@ Return the most-needed type of production.
 */
 
 int
-need_more (city_count, prod1, prod2)
-int *city_count;
-int prod1, prod2;
+need_more(int *city_count, int prod1, int prod2)
 {
        if (city_count[prod1] * ratio[prod2]
                 <= city_count[prod2] * ratio[prod1])
@@ -317,11 +309,7 @@ a flag telling us if armies are ok to produce.
 */
 
 void
-comp_set_needed (cityp, city_count, army_ok, is_lake)
-city_info_t *cityp;
-int *city_count;
-int army_ok;
-int is_lake;
+comp_set_needed(city_info_t *cityp, int *city_count, int army_ok, int is_lake)
 {
        int best_prod;
        int prod;
@@ -355,8 +343,7 @@ have unexplored territory on the edges.
 */
 
 int
-lake (loc)
-loc_t loc;
+lake(loc_t loc)
 {
        int cont_map[MAP_SIZE];
        scan_counts_t counts;
@@ -375,7 +362,7 @@ static view_map_t amap[MAP_SIZE]; /* temp view map */
 static path_map_t path_map[MAP_SIZE];
 
 void
-do_pieces () { /* move pieces */
+do_pieces(void) { /* move pieces */
        void cpiece_move();
 
        int i;
@@ -397,8 +384,7 @@ objective.
 */
 
 void
-cpiece_move (obj)
-piece_info_t *obj;
+cpiece_move(piece_info_t *obj)
 {
        void move1();
 
@@ -450,8 +436,7 @@ Move a piece one square.
 */
 
 void
-move1 (obj)
-piece_info_t *obj;
+move1(piece_info_t *obj)
 {
        void army_move(), transport_move(), fighter_move(), ship_move();
 
@@ -493,8 +478,7 @@ destination.  (If there is no destination, sit around and wait.)
 */
 
 void
-army_move (obj)
-piece_info_t *obj;
+army_move(piece_info_t *obj)
 {
        loc_t move_away();
        loc_t find_attack();
@@ -577,8 +561,7 @@ Remove pruned explore locs from a view map.
 */
 
 void
-unmark_explore_locs (xmap)
-view_map_t *xmap;
+unmark_explore_locs(view_map_t *xmap)
 {
        count_t i;
 
@@ -593,10 +576,7 @@ transport and tt producing city with a '$'.
 */
 
 void
-make_army_load_map (obj, xmap, vmap)
-piece_info_t *obj;
-view_map_t *xmap;
-view_map_t *vmap;
+make_army_load_map(piece_info_t *obj, view_map_t *xmap, view_map_t *vmap)
 {
        piece_info_t *p;
        int i;
@@ -622,9 +602,7 @@ view_map_t *vmap;
 /* Return true if an army is considered near a location for loading. */
 
 int
-nearby_load (obj, loc)
-piece_info_t *obj;
-loc_t loc;
+nearby_load(piece_info_t *obj, loc_t loc)
 {
        return obj->func == 1 && dist (obj->loc, loc) <= 2;
 }
@@ -632,8 +610,7 @@ loc_t loc;
 /* Return number of nearby armies. */
 
 int
-nearby_count (loc)
-loc_t loc;
+nearby_count(loc_t loc)
 {
        piece_info_t *obj;
        int count;
@@ -648,9 +625,7 @@ loc_t loc;
 /* Make load map for a ship. */
 
 void
-make_tt_load_map (xmap, vmap)
-view_map_t *xmap;
-view_map_t *vmap;
+make_tt_load_map(view_map_t *xmap, view_map_t *vmap)
 {
        piece_info_t *p;
        
@@ -695,9 +670,7 @@ static int owncont_map[MAP_SIZE];
 static int tcont_map[MAP_SIZE];
 
 void
-make_unload_map (xmap, vmap)
-view_map_t *xmap;
-view_map_t *vmap;
+make_unload_map(view_map_t *xmap, view_map_t *vmap)
 {
        count_t i;
        scan_counts_t counts;
@@ -747,10 +720,7 @@ close to the ocean.
 */
 
 void
-board_ship (obj, pmap, dest)
-piece_info_t *obj;
-path_map_t *pmap;
-loc_t dest;
+board_ship(piece_info_t *obj, path_map_t *pmap, loc_t dest)
 {
        if (!load_army (obj)) {
                obj->func = 1; /* loading */
@@ -765,9 +735,7 @@ one of the ships to become more full.
 */
 
 piece_info_t *
-find_best_tt (best, loc)
-piece_info_t *best;
-loc_t loc;
+find_best_tt(piece_info_t *best, loc_t loc)
 {
        piece_info_t *p;
 
@@ -784,8 +752,7 @@ Load an army onto the most full non-full ship.
 */
 
 int
-load_army (obj)
-piece_info_t *obj;
+load_army(piece_info_t *obj)
 {
        piece_info_t *p;
        int i;
@@ -819,10 +786,7 @@ the correct terrain.
 */
 
 loc_t
-move_away (vmap, loc, terrain)
-view_map_t *vmap;
-loc_t loc;
-char *terrain;
+move_away(view_map_t *vmap, loc_t loc, char *terrain)
 {
        loc_t new_loc;
        int i;
@@ -845,10 +809,7 @@ best of these.
 */
 
 loc_t
-find_attack (loc, obj_list, terrain)
-loc_t loc;
-char *obj_list;
-char *terrain;
+find_attack(loc_t loc, char *obj_list, char *terrain)
 {
        loc_t new_loc, best_loc;
        int i, best_val;
@@ -884,8 +845,7 @@ Transports become 'loading' when empty, and 'unloading' when full.
 */
 
 void
-transport_move (obj)
-piece_info_t *obj;
+transport_move(piece_info_t *obj)
 {
        void tt_do_move();
 
@@ -937,8 +897,7 @@ if there is one in range.
 */
 
 void
-fighter_move (obj)
-piece_info_t *obj;
+fighter_move(piece_info_t *obj)
 {
        loc_t new_loc;
 
@@ -970,8 +929,7 @@ something to attack.
 */
 
 void
-ship_move (obj)
-piece_info_t *obj;
+ship_move(piece_info_t *obj)
 {
        loc_t new_loc;
        char *adj_list;
@@ -1008,11 +966,8 @@ Move to an objective.
 */
 
 void
-move_objective (obj, pathmap, new_loc, adj_list)
-piece_info_t *obj;
-path_map_t pathmap[];
-loc_t new_loc;
-char *adj_list;
+move_objective(piece_info_t *obj, path_map_t pathmap[], 
+               loc_t new_loc, char *adj_list)
 {
        char *terrain;
        char *attack_list;
@@ -1119,7 +1074,7 @@ and armies as the user, then the computer will give up.
 */
 
 void
-check_endgame () { /* see if game is over */
+check_endgame(void) { /* see if game is over */
 
        int nuser_city, ncomp_city;
        int nuser_army, ncomp_army;

diff --git a/display.c b/display.c
index 78c36a0c9a5127f484251d80664687f320342087..0970c580d7043ec0852a6f29ffb9a56d7b183a7c 100644 (file)
--- a/display.c
+++ b/display.c
@@ -62,8 +62,7 @@ void announce (char *msg) {
  * Map input character to direction offset.
  * Attempts to enable arrow and keypad keys.
  */
-int direction(c)
-chtype c;
+int direction(chtype c)
 {
     switch (c)
     {
@@ -164,10 +163,8 @@ redisplay the sector, or if the location is not on the screen.
 */
 
 void
-display_loc (whose, vmap, loc)
-int whose; /* whose map to display */
-view_map_t vmap[];
-loc_t loc; /* location to display */
+display_loc (int whose, view_map_t vmap[], loc_t loc)
+/* whose is whose map to display; loc is location to display */
 {
        if (change_ok || whose != whose_map || !on_screen (loc))
                print_sector (whose, vmap, loc_sector (loc));
@@ -180,10 +177,8 @@ Display a location iff the location is on the screen.
 */
 
 void
-display_locx (whose, vmap, loc)
-int whose; /* whose map to display */
-view_map_t vmap[];
-loc_t loc; /* location to display */
+display_locx (int whose, view_map_t vmap[], loc_t loc)
+/* whose is whose map to display; loc is location to display */
 {
        if (whose == whose_map && on_screen (loc))
                show_loc (vmap, loc);
@@ -194,9 +189,7 @@ Display a location which exists on the screen.
 */
 
 void
-show_loc (vmap, loc)
-view_map_t vmap[];
-loc_t loc;
+show_loc (view_map_t vmap[], loc_t loc)
 {
        int r, c;
        
@@ -228,10 +221,8 @@ screen.
 */
  
 void
-print_sector (whose, vmap, sector)
-char whose; /* USER or COMP */
-view_map_t vmap[]; /* map to display */
-int sector; /* sector to display */
+print_sector(int whose, view_map_t vmap[], int sector)
+/* whose is USER or COMP, vmap is map to display, sector is sector to display */
 {
        void display_screen();
 
@@ -309,8 +300,7 @@ pretty.
 */
 
 
-static void disp_square(vp)
-view_map_t *vp;
+static void disp_square(view_map_t *vp)
 {
 #ifdef A_COLOR
        chtype attr;
@@ -353,8 +343,7 @@ view_map_t *vp;
 Display the portion of the map that appears on the screen.
 */
 
-void display_screen (vmap)
-view_map_t vmap[];
+void display_screen(view_map_t vmap[])
 {
        int display_rows, display_cols;
        int r, c;
@@ -378,9 +367,8 @@ We display the cursor on the screen, if possible.
 */
 
 int
-move_cursor (cursor, offset)
-loc_t *cursor; /* current cursor position */
-int offset; /* offset to add to cursor */
+move_cursor(loc_t *cursor, int offset)
+/* cursor is current cursor position, offset is offset to add to cursor */
 {
        loc_t t;
        int r, c;
@@ -403,8 +391,7 @@ int offset; /* offset to add to cursor */
 See if a location is displayed on the screen.
 */
 
-int on_screen (loc)
-loc_t loc;
+int on_screen (loc_t loc)
 {
        int new_r, new_c;
        
@@ -423,8 +410,7 @@ loc_t loc;
 /* Print a view map for debugging. */
 
 void
-print_xzoom (vmap)
-view_map_t *vmap;
+print_xzoom(view_map_t *vmap)
 {
        print_zoom (vmap);
 #if 0
@@ -440,8 +426,7 @@ Print a condensed version of the map.
 char zoom_list[] = "XO*tcbsdpfaTCBSDPFAzZ+. ";
 
 void
-print_zoom (vmap)
-view_map_t *vmap;
+print_zoom(view_map_t *vmap)
 {
        void print_zoom_cell ();
 
@@ -467,10 +452,8 @@ Print a single cell in condensed format.
 */
 
 void
-print_zoom_cell (vmap, row, col, row_inc, col_inc)
-view_map_t *vmap;
-int row, col;
-int row_inc, col_inc;
+print_zoom_cell(view_map_t *vmap, 
+                int row, int col, int row_inc, int col_inc)
 {
        int r, c;
        char cell;
@@ -491,10 +474,7 @@ Print a condensed version of a pathmap.
 */
 
 void
-print_pzoom (s, pmap, vmap)
-char *s;
-path_map_t *pmap;
-view_map_t *vmap;
+print_pzoom(char *s, path_map_t *pmap, view_map_t *vmap)
 {
        void print_pzoom_cell();
 
@@ -526,11 +506,8 @@ between P and Z are printed as U.
 */
 
 void
-print_pzoom_cell (pmap, vmap, row, col, row_inc, col_inc)
-path_map_t *pmap;
-view_map_t *vmap;
-int row, col;
-int row_inc, col_inc;
+print_pzoom_cell(path_map_t *pmap, view_map_t *vmap, 
+                 int row, int col, int row_inc, int col_inc)
 {
        int r, c;
        int sum, d;
@@ -570,7 +547,7 @@ Display the score off in the corner of the screen.
 */
 
 void
-display_score (void)
+display_score(void)
 {
        pos_str (1, cols-12, " User  Comp",0,0,0,0,0,0,0,0);
        pos_str (2, cols-12, "%5d %5d", user_score, comp_score,0,0,0,0,0,0);
@@ -581,8 +558,7 @@ Clear the end of a specified line starting at the specified column.
 */
 
 void
-clreol(linep, colp)
-int linep, colp;
+clreol(int linep, int colp)
 {
        (void) move (linep, colp);
        (void) clrtoeol();
@@ -616,7 +592,8 @@ display.
 */
 
 void
-clear_screen (void) {
+clear_screen(void)
+{
        (void) clear ();
        (void) refresh ();
        kill_display ();
@@ -627,12 +604,14 @@ Redraw the screen.
 */
 
 void 
-redisplay (void) {
+redisplay(void)
+{
        (void) refresh ();
 }
 
 void
-redraw (void) {
+redraw(void)
+{
        (void) clearok (curscr, TRUE);
        (void) refresh ();
 }
@@ -643,7 +622,8 @@ the screen and pause for a few milliseconds.
 */
 
 void
-delay (void) {
+delay(void)
+{
         int t = delay_time;
         int i = 500;
        (void) refresh ();
@@ -677,19 +657,16 @@ Position the cursor and output a string.
 */
 
 void
-pos_str1 (row, col, str, a, b, c, d, e, f, g, h)
-int row, col;
-char *str, *a;
-int b, c, d, e, f, g, h;
+pos_str1(int row, int col, char *str, char *a, 
+         int b, int c, int d, int e, int f, int g, int h)
 {
        (void) move (row, col);
        addprintf1 (str, a, b, c, d, e, f, g, h);
 }
+
 void
-pos_str (row, col, str, a, b, c, d, e, f, g, h)
-int row, col;
-char *str;
-int a, b, c, d, e, f, g, h;
+pos_str(int row, int col, char *str, 
+       int a, int b, int c, int d, int e, int f, int g, int h)
 {
        (void) move (row, col);
        addprintf (str, a, b, c, d, e, f, g, h);
@@ -697,9 +674,7 @@ int a, b, c, d, e, f, g, h;
 
 void
 /* VARARGS1 */
-addprintf (str, a, b, c, d, e, f, g, h)
-char *str;
-int a, b, c, d, e, f, g, h;
+addprintf(char *str, int a, int b, int c, int d, int e, int f, int g, int h)
 {
        char junkbuf[STRSIZE];
        
@@ -708,22 +683,17 @@ int a, b, c, d, e, f, g, h;
 }
 void
 /* VARARGS1 */
-addprintf1 (str, a, b, c, d, e, f, g, h)
-char *str;
-char *a;
-int b, c, d, e, f, g, h;
+addprintf1(char *str, char *a, int b, int c, int d, int e, int f, int g, int h)
 {
        char junkbuf[STRSIZE];
        
        (void) sprintf (junkbuf, str, a, b, c, d, e, f, g, h);
        (void) addstr (junkbuf);
 }
+
 void
 /* VARARGS1 */
-addprintf2 (str, a, b, c, d, e, f, g, h)
-char *str;
-char *a, *e, *f;
-int b, c, d, g, h;
+addprintf2(char *str, char *a, int b, int c, int d, char *e, char *f, int g, int h)
 {
        char junkbuf[STRSIZE];
        
@@ -738,10 +708,7 @@ Print a single cell in condensed format.
 extern char zoom_list[];
 
 void
-print_movie_cell (mbuf, row, col, row_inc, col_inc)
-char *mbuf;
-int row, col;
-int row_inc, col_inc;
+print_movie_cell(char *mbuf, int row, int col, int row_inc, int col_inc)
 {
        int r, c;
        char cell;

diff --git a/edit.c b/edit.c
index 047c9fffa558ae9c5d464432455e2936c13df592..5106e5eb385197bb55f6e49d8b6835d8cf030637 100644 (file)
--- a/edit.c
+++ b/edit.c
@@ -20,8 +20,7 @@ void e_move(loc_t *path_start, loc_t loc);
 extern int get_piece_name(void);
 
 void
-edit(edit_cursor)
-loc_t edit_cursor;
+edit(loc_t edit_cursor)
 {
        char e_cursor();
        void e_leave(), e_print(), e_random();
@@ -113,8 +112,7 @@ fast.
 */
 
 char
-e_cursor (edit_cursor)
-loc_t *edit_cursor;
+e_cursor(loc_t *edit_cursor)
 {
        chtype e;
        int p;
@@ -145,7 +143,7 @@ Leave edit mode.
 */
 
 void
-e_leave (void) {
+e_leave(void) {
 }
 
 /*
@@ -153,8 +151,7 @@ Print new sector.
 */
 
 void
-e_print (edit_cursor)
-loc_t *edit_cursor;
+e_print(loc_t *edit_cursor)
 {
         int sector;
        
@@ -170,9 +167,7 @@ Set the function of a piece.
 */
 
 void
-e_set_func (loc, func)
-loc_t loc;
-long func;
+e_set_func(loc_t loc, long func)
 {
        piece_info_t *obj;
        obj = find_obj_at_loc (loc);
@@ -186,10 +181,7 @@ long func;
 /* Set the function of a city for some piece. */
 
 void
-e_set_city_func (cityp, type, func)
-city_info_t *cityp;
-int type;
-long func;
+e_set_city_func(city_info_t *cityp, int type, long func)
 {
        cityp->func[type] = func;
 }
@@ -199,16 +191,13 @@ Set a piece to move randomly.
 */
 
 void
-e_random (loc)
-loc_t loc;
+e_random(loc_t loc)
 {
        e_set_func (loc, RANDOM);
 }
 
 void
-e_city_random (cityp, type)
-city_info_t *cityp;
-int type;
+e_city_random(city_info_t *cityp, int type)
 {
        e_set_city_func (cityp, type, RANDOM);
 }
@@ -218,8 +207,7 @@ Put a ship in fill mode.
 */
 
 void
-e_fill (loc)
-loc_t loc;
+e_fill(loc_t loc)
 {
        if (user_map[loc].contents == 'T' || user_map[loc].contents == 'C')
                e_set_func (loc, FILL);
@@ -227,9 +215,7 @@ loc_t loc;
 }
 
 void
-e_city_fill (cityp, type)
-city_info_t *cityp;
-int type;
+e_city_fill(city_info_t *cityp, int type)
 {
        if (type == TRANSPORT || type == CARRIER)
                e_set_city_func (cityp, type, FILL);
@@ -241,16 +227,13 @@ Set a piece to explore.
 */
 
 void
-e_explore (loc)
-loc_t loc;
+e_explore(loc_t loc)
 {
        e_set_func (loc, EXPLORE);
 }
 
 void
-e_city_explore (cityp, type)
-city_info_t *cityp;
-int type;
+e_city_explore(city_info_t *cityp, loc_t type)
 {
        e_set_city_func (cityp, type, EXPLORE);
 }
@@ -260,20 +243,19 @@ Set a fighter to land.
 */
 
 void
-e_land (loc)
-loc_t loc;
+e_land(loc_t loc)
 {
        if (user_map[loc].contents == 'F')
                e_set_func (loc, LAND);
        else huh ();
 }
+
 /*
 Set an army's function to TRANSPORT.
 */
 
 void
-e_transport (loc)
-loc_t loc;
+e_transport(loc_t loc)
 {
        if (user_map[loc].contents == 'A')
                e_set_func (loc, WFTRANSPORT);
@@ -285,8 +267,7 @@ Set an army's function to ATTACK.
 */
 
 void
-e_attack (loc)
-loc_t loc;
+e_attack(loc_t loc)
 {
        if (user_map[loc].contents == 'A')
                e_set_func (loc, ARMYATTACK);
@@ -294,9 +275,7 @@ loc_t loc;
 }
 
 void
-e_city_attack (cityp, type)
-city_info_t *cityp;
-int type;
+e_city_attack(city_info_t *cityp, int type)
 {
        if (type == ARMY)
                e_set_city_func (cityp, type, ARMYATTACK);
@@ -308,8 +287,7 @@ Set a ship's function to REPAIR.
 */
 
 void
-e_repair (loc)
-loc_t loc;
+e_repair(loc_t loc)
 {
        if (strchr ("PDSTBC", user_map[loc].contents))
                e_set_func (loc, REPAIR);
@@ -317,9 +295,7 @@ loc_t loc;
 }
 
 void
-e_city_repair (cityp, type)
-city_info_t *cityp;
-int type;
+e_city_repair(city_info_t *cityp, int type)
 {
        if (type == ARMY || type == FIGHTER || type == SATELLITE)
                huh ();
@@ -333,8 +309,7 @@ Set object to move in a direction.
 static char dirs[] = "WEDCXZAQ";
  
 void
-e_stasis (loc)
-loc_t loc;
+e_stasis(loc_t loc)
 {
        char e;
        char *p;
@@ -351,9 +326,7 @@ loc_t loc;
 }
 
 void
-e_city_stasis (cityp, type)
-city_info_t *cityp;
-int type;
+e_city_stasis(city_info_t *cityp, int type)
 {
        char e;
        char *p;
@@ -370,8 +343,7 @@ Wake up anything and everything.
 */
 
 void
-e_wake (loc)
-loc_t loc;
+e_wake(loc_t loc)
 {
        city_info_t *cityp;
        piece_info_t *obj;
@@ -387,9 +359,7 @@ loc_t loc;
 }
 
 void
-e_city_wake (cityp, type)
-city_info_t *cityp;
-int type;
+e_city_wake(city_info_t *cityp, int type)
 {
        e_set_city_func (cityp, type, NOFUNC);
 }
@@ -400,10 +370,7 @@ the function itself.
 */
 
 void
-e_city_func (path_start, loc, path_type)
-loc_t *path_start;
-loc_t loc;
-int *path_type;
+e_city_func(loc_t *path_start, loc_t loc, int *path_type)
 {
        int type;
        char e;
@@ -460,9 +427,7 @@ Beginning of move to location.
 */
 
 void
-e_move (path_start, loc)
-loc_t *path_start;
-loc_t loc;
+e_move(loc_t *path_start, loc_t loc)
 {
        if (!isupper(user_map[loc].contents)) huh (); /* nothing there? */
        else if (user_map[loc].contents == 'X') huh (); /* enemy city? */
@@ -474,10 +439,7 @@ End of move to location.
 */
 
 void
-e_end (path_start, loc, path_type)
-loc_t *path_start;
-loc_t loc;
-int path_type;
+e_end(loc_t *path_start, loc_t loc, int path_type)
 {
        city_info_t *cityp;
        
@@ -497,8 +459,7 @@ Put a piece to sleep.
 */
 
 void
-e_sleep (loc)
-loc_t loc;
+e_sleep(loc_t loc)
 {
        if (user_map[loc].contents == 'O') huh (); /* can't sleep a city */
        else e_set_func (loc, SENTRY);
@@ -509,10 +470,9 @@ Print out information about a piece.
 */
 
 void
-e_info (edit_cursor)
-loc_t edit_cursor;
+e_info(loc_t edit_cursor)
 {
-       void e_city_info(), e_piece_info();
+       void e_city_info(loc_t), e_piece_info(loc_t edit_cursor, char ab);
 
        char ab;
 
@@ -532,9 +492,7 @@ Print info about a piece.
 */
 
 void
-e_piece_info (edit_cursor, ab)
-loc_t edit_cursor;
-char ab;
+e_piece_info(loc_t edit_cursor, char ab)
 {
        piece_info_t *obj;
        int type;
@@ -554,8 +512,7 @@ Display info on a city.
 */
 
 void
-e_city_info (edit_cursor)
-loc_t edit_cursor;
+e_city_info(loc_t edit_cursor)
 {
        piece_info_t *obj;
        city_info_t *cityp;
@@ -614,8 +571,7 @@ Change city production.
 */
 
 void
-e_prod (loc)
-loc_t loc;
+e_prod(loc_t loc)
 {
        city_info_t *cityp;
        
@@ -630,7 +586,7 @@ get help
 */
 
 void
-e_help (void) {
+e_help(void) {
        help (help_edit, edit_lines);
        prompt ("Press any key to continue: ",0,0,0,0,0,0,0,0);
        (void) get_chx ();

diff --git a/empire.c b/empire.c
index 99c6f0c3db08aa35909ca1f12d6436feb158c81d..ca51828ae29dd179add6e7fcd1d0740a054c3a0d 100644 (file)
--- a/empire.c
+++ b/empire.c
@@ -26,8 +26,8 @@ void c_examine(void), c_movie(void);
  */
 
 void
-empire (void) {
-       void do_command();
+empire(void) {
+       void do_command(char);
        void print_zoom();
 
        char order;
@@ -68,10 +68,9 @@ Execute a command.
 */
 
 void
-do_command (orders)
-char orders;
+do_command(char orders)
 {
-       void c_debug(), c_quit(void), c_sector(void), c_map(void);
+       void c_debug(char order), c_quit(void), c_sector(void), c_map(void);
        void c_give(void);
 
        char e;
@@ -188,7 +187,7 @@ it as the computers.
 */
 
 void
-c_give () {
+c_give(void) {
        int unowned[NUM_CITY];
        count_t i, count;
 
@@ -218,8 +217,7 @@ The order cannot be any legal command.
 */
 
 void
-c_debug (order)
-char order;
+c_debug(char order)
 {
        char e;
 
@@ -254,7 +252,7 @@ The quit command.  Make sure the user really wants to quit.
 */
 
 void
-c_quit (void) {
+c_quit(void) {
        if (getyn ("QUIT - Are you sure? ")) {
            empend ();
        }
@@ -266,7 +264,7 @@ and print it.
 */
 
 void
-c_sector (void) {
+c_sector(void) {
        int num;
 
        num = get_range ("Sector number? ", 0, NUM_SECTORS-1);
@@ -281,7 +279,7 @@ out the map.
 */
 
 void
-c_map (void) {
+c_map(void) {
        FILE *f;
        int i, j;
        char line[MAP_HEIGHT+2];
@@ -314,7 +312,7 @@ Allow user to examine the computer's map.
 */
 
 void
-c_examine (void) {
+c_examine(void) {
        int num;
 
        num = get_range ("Sector number? ", 0, NUM_SECTORS-1);
@@ -327,7 +325,7 @@ Print a "zoomed" version of the computer's map.
 */
 
 void
-c_movie (void) {
+c_movie(void) {
        for (;;) {
                comp_move (1);
                print_zoom (comp_map);

diff --git a/game.c b/game.c
index ae747ce5d014aaa624e6f30e43864f8316242e1a..77ba1b5bd77d6169fe909220a8d842ca37ad320e 100644 (file)
--- a/game.c
+++ b/game.c
@@ -31,7 +31,7 @@ on the map, select cities for each opponent, and zero out the lists of
 pieces on the board.
 */
 
-void init_game (void) {
+void init_game(void) {
        void make_map(void), place_cities(void);
 
        count_t i;
@@ -96,7 +96,7 @@ at program start up.
 static int height[2][MAP_SIZE];
 static int height_count[MAX_HEIGHT+1];
 
-void make_map (void) {
+void make_map(void) {
        int from, to, k;
        count_t i, j, sum;
        loc_t loc;
@@ -168,7 +168,7 @@ for a city, we remove land cells which are too close to the city.
 /* avoid compiler problems with large automatic arrays */
 static loc_t land[MAP_SIZE];
 
-void place_cities (void) {
+void place_cities(void) {
        count_t regen_land();
 
        count_t placed, i;
@@ -205,8 +205,7 @@ put all land in the list, decrement the min_city_dist, and then
 remove any land which is too close to a city.
 */
 
-count_t regen_land (placed)
-count_t placed;
+count_t regen_land(count_t placed)
 {
        count_t num_land;
        count_t i;
@@ -232,9 +231,7 @@ count_t placed;
 Remove land that is too close to a city.
 */
 
-count_t remove_land (loc, num_land)
-loc_t loc;
-count_t num_land;
+count_t remove_land(loc_t loc, count_t num_land)
 {
        count_t new, i;
 
@@ -298,7 +295,7 @@ static cont_t cont_tab[MAX_CONT]; /* list of good continenets */
 static int rank_tab[MAX_CONT]; /* indices to cont_tab in order of rank */
 static pair_t pair_tab[MAX_CONT*MAX_CONT]; /* ranked pairs of continents */
 
-int select_cities (void) {
+int select_cities(void) {
        void find_cont(void), make_pair(void);
 
        loc_t compi, useri;
@@ -348,7 +345,7 @@ Find all continents with 2 cities or more, one of which must be a shore
 city.  We rank the continents.
 */
 
-void find_cont (void) {
+void find_cont(void) {
        loc_t i;
        loc_t mapi;
 
@@ -366,8 +363,7 @@ Find the next continent and insert it in the rank table.
 If there are no more continents, we return false.
 */
 
-int find_next (mapi)
-loc_t *mapi;
+int find_next(loc_t *mapi)
 {
        count_t i;
        long val;
@@ -404,8 +400,7 @@ continent and return true.  Otherwise we return false.
 static count_t ncity, nland, nshore;
 static void mark_cont(loc_t);
 
-int good_cont (mapi)
-loc_t mapi;
+int good_cont(loc_t mapi)
 {
        long val;
 
@@ -440,8 +435,7 @@ cities for the continent.  We then examine each surrounding cell.
 */
 
 static void
-mark_cont (mapi)
-loc_t mapi;
+mark_cont(loc_t mapi)
 {
        int i;
 
@@ -468,7 +462,7 @@ win with.  Our ranking is simply based on the difference in value
 between the user's continent and the computer's continent.
 */
 
-void make_pair (void) {
+void make_pair(void) {
        int i, j, k, npair;
        long val;
 
@@ -503,7 +497,7 @@ tell the user why.
 #define wbuf(buf) if (!xwrite (f, (char *)buf, sizeof (buf))) return
 #define wval(val) if (!xwrite (f, (char *)&val, sizeof (val))) return
 
-void save_game (void) {
+void save_game(void) {
        FILE *f; /* file to save game in */
 
        f = fopen (savefile, "w"); /* open for output */
@@ -540,7 +534,7 @@ We return TRUE if we succeed, otherwise FALSE.
 #define rbuf(buf) if (!xread (f, (char *)buf, sizeof(buf))) return (FALSE);
 #define rval(val) if (!xread (f, (char *)&val, sizeof(val))) return (FALSE);
 
-int restore_game (void) {
+int restore_game(void) {
        void read_embark();
        
        FILE *f; /* file to save game in */
@@ -627,9 +621,7 @@ We then loop through the pieces at the ship's location until
 the ship has the same amount of cargo it previously had.
 */
 
-void read_embark (list, piece_type)
-piece_info_t *list;
-int piece_type;
+void read_embark(piece_info_t *list, int piece_type)
 {
        void inconsistent(void);
 
@@ -652,7 +644,7 @@ int piece_type;
        }
 }
 
-void inconsistent (void) {
+void inconsistent(void) {
        (void) printf ("saved game is inconsistent.  Please remove it.\n");
        exit (1);
 }
@@ -662,10 +654,7 @@ Write a buffer to a file.  If we cannot write everything, return FALSE.
 Also, tell the user why the write did not work if it didn't.
 */
 
-int xwrite (f, buf, size)
-FILE *f;
-char *buf;
-int size;
+int xwrite(FILE *f, char *buf, int size)
 {
        int bytes;
  
@@ -686,10 +675,7 @@ Read a buffer from a file.  If the read fails, we tell the user why
 and return FALSE.
 */
 
-int xread (f, buf, size)
-FILE *f;
-char *buf;
-int size;
+int xread(FILE *f, char *buf, int size)
 {
        int bytes;
 
@@ -715,7 +701,7 @@ extern char city_char[];
 static char mapbuf[MAP_SIZE];
 
 void
-save_movie_screen (void)
+save_movie_screen(void)
 {
        FILE *f; /* file to save game in */
        count_t i;
@@ -748,7 +734,7 @@ print it using a zoomed display.
 */
 
 void
-replay_movie (void)
+replay_movie(void)
 {
        void print_movie_cell();
 
@@ -798,9 +784,7 @@ The "xxxxx" field is the cumulative cost of building the hardware.
 /* in declared order, with city first */
 static char *pieces = "OAFPDSTCBZXafpdstcbz";
 
-void stat_display (mbuf, round)
-char *mbuf;
-int round;
+void stat_display(char *mbuf, int round)
 {
        count_t i;
        int counts[2*NUM_OBJECTS+2];

diff --git a/main.c b/main.c
index aee294a7df25344b325a1963e3ea9f0083b3d162..5d5df20fcbf598413fe63f2c673d73ea4f9e3f17 100644 (file)
--- a/main.c
+++ b/main.c
@@ -31,7 +31,7 @@ options:
 
 #define OPTFLAGS "w:s:d:S:f:"
 
-int main (argc, argv)
+int main(argc, argv)
 int argc;
 char *argv[];
 {

diff --git a/map.c b/map.c
index a35ef53ffc4b6984268dd5e0038341a6f61b1dab..5163dad4b67d44d40495008b0672cdfaff15c4dd 100644 (file)
--- a/map.c
+++ b/map.c
@@ -53,11 +53,7 @@ or lakes.
 */
 
 void
-vmap_cont (cont_map, vmap, loc, bad_terrain)
-int *cont_map;
-view_map_t *vmap;
-loc_t loc;
-char bad_terrain;
+vmap_cont (int *cont_map, view_map_t *vmap, loc_t loc, char bad_terrain)
 {
        (void) bzero ((char *)cont_map, MAP_SIZE * sizeof (int));
        vmap_mark_up_cont (cont_map, vmap, loc, bad_terrain);
@@ -70,11 +66,7 @@ known to be either on the continent or adjacent to the continent.
 */
 
 void
-vmap_mark_up_cont (cont_map, vmap, loc, bad_terrain)
-int *cont_map;
-view_map_t *vmap;
-loc_t loc;
-char bad_terrain;
+vmap_mark_up_cont (int *cont_map, view_map_t *vmap, loc_t loc, char bad_terrain)
 {
        int i, j;
        loc_t new_loc;
@@ -121,13 +113,10 @@ By adjusting the value of
 or lakes.
 */
 
-static void rmap_mark_up_cont();
+static void rmap_mark_up_cont(int *cont_map, loc_t loc, char bad_terrain);
 
 void
-rmap_cont (cont_map, loc, bad_terrain)
-int *cont_map;
-loc_t loc;
-char bad_terrain;
+rmap_cont (int *cont_map, loc_t loc, char bad_terrain)
 {
        (void) bzero ((char *)cont_map, MAP_SIZE * sizeof (int));
        rmap_mark_up_cont (cont_map, loc, bad_terrain);
@@ -142,10 +131,7 @@ Someday this should be tweaked to use perimeter lists.
 */
 
 static void
-rmap_mark_up_cont (cont_map, loc, bad_terrain)
-int *cont_map;
-loc_t loc;
-char bad_terrain;
+rmap_mark_up_cont (int *cont_map, loc_t loc, char bad_terrain)
 {
        int i;
        loc_t new_loc;
@@ -169,9 +155,7 @@ This could be done as we mark up the continent.
 #define COUNT(c,item) case c: item += 1; break
 
 scan_counts_t
-vmap_cont_scan (cont_map, vmap)
-int *cont_map;
-view_map_t *vmap;
+vmap_cont_scan (int *cont_map, view_map_t *vmap)
 {
        scan_counts_t counts;
        count_t i;
@@ -225,8 +209,7 @@ fields are valid.
 */
 
 scan_counts_t
-rmap_cont_scan (cont_map)
-int *cont_map;
+rmap_cont_scan (int *cont_map)
 {
        scan_counts_t counts;
        count_t i;
@@ -248,9 +231,7 @@ Return TRUE if a location is on the edge of a continent.
 */
 
 int
-map_cont_edge (cont_map, loc)
-int *cont_map;
-loc_t loc;
+map_cont_edge (int *cont_map, loc_t loc)
 {
        loc_t i, j;
 
@@ -295,13 +276,8 @@ the information must be consistent with the needs of 'vmap_mark_path'.
 /* Find an objective over a single type of terrain. */
 
 loc_t
-vmap_find_xobj (path_map, vmap, loc, move_info, start, expand)
-path_map_t path_map[];
-view_map_t *vmap;
-loc_t loc;
-move_info_t *move_info;
-int start;
-int expand;
+vmap_find_xobj (path_map_t path_map[], view_map_t *vmap, 
+               loc_t loc, move_info_t *move_info, int start, int expand)
 {
        perimeter_t *from;
        perimeter_t *to;
@@ -332,11 +308,8 @@ int expand;
 /* Find an objective for a piece that crosses land and water. */
 
 loc_t
-vmap_find_aobj (path_map, vmap, loc, move_info)
-path_map_t path_map[];
-view_map_t *vmap;
-loc_t loc;
-move_info_t *move_info;
+vmap_find_aobj (path_map_t path_map[], view_map_t *vmap, 
+               loc_t loc, move_info_t *move_info)
 {
        return vmap_find_xobj (path_map, vmap, loc, move_info, T_LAND, T_AIR);
 }
@@ -344,11 +317,8 @@ move_info_t *move_info;
 /* Find an objective for a piece that crosses only water. */
 
 loc_t
-vmap_find_wobj (path_map, vmap, loc, move_info)
-path_map_t path_map[];
-view_map_t *vmap;
-loc_t loc;
-move_info_t *move_info;
+vmap_find_wobj (path_map_t path_map[], view_map_t *vmap, 
+               loc_t loc, move_info_t *move_info)
 {
        return vmap_find_xobj (path_map, vmap, loc, move_info, T_WATER, T_WATER);
 }
@@ -356,11 +326,8 @@ move_info_t *move_info;
 /* Find an objective for a piece that crosses only land. */
 
 loc_t
-vmap_find_lobj (path_map, vmap, loc, move_info)
-path_map_t path_map[];
-view_map_t *vmap;
-loc_t loc;
-move_info_t *move_info;
+vmap_find_lobj (path_map_t path_map[], view_map_t *vmap, 
+               loc_t loc, move_info_t *move_info)
 {
        return vmap_find_xobj (path_map, vmap, loc, move_info, T_LAND, T_LAND);
 }
@@ -378,12 +345,8 @@ is being approached from the land or the water.
 */
 
 loc_t
-vmap_find_lwobj (path_map, vmap, loc, move_info, beat_cost)
-path_map_t path_map[];
-view_map_t *vmap;
-loc_t loc;
-move_info_t *move_info;
-int beat_cost;
+vmap_find_lwobj (path_map_t path_map[], view_map_t *vmap, 
+                loc_t loc, move_info_t *move_info, int beat_cost)
 {
        perimeter_t *cur_land;
        perimeter_t *cur_water;
@@ -436,10 +399,7 @@ with the lowest cost.
 */
 
 STATIC int
-best_adj (pmap, loc, type)
-path_map_t *pmap;
-loc_t loc;
-int type;
+best_adj (path_map_t *pmap, loc_t loc, int type)
 {
        int i;
        loc_t new_loc;
@@ -467,11 +427,8 @@ but the second time, we only expand water (tt taking its second move).
 */
 
 loc_t
-vmap_find_wlobj (path_map, vmap, loc, move_info)
-path_map_t path_map[];
-view_map_t *vmap;
-loc_t loc;
-move_info_t *move_info;
+vmap_find_wlobj (path_map_t path_map[], view_map_t *vmap, 
+                loc_t loc, move_info_t *move_info)
 {
        perimeter_t *cur_land;
        perimeter_t *cur_water;
@@ -527,11 +484,7 @@ static path_map_t pmap_init[MAP_SIZE];
 static int init_done = 0;
 
 STATIC void
-start_perimeter (pmap, perim, loc, terrain)
-path_map_t *pmap;
-perimeter_t *perim;
-loc_t loc;
-int terrain;
+start_perimeter (path_map_t *pmap, perimeter_t *perim, loc_t loc, int terrain)
 {
        int i;
        
@@ -573,17 +526,19 @@ We set the cost to reach the current perimeter.
 */
 
 STATIC void
-expand_perimeter (pmap, vmap, move_info, curp, type, cur_cost, inc_wcost, inc_lcost, waterp, landp)
-path_map_t *pmap; /* path map to update */
-view_map_t *vmap;
-move_info_t *move_info; /* objectives and weights */
-perimeter_t *curp; /* perimeter to expand */
-int type; /* type of terrain to expand */
-int cur_cost; /* cost to reach cells on perimeter */
-int inc_wcost; /* cost to enter new water cells */
-int inc_lcost; /* cost to enter new land cells */
-perimeter_t *waterp; /* pointer to new water perimeter */
-perimeter_t *landp; /* pointer to new land perimeter */
+expand_perimeter (path_map_t *pmap, view_map_t *vmap, move_info_t *move_info, 
+                 perimeter_t *curp, 
+                 int type, int cur_cost, int inc_wcost, int inc_lcost, 
+                 perimeter_t *waterp, perimeter_t *landp)
+/* pmap = path map to update */
+/* move_info = objectives and weights */
+/* curp = perimeter to expand */
+/* type = type of terrain to expand */
+/* cur_cost = cost to reach cells on perimeter */
+/* inc_wcost = cost to enter new water cells */
+/* inc_lcost = cost to enter new land cells */
+/* waterp = pointer to new water perimeter */
+/* landp = pointer to new land perimeter */
 {
        register long i;
        register int j;
@@ -625,13 +580,8 @@ perimeter_t *landp; /* pointer to new land perimeter */
 /* Add a cell to a perimeter list. */
        
 STATIC void
-add_cell (pmap, new_loc, perim, terrain, cur_cost, inc_cost)
-path_map_t *pmap;
-loc_t new_loc;
-perimeter_t *perim;
-int terrain;
-int cur_cost;
-int inc_cost;
+add_cell (path_map_t *pmap, loc_t new_loc, 
+         perimeter_t *perim, int terrain, int cur_cost, int inc_cost)
 {
        register        path_map_t      *pm = &pmap[new_loc];
 
@@ -646,11 +596,8 @@ int inc_cost;
 /* Compute the cost to move to an objective. */
 
 STATIC int
-objective_cost (vmap, move_info, loc, base_cost)
-view_map_t *vmap;
-move_info_t *move_info;
-loc_t loc;
-int base_cost;
+objective_cost (view_map_t *vmap, move_info_t *move_info, 
+               loc_t loc, int base_cost)
 {
        char *p;
        int w;
@@ -687,12 +634,8 @@ Return the type of terrain at a vmap location.
 */
 
 STATIC int
-terrain_type (pmap, vmap, move_info, from_loc, to_loc)
-path_map_t *pmap;
-view_map_t *vmap;
-move_info_t *move_info;
-loc_t from_loc;
-loc_t to_loc;
+terrain_type (path_map_t *pmap, view_map_t *vmap, move_info_t *move_info,
+             loc_t from_loc, loc_t to_loc)
 {
        if (vmap[to_loc].contents == '+') return T_LAND;
        if (vmap[to_loc].contents == '.') return T_WATER;
@@ -743,8 +686,7 @@ So be careful.
 */
 
 void
-vmap_prune_explore_locs (vmap)
-view_map_t *vmap;
+vmap_prune_explore_locs (view_map_t *vmap)
 {
        path_map_t pmap[MAP_SIZE];
        perimeter_t *from, *to;
@@ -871,13 +813,8 @@ Careful:  'loc' may be "off board".
 */
 
 STATIC void
-expand_prune (vmap, pmap, loc, type, to, explored)
-view_map_t *vmap;
-path_map_t *pmap;
-loc_t loc;
-int type;
-perimeter_t *to;
-int *explored;
+expand_prune (view_map_t *vmap, path_map_t *pmap,
+             loc_t loc, int type, perimeter_t *to, int *explored)
 {
        int i;
        loc_t new_loc;
@@ -909,13 +846,12 @@ This is similar to 'find_objective' except that we know our destination.
 */
 
 loc_t
-vmap_find_dest (path_map, vmap, cur_loc, dest_loc, owner, terrain)
-path_map_t path_map[];
-view_map_t vmap[];
-loc_t cur_loc; /* current location of piece */
-loc_t dest_loc; /* destination of piece */
-int owner; /* owner of piece being moved */
-int terrain; /* terrain we can cross */
+vmap_find_dest (path_map_t path_map[], view_map_t vmap[], 
+               loc_t cur_loc, loc_t dest_loc, int owner, int terrain)
+/* cur_loc = current location of piece */
+/* dest_loc = destination of piece */
+/* owner = owner of piece being moved */
+/* terrain = terrain we can cross */
 {
        perimeter_t *from;
        perimeter_t *to;
@@ -968,10 +904,7 @@ Someday, this routine should probably use perimeter lists as well.
 */
 
 void
-vmap_mark_path (path_map, vmap, dest)
-path_map_t *path_map;
-view_map_t *vmap;
-loc_t dest;
+vmap_mark_path (path_map_t *path_map, view_map_t *vmap, loc_t dest)
 {
        int n;
        loc_t new_dest;
@@ -995,9 +928,7 @@ invoked to decide which squares are actually valid.
 */
 
 void
-vmap_mark_adjacent (path_map, loc)
-path_map_t path_map[];
-loc_t loc;
+vmap_mark_adjacent (path_map_t path_map[], loc_t loc)
 {
        int i;
        loc_t new_loc;
@@ -1013,9 +944,7 @@ to a location on the existing shortest path.
 */
 
 void
-vmap_mark_near_path (path_map, loc)
-path_map_t path_map[];
-loc_t loc;
+vmap_mark_near_path (path_map_t path_map[], loc_t loc)
 {
        int i, j;
        loc_t new_loc, xloc;

diff --git a/math.c b/math.c
index 22e81649d4dccbea1dbdc178f1bf818f08aa3b01..e59ac377d94bbcd110327f3f09fbcd8225aeceee 100644 (file)
--- a/math.c
+++ b/math.c
@@ -25,13 +25,12 @@ Other routines include:
 #include "empire.h"
 #include "extern.h"
 
-void rndini()
+void rndini(void)
 {
        srand((unsigned)(time(0) & 0xFFFF));
 }
 
-long irand(high)
-long high;
+long irand(long high)
 {
        if (high < 2) {
                return (0);
@@ -39,8 +38,7 @@ long high;
        return (rand() % high);
 }
 
-int rndint(minp, maxp)
-int minp, maxp;
+int rndint(int minp, int maxp)
 {
        int size;
 
@@ -58,8 +56,7 @@ the max of the absolute differnce between the x and y coordinates.
 #define ABS(a) ((a) < 0 ? -(a) : (a))
 
 int
-dist (a, b)
-loc_t a, b;
+dist(loc_t a, loc_t b)
 {
        int ax, ay, bx, by;
 
@@ -76,8 +73,7 @@ Find the square root of an integer.  We actually return the floor
 of the square root using Newton's method.
 */
 
-int isqrt (n)
-int n;
+int isqrt(int n)
 {
        int guess;
        

diff --git a/object.c b/object.c
index ef6c98445e06c349ec63da3c1816aac68d8ecc60..8b20f073721f656545195aec7b1eceac84bbc491 100644 (file)
--- a/object.c
+++ b/object.c
@@ -24,10 +24,7 @@ Distances are computed as straight-line distances.
 */
 
 int
-find_nearest_city (loc, owner, city_loc)
-loc_t loc;
-int owner;
-loc_t *city_loc;
+find_nearest_city(loc_t loc, int owner, loc_t *city_loc)
 {
        loc_t best_loc;
        long best_dist;
@@ -52,8 +49,7 @@ loc_t *city_loc;
 Given the location of a city, return the index of that city.
 */
 
-city_info_t *find_city (loc)
-loc_t loc;
+city_info_t *find_city(loc_t loc)
 {
        return (map[loc].cityp);
 }
@@ -67,8 +63,7 @@ at a fraction of their normal speed.  An object which has lost
 half of its hits moves at half-speed, for example.
 */
 
-int obj_moves (obj)
-piece_info_t *obj;
+int obj_moves (piece_info_t *obj)
 {
        return (piece_attr[obj->type].speed * obj->hits
               + piece_attr[obj->type].max_hits - 1) /* round up */
@@ -79,8 +74,7 @@ piece_info_t *obj;
 Figure out the capacity for an object.
 */
 
-int obj_capacity (obj)
-piece_info_t *obj;
+int obj_capacity(piece_info_t *obj)
 {
        return (piece_attr[obj->type].capacity * obj->hits
               + piece_attr[obj->type].max_hits - 1) /* round up */
@@ -92,9 +86,7 @@ Search for an object of a given type at a location.  We scan the
 list of objects at the given location for one of the given type.
 */
 
-piece_info_t *find_obj (type, loc)
-int type;
-loc_t loc;
+piece_info_t *find_obj(int type, loc_t loc)
 {
        piece_info_t *p;
 
@@ -108,9 +100,7 @@ loc_t loc;
 Find a non-full item of the appropriate type at the given location.
 */
 
-piece_info_t *find_nfull (type, loc)
-int type;
-loc_t loc;
+piece_info_t *find_nfull(int type, loc_t loc)
 {
        piece_info_t *p;
 
@@ -127,9 +117,7 @@ of the transport if there is one.
 */
 
 loc_t
-find_transport (owner, loc)
-int owner;
-loc_t loc;
+find_transport(int owner, loc_t loc)
 {
        int i;
        loc_t new_loc;
@@ -149,8 +137,7 @@ We prefer transports and carriers to other objects.
 */
 
 piece_info_t *
-find_obj_at_loc (loc)
-loc_t loc;
+find_obj_at_loc(loc_t loc)
 {
        piece_info_t *p, *best;
        
@@ -168,8 +155,7 @@ loc_t loc;
 If an object is on a ship, remove it from that ship.
 */
 
-void disembark (obj)
-piece_info_t *obj;
+void disembark(piece_info_t *obj)
 {
        if (obj->ship) {
                UNLINK (obj->ship->cargo, obj, cargo_link);
@@ -182,8 +168,7 @@ piece_info_t *obj;
 Move an object onto a ship.
 */
 
-void embark (ship, obj)
-piece_info_t *ship, *obj;
+void embark(piece_info_t *ship, piece_info_t *obj)
 {
        obj->ship = ship;
        LINK (ship->cargo, obj, cargo_link);
@@ -195,9 +180,7 @@ Kill an object.  We scan around the piece and free it.  If there is
 anything in the object, it is killed as well.
 */
 
-void kill_obj (obj, loc)
-piece_info_t *obj;
-loc_t loc;
+void kill_obj(piece_info_t *obj, loc_t loc)
 {
        void kill_one();
 
@@ -216,9 +199,7 @@ loc_t loc;
 
 /* kill an object without scanning */
 
-void kill_one (list, obj)
-piece_info_t **list;
-piece_info_t *obj;
+void kill_one(piece_info_t **list, piece_info_t *obj)
 {
        UNLINK (list[obj->type], obj, piece_link); /* unlink obj from all lists */
        UNLINK (map[obj->loc].objp, obj, loc_link);
@@ -234,8 +215,7 @@ Kill a city.  We kill off all objects in the city and set its type
 to unowned.  We scan around the city's location.
 */
 
-void kill_city (cityp)
-city_info_t *cityp;
+void kill_city(city_info_t *cityp)
 {
        view_map_t *vmap;
        piece_info_t *p;
@@ -285,8 +265,7 @@ Produce an item for a city.
 static int sat_dir[4] = {MOVE_NW, MOVE_SW, MOVE_NE, MOVE_SE};
 
 void
-produce (cityp)
-city_info_t *cityp;
+produce(city_info_t *cityp)
 {
        piece_info_t **list;
        piece_info_t *new;
@@ -327,9 +306,7 @@ of an object, keeping track of the number of pieces on a boat,
 etc.
 */
 
-void move_obj (obj, new_loc)
-piece_info_t *obj;
-loc_t new_loc;
+void move_obj(piece_info_t *obj, loc_t new_loc)
 {
        view_map_t *vmap;
        loc_t old_loc;
@@ -384,8 +361,7 @@ We start off with some preliminary routines.
 /* Return next direction for a sattellite to travel. */
 
 static loc_t
-bounce (loc, dir1, dir2, dir3)
-loc_t loc, dir1, dir2, dir3;
+bounce(loc_t loc, loc_t dir1, loc_t dir2, loc_t dir3)
 {
        int new_loc;
 
@@ -401,8 +377,7 @@ loc_t loc, dir1, dir2, dir3;
 /* Move a satellite one square. */
 
 static void
-move_sat1 (obj)
-piece_info_t *obj;
+move_sat1(piece_info_t *obj)
 {
        int dir;
        loc_t new_loc;
@@ -438,8 +413,7 @@ Satellite burns iff it's range reaches zero.
 */
                
 void
-move_sat (obj)
-piece_info_t *obj;
+move_sat(piece_info_t *obj)
 {
        obj->moved = 0;
        
@@ -462,9 +436,7 @@ terrain type for the location.  Boats may move into port, armies may
 move onto transports, and fighters may move onto cities or carriers.
 */
 
-int good_loc (obj, loc)
-piece_info_t *obj;
-loc_t loc;
+int good_loc(piece_info_t *obj, loc_t loc)
 {
        view_map_t *vmap;
        piece_info_t *p;
@@ -495,8 +467,7 @@ loc_t loc;
        return (FALSE);
 }
 
-void describe_obj (obj)
-piece_info_t *obj;
+void describe_obj(piece_info_t *obj)
 {
        char func[STRSIZE];
        char other[STRSIZE];
@@ -539,9 +510,7 @@ on top.
 */
 
 void
-scan (vmap, loc)
-view_map_t vmap[];
-loc_t loc;
+scan(view_map_t vmap[], loc_t loc)
 {
        void update(), check(void);
 
@@ -565,9 +534,7 @@ Scan a portion of the board for a satellite.
 */
 
 void
-scan_sat (vmap, loc)
-view_map_t *vmap;
-loc_t loc;
+scan_sat(view_map_t vmap[], loc_t loc)
 {
        int i;
        loc_t xloc;
@@ -591,9 +558,7 @@ city type.
 char city_char[] = {'*', 'O', 'X'};
 
 void
-update (vmap, loc)
-view_map_t vmap[];
-loc_t loc;
+update(view_map_t vmap[], loc_t loc)
 {
        piece_info_t *p;
 
@@ -624,8 +589,7 @@ asking until we get a valid answer.
 */
 
 void
-set_prod (cityp)
-city_info_t *cityp;
+set_prod(city_info_t *cityp)
 {
        int i;
 
@@ -651,7 +615,7 @@ city_info_t *cityp;
 /* Get the name of a type of object. */
 
 int
-get_piece_name (void)
+get_piece_name(void)
 {
        char c;
        int i;

diff --git a/term.c b/term.c
index 9e9b02a074e74293b7022c912f7a011d9014e5ab..86a177506b55d86ec7e0eb80930ec7a8f7f000b4 100644 (file)
--- a/term.c
+++ b/term.c
@@ -38,11 +38,11 @@ to read the lines.  The new information is then displayed, and the
 
 static int need_delay;
 static FILE *my_stream;
+
 void
 /* VARARGS1 */
-pdebug (s, a, b, c, d, e, f, g, h)
-char *s;
-int a, b, c, d, e, f, g, h;
+pdebug(char *s, 
+       int a, int b, int c, int d, int e, int f, int g, int h)
 {
        if (!print_debug) return;
        comment (s, a, b, c, d, e, f, g, h);
@@ -55,7 +55,7 @@ we finish printing information to the screen.
 */
 
 void
-topini()
+topini(void)
 {
        info (0, 0, 0);
 }
@@ -65,10 +65,8 @@ Write a message to one of the top lines.
 
 void
 /* VARARGS2 */
-topmsg(linep, buf, a, b, c, d, e, f, g, h)
-int linep;
-char *buf;
-int a, b, c, d, e, f, g, h;
+topmsg(int linep, char *buf,
+       int a, int b, int c, int d, int e, int f, int g, int h)
 {
        if (linep < 1 || linep > NUMTOPS)
                linep = 1;
@@ -81,11 +79,8 @@ int a, b, c, d, e, f, g, h;
 }
 
 void
-topmsg1 (linep, buf, a, b, c, d, e, f, g, h)
-int linep;
-char *buf;
-char *a;
-int b, c, d, e, f, g, h;
+topmsg1(int linep, char *buf, char *a,
+       int b, int c, int d, int e, int f, int g, int h)
 {
        if (linep < 1 || linep > NUMTOPS)
                linep = 1;
@@ -96,12 +91,10 @@ int b, c, d, e, f, g, h;
        
        (void) clrtoeol ();
 }
+
 void
-topmsg2 (linep, buf, a, b, c, d, e, f, g, h)
-int linep;
-char *buf;
-char *a, *e, *f;
-int b, c, d, g, h;
+topmsg2(int linep, char *buf, 
+       char *a, int b, int c, int d, char *e, char *f, int g, int h)
 {
        if (linep < 1 || linep > NUMTOPS)
                linep = 1;
@@ -112,31 +105,30 @@ int b, c, d, g, h;
        
        (void) clrtoeol ();
 }
+
 /*
 Print a prompt on the first message line.
 */
 
 void
 /* VARARGS1 */
-prompt (buf, a, b, c, d, e, f, g, h)
-char *buf;
-int a,b,c,d,e,f,g,h;
+prompt(char *buf,
+       int a, int b, int c, int d, int e, int f, int g, int h)
 {
-       topmsg (1, buf, a, b, c, d, e, f, g, h);
+       topmsg(1, buf, a, b, c, d, e, f, g, h);
 }
+
 void
-prompt1 (buf, a, b, c, d, e, f, g, h)
-char *buf, *a;
-int b,c,d,e,f,g,h;
+prompt1(char *buf, char *a, 
+       int b, int c, int d, int e, int f, int g, int h)
 {
-       topmsg1 (1, buf, a, b, c, d, e, f, g, h);
+       topmsg1(1, buf, a, b, c, d, e, f, g, h);
 }
+
 void
-prompt2 (buf, a, b, c, d, e, f, g, h)
-char *buf, *a, *e, *f;
-int b,c,d,g,h;
-{
-       topmsg2 (1, buf, a, b, c, d, e, f, g, h);
+prompt2 (char *buf, 
+       char *a, int b, int c, int d, char *e, char *f, int g, int h){
+       topmsg2(1, buf, a, b, c, d, e, f, g, h);
 }
 
 /*
@@ -145,11 +137,10 @@ Print an error message on the second message line.
 
 void
 /* VARARGS1 */
-error (buf, a, b, c, d, e, f, g, h)
-char *buf;
-int a, b, c, d, e, f, g, h;
+error(char *buf,
+       int a, int b, int c, int d, int e, int f, int g, int h)
 {
-       topmsg (2, buf, a, b, c, d, e, f, g, h);
+       topmsg(2, buf, a, b, c, d, e, f, g, h);
 }
 
 /*
@@ -158,11 +149,10 @@ Print out extra information.
 
 void
 /* VARARGS1 */
-extra (buf, a, b, c, d, e, f, g, h)
-char *buf;
-int a, b, c, d, e, f, g, h;
+extra(char *buf,
+       int a, int b, int c, int d, int e, int f, int g, int h)
 {
-       topmsg (3, buf, a, b, c, d, e, f, g, h);
+       topmsg(3, buf, a, b, c, d, e, f, g, h);
 }
 
 /*
@@ -170,7 +160,7 @@ Print out a generic error message.
 */
 
 void
-huh ()
+huh(void)
 {
        error ("Type H for Help.",0,0,0,0,0,0,0,0);
 }
@@ -182,8 +172,7 @@ information, we set the need_delay flag.
 */
 
 void
-info (a, b, c)
-char *a, *b, *c;
+info(char *a, char *b, char *c)
 {
        if (need_delay) delay ();
        topmsg (1, a,0,0,0,0,0,0,0,0);
@@ -193,14 +182,13 @@ char *a, *b, *c;
 }
 
 void
-set_need_delay () {
+set_need_delay(void) {
        need_delay = 1;
 }
 
 void
-comment (buf, a, b, c, d, e, f, g, h)
-char *buf;
-int a, b, c, d, e, f, g, h;
+comment (char *buf,
+       int a, int b, int c, int d, int e, int f, int g, int h)
 {
        if (need_delay) delay ();
        topmsg (1, 0,0,0,0,0,0,0,0,0);
@@ -210,9 +198,8 @@ int a, b, c, d, e, f, g, h;
 }
        
 void
-comment1 (buf, a, b, c, d, e, f, g, h)
-char *buf, *a;
-int b, c, d, e, f, g, h;
+comment1(char *buf, char *a,
+        int b, int c, int d, int e, int f, int g, int h)
 {
        if (need_delay) delay ();
        topmsg1 (1, 0,0,0,0,0,0,0,0,0);
@@ -223,9 +210,8 @@ int b, c, d, e, f, g, h;
        
 /* kermyt begin */
 void
-ksend (buf, a, b, c, d, e, f, g, h)
-char *buf;
-int a,b,c,d,e,f,g,h;
+ksend(char *buf,
+       int a, int b, int c, int d, int e, int f, int g, int h)
 {
        if(!(my_stream=fopen("info_list.txt","a")))
        {
@@ -236,10 +222,10 @@ int a,b,c,d,e,f,g,h;
        fclose(my_stream);
        return;
 }
+
 void
-ksend1 (buf, a, b, c, d, e, f, g, h)
-char *buf, *a;
-int b,c,d,e,f,g,h;
+ksend1(char *buf, char *a, 
+       int b, int c, int d, int e, int f, int g, int h)
 {
        if(!(my_stream=fopen("info_list.txt","a")))
        {
@@ -256,9 +242,7 @@ Get a string from the user, echoing characters all the while.
 */
 
 void
-get_str (buf, sizep)
-char *buf;
-int sizep;
+get_str(char *buf, int sizep)
 {
        (void) echo();
        get_strq(buf, sizep);
@@ -270,9 +254,7 @@ Get a string from the user, ignoring the current echo mode.
 */
 
 void
-get_strq (buf, sizep)
-char *buf;
-int sizep;
+get_strq(char *buf, int sizep)
 {
        sizep = sizep; /* size of buf, currently unused */
 
@@ -289,7 +271,7 @@ Get a character from the user and convert it to uppercase.
 */
 
 char
-get_chx()
+get_chx(void)
 {
        char c;
 
@@ -306,8 +288,7 @@ Input an integer from the user.
 */
 
 int
-getint (message)
-char *message;
+getint(char *message)
 {
        char buf[STRSIZE];
        char *p;
@@ -335,7 +316,7 @@ Input a character from the user with echoing.
 */
 
 char
-get_c ()
+get_c(void)
 {
        char c; /* one char and a null */
 
@@ -350,7 +331,7 @@ Input a character quietly.
 */
 
 char
-get_cq ()
+get_cq(void)
 {
        char c;
 
@@ -368,8 +349,7 @@ a valid response.  We return TRUE iff the user replies 'y'.
 */
 
 int
-getyn (message)
-char *message;
+getyn(char *message)
 {
        char c;
 
@@ -389,9 +369,7 @@ Input an integer in a range.
 */
 
 int
-get_range (message, low, high)
-char *message;
-int low, high;
+get_range(char *message, int low, int high)
 {
        int result;
 
@@ -409,9 +387,7 @@ Print a screen of help information.
 */
 
 void
-help (text, nlines)
-char **text;
-int nlines;
+help(char **text, int nlines)
 {
        int i, r, c;
        int text_lines;
@@ -456,7 +432,7 @@ int nlines;
 #define COL_DIGITS ((MAP_WIDTH <= 100) ? 2 : ((MAP_WIDTH <= 1000 ? 3 : (1 / 0))))
 
 int
-loc_disp (int loc)
+loc_disp(int loc)
 {
   int row = loc / MAP_WIDTH;
   int nrow = row;

diff --git a/usermove.c b/usermove.c
index 8059f4b253cefe67f46d4a230137a35aa66f2421..ec131a9b85cd814a259af53a2a23db0618cb758d 100644 (file)
--- a/usermove.c
+++ b/usermove.c
@@ -23,7 +23,7 @@ int awake(piece_info_t *obj);
 extern int get_piece_name(void);
 
 void
-user_move (void) {
+user_move(void) {
        void piece_move();
 
        int i, j, sec, sec_start;
@@ -102,8 +102,7 @@ the piece has not moved after this, we ask the user what to do.
 */
 
 void
-piece_move (obj)
-piece_info_t *obj;
+piece_move(piece_info_t *obj)
 {
        void move_random(), move_fill(), move_land(), move_explore();
        void move_path(), move_dir(), move_armyload(), ask_user();
@@ -205,8 +204,7 @@ the piece can move.  If there are none, we do nothing, otherwise we
 move the piece to a random adjacent square.
 */
 
-void move_random (obj)
-piece_info_t *obj;
+void move_random(piece_info_t *obj)
 {
        loc_t loc_list[8];
        int i, nloc;
@@ -232,8 +230,7 @@ which the piece can reach and have to piece move toward the
 territory.
 */
 
-void move_explore (obj)
-piece_info_t *obj;
+void move_explore(piece_info_t *obj)
 {
        path_map_t path_map[MAP_SIZE];
        loc_t loc;
@@ -271,8 +268,7 @@ army to the transport and waken the army.
 */
 
 void
-move_transport (obj)
-piece_info_t *obj;
+move_transport(piece_info_t *obj)
 {
        loc_t loc;
 
@@ -295,8 +291,7 @@ the transport, and awaken the army.
 static view_map_t amap[MAP_SIZE];
 
 void
-move_armyload (obj)
-piece_info_t *obj;
+move_armyload(piece_info_t *obj)
 {
        loc_t loc;
        piece_info_t *p;
@@ -330,8 +325,7 @@ Move an army toward an attackable city or enemy army.
 */
 
 void
-move_armyattack (obj)
-piece_info_t *obj;
+move_armyattack(piece_info_t *obj)
 {
        path_map_t path_map[MAP_SIZE];
        loc_t loc;
@@ -349,8 +343,7 @@ piece_info_t *obj;
 }
 
 void
-move_ttload (obj)
-piece_info_t *obj;
+move_ttload(piece_info_t *obj)
 {
        ABORT;
        obj = obj;
@@ -361,8 +354,7 @@ Move a ship toward port.  If the ship is healthy, wake it up.
 */
 
 void
-move_repair (obj)
-piece_info_t *obj;
+move_repair(piece_info_t *obj)
 {
        path_map_t path_map[MAP_SIZE];
        loc_t loc;
@@ -396,8 +388,7 @@ object is not full, we set the move count to its maximum value.
 Otherwise we awaken the object.
 */
 
-void move_fill (obj)
-piece_info_t *obj;
+void move_fill(piece_info_t *obj)
 {
        if (obj->count == obj_capacity (obj)) /* full? */
                obj->func = NOFUNC; /* awaken full boat */
@@ -412,8 +403,7 @@ The nearest landing field must be within the object's range.
 */
 
 void
-move_land (obj)
-piece_info_t *obj;
+move_land(piece_info_t *obj)
 {
        long best_dist;
        loc_t best_loc;
@@ -443,8 +433,7 @@ If the object is a fighter which has travelled for half its range,
 we wake it up.
 */
 
-void move_dir (obj)
-piece_info_t *obj;
+void move_dir(piece_info_t *obj)
 {
        loc_t loc;
        int dir;
@@ -463,8 +452,7 @@ to our destination, and if there is nothing in the way.  If so, we
 move in the first direction we find.
 */
 
-void move_path (obj)
-piece_info_t *obj;
+void move_path(piece_info_t *obj)
 {
        if (obj->loc == obj->func)
                obj->func = NOFUNC;
@@ -478,9 +466,7 @@ Then we mark the paths to the destination.  Then we choose a
 move.
 */
 
-void move_to_dest (obj, dest)
-piece_info_t *obj;
-loc_t dest;
+void move_to_dest(piece_info_t *obj, loc_t dest)
 {
        path_map_t path_map[MAP_SIZE];
        int fterrain;
@@ -517,8 +503,7 @@ loc_t dest;
 Ask the user to move her piece.
 */
 
-void ask_user (obj)
-piece_info_t *obj;
+void ask_user(piece_info_t *obj)
 {
        void user_skip(), user_fill(), user_dir(), user_set_dir();
        void user_wake(), user_set_city_func(), user_cancel_auto();
@@ -581,8 +566,7 @@ function, and did not tell us what to do with the object.
 */
 
 void
-reset_func (obj)
-piece_info_t *obj;
+reset_func(piece_info_t *obj)
 {
        city_info_t *cityp;
        
@@ -602,8 +586,7 @@ the city.
 */
 
 void
-user_skip (obj)
-piece_info_t *obj;
+user_skip(piece_info_t *obj)
 {
        if (obj->type == ARMY && user_map[obj->loc].contents == 'O')
                move_army_to_city (obj, obj->loc);
@@ -616,8 +599,7 @@ or carrier.  If not, we beep at the user.
 */
 
 void
-user_fill (obj)
-piece_info_t *obj;
+user_fill(piece_info_t *obj)
 {
        if (obj->type != TRANSPORT && obj->type != CARRIER) (void) beep ();
        else obj->func = FILL;
@@ -628,7 +610,7 @@ Print out help information.
 */
 
 void
-user_help (void) {
+user_help(void) {
        char c;
 
        help (help_user, user_lines);
@@ -642,8 +624,7 @@ Set an object's function to move in a certain direction.
 */
 
 void
-user_set_dir (obj)
-piece_info_t *obj;
+user_set_dir(piece_info_t *obj)
 {
        char c;
 
@@ -666,8 +647,7 @@ Wake up the current piece.
 */
 
 void
-user_wake (obj)
-piece_info_t *obj;
+user_wake(piece_info_t *obj)
 {
        obj->func = NOFUNC;
 }
@@ -677,8 +657,7 @@ Set the piece's func to random.
 */
 
 void
-user_random (obj)
-piece_info_t *obj;
+user_random(piece_info_t *obj)
 {
        obj->func = RANDOM;
 }
@@ -688,8 +667,7 @@ Set a piece's function to sentry.
 */
 
 void
-user_sentry (obj)
-piece_info_t *obj;
+user_sentry(piece_info_t *obj)
 {
        obj->func = SENTRY;
 }
@@ -699,8 +677,7 @@ Set a fighter's function to land at the nearest city.
 */
 
 void
-user_land (obj)
-piece_info_t *obj;
+user_land(piece_info_t *obj)
 {
        if (obj->type != FIGHTER) (void) beep ();
        else obj->func = LAND;
@@ -711,8 +688,7 @@ Set the piece's func to explore.
 */
 
 void
-user_explore (obj)
-piece_info_t *obj;
+user_explore(piece_info_t *obj)
 {
        obj->func = EXPLORE;
 }
@@ -722,8 +698,7 @@ Set an army's function to WFTRANSPORT.
 */
 
 void
-user_transport (obj)
-piece_info_t *obj;
+user_transport(piece_info_t *obj)
 {
        if (obj->type != ARMY) (void) beep ();
        else obj->func = WFTRANSPORT;
@@ -734,8 +709,7 @@ Set an army's function to ARMYATTACK.
 */
 
 void
-user_armyattack (obj)
-piece_info_t *obj;
+user_armyattack(piece_info_t *obj)
 {
        if (obj->type != ARMY) (void) beep ();
        else obj->func = ARMYATTACK;
@@ -746,8 +720,7 @@ Set a ship's function to REPAIR.
 */
 
 void
-user_repair (obj)
-piece_info_t *obj;
+user_repair(piece_info_t *obj)
 {
        if (obj->type == ARMY || obj->type == FIGHTER) (void) beep ();
        else obj->func = REPAIR;
@@ -758,8 +731,7 @@ Set a city's function.
 */
 
 void
-user_set_city_func (obj)
-piece_info_t *obj;
+user_set_city_func(piece_info_t *obj)
 {
        void e_city_fill(), e_city_explore(), e_city_stasis();
        void e_city_wake(), e_city_random(), e_city_repair();
@@ -816,8 +788,7 @@ Change a city's production.
 */
 
 void
-user_build (obj)
-piece_info_t *obj;
+user_build(piece_info_t *obj)
 {
        city_info_t *cityp;
 
@@ -836,9 +807,7 @@ This routine handles attacking objects.
 */
 
 void
-user_dir (obj, dir)
-piece_info_t *obj;
-int dir;
+user_dir(piece_info_t *obj, int dir)
 {
        void user_dir_army(), user_dir_fighter(), user_dir_ship();
 
@@ -869,9 +838,7 @@ necessary, and attack if necessary.
 */
 
 void
-user_dir_army (obj, loc)
-piece_info_t *obj;
-loc_t loc;
+user_dir_army(piece_info_t *obj, loc_t loc)
 {
        int enemy_killed;
        
@@ -934,9 +901,7 @@ three cases:  attacking a city, attacking ourself, attacking the enemy.
 */
 
 void
-user_dir_fighter (obj, loc)
-piece_info_t *obj;
-loc_t loc;
+user_dir_fighter(piece_info_t *obj, loc_t loc)
 {
        if (map[loc].contents == '*')
                fatal (obj, loc,
@@ -961,9 +926,7 @@ a city, attacking self, attacking enemy.
 */
        
 void
-user_dir_ship (obj, loc)
-piece_info_t *obj;
-loc_t loc;
+user_dir_ship(piece_info_t *obj, loc_t loc)
 {
        int enemy_killed;
 
@@ -1020,9 +983,7 @@ if she really wants to attack the city.
 */
 
 void
-move_army_to_city (obj, city_loc)
-piece_info_t *obj;
-loc_t city_loc;
+move_army_to_city(piece_info_t *obj, loc_t city_loc)
 {
        piece_info_t *tt;
 
@@ -1040,7 +1001,8 @@ Cancel automove mode.
 */
 
 void
-user_cancel_auto (void) {
+user_cancel_auto(void)
+{
        if (!automove)
                comment ("Not in auto mode!",0,0,0,0,0,0,0,0);
        else {
@@ -1054,7 +1016,8 @@ Redraw the screen.
 */
 
 void
-user_redraw (void) {
+user_redraw (void)
+{
        redraw ();
 }
 
@@ -1068,8 +1031,7 @@ will return TRUE if we want the user to have control.
 */
 
 int
-awake (obj)
-piece_info_t *obj;
+awake(piece_info_t *obj)
 {
        int i;
        char c;
@@ -1105,11 +1067,7 @@ print out the response and kill the object.
 */
 
 void
-fatal (obj, loc, message, response)
-piece_info_t *obj;
-loc_t loc;
-char *message;
-char *response;
+fatal(piece_info_t *obj, loc_t loc, char *message, char *response)
 {
        if (getyn (message)) {
                comment (response,0,0,0,0,0,0,0,0);

diff --git a/util.c b/util.c
index 956401daba896d90e94fa09e8b0ef6797a104b91..589a73d229fc191ad74609602d2e23b1ea36b60b 100644 (file)
--- a/util.c
+++ b/util.c
@@ -28,8 +28,7 @@ Shirley this is defined elsewhere?
 #include <ctype.h>
 
 void
-tupper (str)
-char   *str;
+tupper(char *str)
 {
        while (*str) {
                if (islower (*str)) *str = upper (*str);
@@ -42,8 +41,7 @@ Convert a character to uppercase (if it is lowercase)
 */
 
 char
-upper (c)
-char c;
+upper(char c)
 {
        if (islower (c))
                return toupper (c);
@@ -55,10 +53,7 @@ Report a bug.
 */
 
 void
-assert (expression, file, line)
-char *expression;
-char *file;
-int line;
+assert(char *expression, char *file, int line)
 {
        char buf[STRSIZE];
 
@@ -76,7 +71,7 @@ End the game by cleaning up the display.
 */
 
 void
-empend ()
+empend(void)
 {
        close_disp ();
        exit (0);
@@ -113,7 +108,7 @@ static int in_loc[LIST_SIZE]; /* TRUE if object in a loc list */
 static int in_cargo[LIST_SIZE]; /* TRUE if object in a cargo list */
 
 void
-check () {
+check(void) {
        void check_cargo(), check_obj(), check_obj_cargo();
        
        long i, j;
@@ -202,9 +197,7 @@ Check object lists.  We look for:
 */
 
 void
-check_obj (list, owner)
-piece_info_t **list;
-int owner;
+check_obj(piece_info_t **list, int owner)
 {
        long i, j;
        piece_info_t *p;
@@ -245,9 +238,7 @@ Check for:
 */
 
 void
-check_cargo (list, cargo_type)
-piece_info_t *list;
-int cargo_type;
+check_cargo(piece_info_t *list, int cargo_type)
 {
        piece_info_t *p, *q;
        long j, count;
@@ -280,8 +271,7 @@ lists are valid.
 */
 
 void
-check_obj_cargo (list)
-piece_info_t **list;
+check_obj_cargo(piece_info_t **list)
 {
        piece_info_t *p;
        long i;