Reindent the code.
authorEric S. Raymond <esr@thyrsus.com>
Sun, 25 Aug 2013 14:57:05 +0000 (10:57 -0400)
committerEric S. Raymond <esr@thyrsus.com>
Sun, 25 Aug 2013 14:57:05 +0000 (10:57 -0400)
It used some odd conventions that made reading difficult - failing to
consistently indent for loops, for example.

12 files changed:
attack.c
compmove.c
display.c
edit.c
empire.c
game.c
main.c
map.c
object.c
term.c
usermove.c
util.c

index 86fccc1..57a62e2 100644 (file)
--- a/attack.c
+++ b/attack.c
@@ -29,46 +29,46 @@ if any.
 void
 attack_city(piece_info_t *att_obj, loc_t loc)
 {
-       city_info_t *cityp;
-       int att_owner, city_owner;
+    city_info_t *cityp;
+    int att_owner, city_owner;
 
-       cityp = find_city (loc);
-       ASSERT (cityp);
+    cityp = find_city (loc);
+    ASSERT (cityp);
        
-       att_owner = att_obj->owner;
-       city_owner = cityp->owner;
+    att_owner = att_obj->owner;
+    city_owner = cityp->owner;
 
-       if (irand (2) == 0) { /* attack fails? */
-               if (att_owner == USER) {
-                   comment ("The scum defending the city crushed your attacking blitzkrieger.");
-                       ksend ("The scum defending the city crushed your attacking blitzkrieger.\n"); //kermyt
-               }
-               else if (city_owner == USER) {
-                       ksend ("Your city at %d is under attack.\n",loc_disp(cityp->loc)); //kermyt
-                       comment ("Your city at %d is under attack.",loc_disp(cityp->loc));
-               }
-               kill_obj (att_obj, loc);
+    if (irand (2) == 0) { /* attack fails? */
+       if (att_owner == USER) {
+           comment ("The scum defending the city crushed your attacking blitzkrieger.");
+           ksend ("The scum defending the city crushed your attacking blitzkrieger.\n"); //kermyt
        }
-       else { /* attack succeeded */
-               kill_city (cityp);
-               cityp->owner = att_owner;
-               kill_obj (att_obj, loc);
-
-               if (att_owner == USER) {
-                       ksend ("City at %d has been subjugated!\n",loc_disp(cityp->loc)); //kermyt
-                       error ("City at %d has been subjugated!",loc_disp(cityp->loc));
-
-                       extra ("Your army has been dispersed to enforce control.");
-                       ksend ("Your army has been dispersed to enforce control.\n");
-                       set_prod (cityp);
-               }
-               else if (city_owner == USER) {
-                   ksend("City at %d has been lost to the enemy!\n",loc_disp(cityp->loc)); //kermyt
-                       comment ("City at %d has been lost to the enemy!",loc_disp(cityp->loc));
-               }
+       else if (city_owner == USER) {
+           ksend ("Your city at %d is under attack.\n",loc_disp(cityp->loc)); //kermyt
+           comment ("Your city at %d is under attack.",loc_disp(cityp->loc));
        }
-       /* let city owner see all results */
-       if (city_owner != UNOWNED) scan (MAP(city_owner), loc);
+       kill_obj (att_obj, loc);
+    }
+    else { /* attack succeeded */
+       kill_city (cityp);
+       cityp->owner = att_owner;
+       kill_obj (att_obj, loc);
+
+       if (att_owner == USER) {
+           ksend ("City at %d has been subjugated!\n",loc_disp(cityp->loc)); //kermyt
+           error ("City at %d has been subjugated!",loc_disp(cityp->loc));
+
+           extra ("Your army has been dispersed to enforce control.");
+           ksend ("Your army has been dispersed to enforce control.\n");
+           set_prod (cityp);
+       }
+       else if (city_owner == USER) {
+           ksend("City at %d has been lost to the enemy!\n",loc_disp(cityp->loc)); //kermyt
+           comment ("City at %d has been lost to the enemy!",loc_disp(cityp->loc));
+       }
+    }
+    /* let city owner see all results */
+    if (city_owner != UNOWNED) scan (MAP(city_owner), loc);
 }
 
 /*
@@ -79,44 +79,44 @@ First we have to figure out what is being attacked.
 void
 attack_obj(piece_info_t *att_obj, loc_t loc)
 {
-       void describe(), survive();
+    void describe(), survive();
        
-       piece_info_t *def_obj; /* defender */
-       int owner;
+    piece_info_t *def_obj; /* defender */
+    int owner;
 
-       def_obj = find_obj_at_loc (loc);
-       ASSERT (def_obj != NULL); /* can't find object to attack? */
+    def_obj = find_obj_at_loc (loc);
+    ASSERT (def_obj != NULL); /* can't find object to attack? */
        
-       if (def_obj->type == SATELLITE) return; /* can't attack a satellite */
-
-       while (att_obj->hits > 0 && def_obj->hits > 0) {
-               if (irand (2) == 0) /* defender hits? */
-                    att_obj->hits -= piece_attr[def_obj->type].strength;
-               else def_obj->hits -= piece_attr[att_obj->type].strength;
-       }
-
-       if (att_obj->hits > 0) { /* attacker won? */
-               describe (att_obj, def_obj, loc);
-               owner = def_obj->owner;
-               kill_obj (def_obj, loc); /* kill loser */
-               survive (att_obj, loc); /* move attacker */
-       }
-       else { /* defender won */
-               describe (def_obj, att_obj, loc);
-               owner = att_obj->owner;
-               kill_obj (att_obj, loc);
-               survive (def_obj, loc);
-       }
-       /* show results to first killed */
-       scan (MAP(owner), loc);
+    if (def_obj->type == SATELLITE) return; /* can't attack a satellite */
+
+    while (att_obj->hits > 0 && def_obj->hits > 0) {
+       if (irand (2) == 0) /* defender hits? */
+           att_obj->hits -= piece_attr[def_obj->type].strength;
+       else def_obj->hits -= piece_attr[att_obj->type].strength;
+    }
+
+    if (att_obj->hits > 0) { /* attacker won? */
+       describe (att_obj, def_obj, loc);
+       owner = def_obj->owner;
+       kill_obj (def_obj, loc); /* kill loser */
+       survive (att_obj, loc); /* move attacker */
+    }
+    else { /* defender won */
+       describe (def_obj, att_obj, loc);
+       owner = att_obj->owner;
+       kill_obj (att_obj, loc);
+       survive (def_obj, loc);
+    }
+    /* show results to first killed */
+    scan (MAP(owner), loc);
 }
 
 void
 attack(piece_info_t *att_obj, loc_t loc)
 {
-       if (map[loc].contents == '*') /* attacking a city? */
-               attack_city (att_obj, loc);
-       else attack_obj (att_obj, loc); /* attacking a piece */
+    if (map[loc].contents == '*') /* attacking a city? */
+       attack_city (att_obj, loc);
+    else attack_obj (att_obj, loc); /* attacking a piece */
 }
 
 /*
@@ -129,47 +129,49 @@ location.
 void
 survive(piece_info_t *obj, loc_t loc)
 {
-       while (obj_capacity (obj) < obj->count)
-               kill_obj (obj->cargo, loc);
+    while (obj_capacity (obj) < obj->count)
+       kill_obj (obj->cargo, loc);
                
-       move_obj (obj, loc);
+    move_obj (obj, loc);
 }
 
 void
 describe(piece_info_t *win_obj, piece_info_t *lose_obj, loc_t loc)
 {
-       char buf[STRSIZE];
-       char buf2[STRSIZE];
-       int diff;
+    char buf[STRSIZE];
+    char buf2[STRSIZE];
+    int diff;
        
-       *buf = '\0';
-       *buf2 = '\0';
+    *buf = '\0';
+    *buf2 = '\0';
        
-       if (win_obj->owner != lose_obj->owner) {
-               if (win_obj->owner == USER) {
-                       user_score += piece_attr[lose_obj->type].build_time; 
-                       ksend ("Enemy %s at %d destroyed.\n",piece_attr[lose_obj->type].name,loc_disp(loc)); //kermyt
-                       topmsg (1, "Enemy %s at %d destroyed.",piece_attr[lose_obj->type].name,loc_disp(loc));
-                       ksend ("Your %s has %d hits left\n",piece_attr[win_obj->type].name,win_obj->hits); //kermyt
-                       topmsg (2, "Your %s has %d hits left.", piece_attr[win_obj->type].name, win_obj->hits);
+    if (win_obj->owner != lose_obj->owner) {
+       if (win_obj->owner == USER) {
+           user_score += piece_attr[lose_obj->type].build_time; 
+           ksend ("Enemy %s at %d destroyed.\n",piece_attr[lose_obj->type].name,loc_disp(loc)); //kermyt
+           topmsg (1, "Enemy %s at %d destroyed.",piece_attr[lose_obj->type].name,loc_disp(loc));
+           ksend ("Your %s has %d hits left\n",piece_attr[win_obj->type].name,win_obj->hits); //kermyt
+           topmsg (2, "Your %s has %d hits left.", piece_attr[win_obj->type].name, win_obj->hits);
                                
-                       diff = win_obj->count - obj_capacity (win_obj);
-                       if (diff > 0) switch (win_obj->cargo->type) {
-                       case ARMY:
-                               ksend("%d armies fell overboard and drowned in the assault.\n",diff); //kermyt
-                            topmsg (3,"%d armies fell overboard and drowned in the assault.",diff);
-                            break;
-                       case FIGHTER:
-                               ksend("%d fighters fell overboard and were lost in the assult.\n",diff); //kermyt
-                            topmsg (3,"%d fighters fell overboard and were lost in the assault.",diff);
-                            break;
-                       }
+           diff = win_obj->count - obj_capacity (win_obj);
+           if (diff > 0) switch (win_obj->cargo->type) {
+               case ARMY:
+                   ksend("%d armies fell overboard and drowned in the assault.\n",diff); //kermyt
+                   topmsg (3,"%d armies fell overboard and drowned in the assault.",diff);
+                   break;
+               case FIGHTER:
+                   ksend("%d fighters fell overboard and were lost in the assult.\n",diff); //kermyt
+                   topmsg (3,"%d fighters fell overboard and were lost in the assault.",diff);
+                   break;
                }
-               else {
-                       comp_score += piece_attr[lose_obj->type].build_time;
-                       ksend ("Your %s at %d destroyed.\n",piece_attr[lose_obj->type].name,loc_disp(loc)); //kermyt
-                       topmsg (3, "Your %s at %d destroyed.",piece_attr[lose_obj->type].name,loc_disp(loc));
-               }
-               set_need_delay ();
        }
+       else {
+           comp_score += piece_attr[lose_obj->type].build_time;
+           ksend ("Your %s at %d destroyed.\n",piece_attr[lose_obj->type].name,loc_disp(loc)); //kermyt
+           topmsg (3, "Your %s at %d destroyed.",piece_attr[lose_obj->type].name,loc_disp(loc));
+       }
+       set_need_delay ();
+    }
 }
+
+/* end */
index b44631c..eb9ab2d 100644 (file)
@@ -34,32 +34,32 @@ void comp_prod(city_info_t *, bool);
 void
 comp_move(int nmoves) 
 {
-       void do_cities(), do_pieces(), check_endgame();
+    void do_cities(), do_pieces(), check_endgame();
 
-       int i;
-       piece_info_t *obj;
+    int i;
+    piece_info_t *obj;
 
-       /* Update our view of the world. */
+    /* Update our view of the world. */
        
-       for (i = 0; i < NUM_OBJECTS; i++)
+    for (i = 0; i < NUM_OBJECTS; i++)
        for (obj = comp_obj[i]; obj != NULL; obj = obj->piece_link.next)
-               scan (comp_map, obj->loc); /* refresh comp's view of world */
+           scan (comp_map, obj->loc); /* refresh comp's view of world */
 
-       for (i = 1; i <= nmoves; i++) { /* for each move we get... */
-               comment ("Thinking...");
+    for (i = 1; i <= nmoves; i++) { /* for each move we get... */
+       comment ("Thinking...");
 
-               (void) memcpy (emap, comp_map, MAP_SIZE * sizeof (view_map_t));
-               vmap_prune_explore_locs (emap);
+       (void) memcpy (emap, comp_map, MAP_SIZE * sizeof (view_map_t));
+       vmap_prune_explore_locs (emap);
        
-               do_cities (); /* handle city production */
-               do_pieces (); /* move pieces */
+       do_cities (); /* handle city production */
+       do_pieces (); /* move pieces */
                
-               if (save_movie) save_movie_screen ();
-               check_endgame (); /* see if game is over */
+       if (save_movie) save_movie_screen ();
+       check_endgame (); /* see if game is over */
 
-               topini ();
-               (void) redisplay ();
-       }
+       topini ();
+       (void) redisplay ();
+    }
 }
 
 /*
@@ -78,27 +78,28 @@ build carriers, as we don't have a good strategy for moving these.
 */
 
 void
-do_cities(void) {
-       int i;
-       bool is_lake;
+do_cities(void)
+{
+    int i;
+    bool is_lake;
 
-       for (i = 0; i < NUM_CITY; i++) /* new production */
+    for (i = 0; i < NUM_CITY; i++) /* new production */
        if (city[i].owner == COMP) {
-               scan (comp_map, city[i].loc);
+           scan (comp_map, city[i].loc);
 
-               if (city[i].prod == NOPIECE)
-                       comp_prod (&city[i], lake (city[i].loc));
+           if (city[i].prod == NOPIECE)
+               comp_prod (&city[i], lake (city[i].loc));
        }
-       for (i = 0; i < NUM_CITY; i++) /* produce and change */
+    for (i = 0; i < NUM_CITY; i++) /* produce and change */
        if (city[i].owner == COMP) {
-               is_lake = lake (city[i].loc);
-               if (city[i].work++ >= (long)piece_attr[(int)city[i].prod].build_time) {
-                       produce (&city[i]);
-                       comp_prod (&city[i], is_lake);
-               }
-               /* don't produce ships in lakes */
-               else if (city[i].prod > FIGHTER && city[i].prod != SATELLITE && is_lake)
-                       comp_prod (&city[i], is_lake);
+           is_lake = lake (city[i].loc);
+           if (city[i].work++ >= (long)piece_attr[(int)city[i].prod].build_time) {
+               produce (&city[i]);
+               comp_prod (&city[i], is_lake);
+           }
+           /* don't produce ships in lakes */
+           else if (city[i].prod > FIGHTER && city[i].prod != SATELLITE && is_lake)
+               comp_prod (&city[i], is_lake);
        }
 }
                        
@@ -133,123 +134,126 @@ The algorithm below contains three parts:
 void
 comp_prod(city_info_t *cityp, bool is_lake)
 {
-       int city_count[NUM_OBJECTS]; /* # of cities producing each piece */
-       int cont_map[MAP_SIZE];
-       int total_cities;
-       count_t i;
-       int comp_ac;
-       city_info_t *p;
-       int need_count, interest;
-       scan_counts_t counts;
-
-       /* Make sure we have army producers for current continent. */
+    int city_count[NUM_OBJECTS]; /* # of cities producing each piece */
+    int cont_map[MAP_SIZE];
+    int total_cities;
+    count_t i;
+    int comp_ac;
+    city_info_t *p;
+    int need_count, interest;
+    scan_counts_t counts;
+
+    /* Make sure we have army producers for current continent. */
        
-       /* map out city's continent */
-       vmap_cont (cont_map, comp_map, cityp->loc, '.');
+    /* map out city's continent */
+    vmap_cont (cont_map, comp_map, cityp->loc, '.');
 
-       /* count items of interest on the continent */
-       counts = vmap_cont_scan (cont_map, comp_map);
-       comp_ac = 0; /* no army producing computer cities */
+    /* count items of interest on the continent */
+    counts = vmap_cont_scan (cont_map, comp_map);
+    comp_ac = 0; /* no army producing computer cities */
        
-       for (i = 0; i < MAP_SIZE; i++)
-               if (cont_map[i]) { /* for each cell of continent */
-                       if (comp_map[i].contents == 'X') {
-                               p = find_city (i);
-                               ASSERT (p != NULL && p->owner == COMP);
-                               if (p->prod == ARMY) comp_ac += 1;
-                       }
+    for (i = 0; i < MAP_SIZE; i++)
+       if (cont_map[i]) { /* for each cell of continent */
+           if (comp_map[i].contents == 'X') {
+               p = find_city (i);
+               ASSERT (p != NULL && p->owner == COMP);
+               if (p->prod == ARMY) comp_ac += 1;
+           }
        }
-       /* see if anything of interest is on continent */
-       interest = (counts.unexplored || counts.user_cities
-                || counts.user_objects[ARMY]
-                || counts.unowned_cities);
+    /* see if anything of interest is on continent */
+    interest = (counts.unexplored || counts.user_cities
+               || counts.user_objects[ARMY]
+               || counts.unowned_cities);
        
-       /* we want one more army producer than enemy has cities */
-       /* and one more if anything of interest on cont */
-       need_count = counts.user_cities - comp_ac + interest;
-       if (counts.user_cities) need_count += 1;
+    /* we want one more army producer than enemy has cities */
+    /* and one more if anything of interest on cont */
+    need_count = counts.user_cities - comp_ac + interest;
+    if (counts.user_cities) need_count += 1;
        
-       if (need_count > 0) { /* need an army producer? */
-               comp_set_prod (cityp, ARMY);
-               return;
-       }
+    if (need_count > 0) { /* need an army producer? */
+       comp_set_prod (cityp, ARMY);
+       return;
+    }
        
-       /* Produce armies in new cities if there is a city to attack. */
-       if (counts.user_cities && cityp->prod == NOPIECE) {
-               comp_set_prod (cityp, ARMY);
-               return;
-       }
+    /* Produce armies in new cities if there is a city to attack. */
+    if (counts.user_cities && cityp->prod == NOPIECE) {
+       comp_set_prod (cityp, ARMY);
+       return;
+    }
 
-       /* Produce a TT and SAT if we don't have one. */
+    /* Produce a TT and SAT if we don't have one. */
        
-       /* count # of cities producing each piece */
-       for (i = 0; i < NUM_OBJECTS; i++)
-               city_count[i] = 0;
+    /* count # of cities producing each piece */
+    for (i = 0; i < NUM_OBJECTS; i++)
+       city_count[i] = 0;
                
-       total_cities = 0;
+    total_cities = 0;
                
-       for (i = 0; i < NUM_CITY; i++)
+    for (i = 0; i < NUM_CITY; i++)
        if (city[i].owner == COMP && city[i].prod != NOPIECE) {
-               city_count[(int)city[i].prod] += 1;
-               total_cities += 1;
+           city_count[(int)city[i].prod] += 1;
+           total_cities += 1;
        }
-       if (total_cities <= 10) ratio = ratio1;
-       else if (total_cities <= 20) ratio = ratio2;
-       else if (total_cities <= 30) ratio = ratio3;
-       else ratio = ratio4;
+    if (total_cities <= 10)
+       ratio = ratio1;
+    else if (total_cities <= 20)
+       ratio = ratio2;
+    else if (total_cities <= 30)
+       ratio = ratio3;
+    else ratio = ratio4;
                
-       /* if we have one army producer, and this is it, return */
-       if (city_count[ARMY] == 1 && cityp->prod == ARMY) return;
+    /* if we have one army producer, and this is it, return */
+    if (city_count[ARMY] == 1 && cityp->prod == ARMY) return;
        
-       /* first available non-lake becomes a tt producer */
-       if (city_count[TRANSPORT] == 0) {
-               if (!is_lake) {
-                       comp_set_prod (cityp, TRANSPORT);
-                       return;
-               }
-               /* if we have one army producer that is not on a lake, */
-               /* produce armies here instead */
-               if (city_count[ARMY] == 1) {
-                       for (i = 0; i < NUM_CITY; i++)
-                       if (city[i].owner == COMP && city[i].prod == ARMY) break;
-               
-                       if (!lake (city[i].loc)) {
-                               comp_set_prod (cityp, ARMY);
-                               return;
-                       }
-               }
+    /* first available non-lake becomes a tt producer */
+    if (city_count[TRANSPORT] == 0) {
+       if (!is_lake) {
+           comp_set_prod (cityp, TRANSPORT);
+           return;
        }
-#if 0
-       /* Now we need a SATELLITE. */
-       if (cityp->prod == NOPIECE && city_count[SATELLITE] == 0) {
-               comp_set_prod (cityp, SATELLITE);
+       /* if we have one army producer that is not on a lake, */
+       /* produce armies here instead */
+       if (city_count[ARMY] == 1) {
+           for (i = 0; i < NUM_CITY; i++)
+               if (city[i].owner == COMP && city[i].prod == ARMY) break;
+               
+           if (!lake (city[i].loc)) {
+               comp_set_prod (cityp, ARMY);
                return;
+           }
        }
-       if (cityp->prod == SATELLITE) return;
-       /* "The satellites are out tonight." -- Lori Anderson */
+    }
+#if 0
+    /* Now we need a SATELLITE. */
+    if (cityp->prod == NOPIECE && city_count[SATELLITE] == 0) {
+       comp_set_prod (cityp, SATELLITE);
+       return;
+    }
+    if (cityp->prod == SATELLITE) return;
+    /* "The satellites are out tonight." -- Lori Anderson */
 #endif
-       /* don't change prod from armies if something on continent */
-       if (cityp->prod == ARMY && interest) return;
+    /* don't change prod from armies if something on continent */
+    if (cityp->prod == ARMY && interest) return;
                        
-       /* Produce armies in new cities if there is a city to attack. */
-       if (counts.unowned_cities && cityp->prod == NOPIECE) {
-               comp_set_prod (cityp, ARMY);
-               return;
-       }
-
-       /* Set production to item most needed.  Continents with one
-       city and nothing interesting may not produce armies.  We
-       set production for unset cities, and change production for
-       cities that produce objects for which we have many city producers.
-       Ship producers on lakes also get there production changed. */
+    /* Produce armies in new cities if there is a city to attack. */
+    if (counts.unowned_cities && cityp->prod == NOPIECE) {
+       comp_set_prod (cityp, ARMY);
+       return;
+    }
+
+    /* Set production to item most needed.  Continents with one
+       city and nothing interesting may not produce armies.  We
+       set production for unset cities, and change production for
+       cities that produce objects for which we have many city producers.
+       Ship producers on lakes also get there production changed. */
        
-       interest = (counts.comp_cities != 1 || interest);
+    interest = (counts.comp_cities != 1 || interest);
        
-       if (cityp->prod == NOPIECE
-           || (cityp->prod == ARMY && counts.comp_cities == 1)
-           || overproduced (cityp, city_count)
-           || (cityp->prod > FIGHTER && is_lake) )
-               comp_set_needed (cityp, city_count, interest, is_lake);
+    if (cityp->prod == NOPIECE
+       || (cityp->prod == ARMY && counts.comp_cities == 1)
+       || overproduced (cityp, city_count)
+       || (cityp->prod > FIGHTER && is_lake) )
+       comp_set_needed (cityp, city_count, interest, is_lake);
 }
        
 /*
@@ -260,11 +264,11 @@ reset production if it is already correct.
 void
 comp_set_prod(city_info_t *cityp, int type)
 {
-       if (cityp->prod == type) return;
+    if (cityp->prod == type) return;
        
-       pdebug ("Changing city prod at %d from %d to %d\n",loc_disp(cityp->loc), cityp->prod, type);
-       cityp->prod = type;
-       cityp->work = -(piece_attr[type].build_time / 5);
+    pdebug ("Changing city prod at %d from %d to %d\n",loc_disp(cityp->loc), cityp->prod, type);
+    cityp->prod = type;
+    cityp->work = -(piece_attr[type].build_time / 5);
 }
 
 /*
@@ -274,16 +278,16 @@ See if a city is producing an object which is being overproduced.
 bool
 overproduced(city_info_t *cityp, int *city_count)
 {
-       int i;
-
-       for (i = 0; i < NUM_OBJECTS; i++) {
-               /* return true if changing production would improve balance */
-               if (i != cityp->prod
-                && ((city_count[(int)cityp->prod] - 1) * ratio[i]
-                  > (city_count[i] + 1) * ratio[(int)cityp->prod]))
-               return true;
-       }
-       return false;
+    int i;
+
+    for (i = 0; i < NUM_OBJECTS; i++) {
+       /* return true if changing production would improve balance */
+       if (i != cityp->prod
+           && ((city_count[(int)cityp->prod] - 1) * ratio[i]
+               > (city_count[i] + 1) * ratio[(int)cityp->prod]))
+           return true;
+    }
+    return false;
 }
 
 /*
@@ -309,23 +313,23 @@ a flag telling us if armies are ok to produce.
 void
 comp_set_needed(city_info_t *cityp, int *city_count, bool army_ok, bool is_lake)
 {
-       int best_prod;
-       int prod;
+    int best_prod;
+    int prod;
 
-       if (!army_ok) city_count[ARMY] = INFINITY;
+    if (!army_ok) city_count[ARMY] = INFINITY;
 
-       if (is_lake) { /* choose fighter or army */
-               comp_set_prod (cityp, need_more (city_count, ARMY, FIGHTER));
-               return;
-       }
-       /* don't choose fighter */
-       city_count[FIGHTER] = INFINITY;
+    if (is_lake) { /* choose fighter or army */
+       comp_set_prod (cityp, need_more (city_count, ARMY, FIGHTER));
+       return;
+    }
+    /* don't choose fighter */
+    city_count[FIGHTER] = INFINITY;
        
-       best_prod = ARMY; /* default */
-       for (prod = 0; prod < NUM_OBJECTS; prod++) {
-               best_prod = need_more (city_count, best_prod, prod);
-       }
-       comp_set_prod (cityp, best_prod);
+    best_prod = ARMY; /* default */
+    for (prod = 0; prod < NUM_OBJECTS; prod++) {
+       best_prod = need_more (city_count, best_prod, prod);
+    }
+    comp_set_prod (cityp, best_prod);
 }
 
 /*
@@ -343,13 +347,13 @@ have unexplored territory on the edges.
 bool
 lake(loc_t loc)
 {
-       int cont_map[MAP_SIZE];
-       scan_counts_t counts;
+    int cont_map[MAP_SIZE];
+    scan_counts_t counts;
 
-       vmap_cont (cont_map, emap, loc, '+'); /* map lake */
-       counts = vmap_cont_scan (cont_map, emap);
+    vmap_cont (cont_map, emap, loc, '+'); /* map lake */
+    counts = vmap_cont_scan (cont_map, emap);
 
-       return !(counts.unowned_cities || counts.user_cities || counts.unexplored);
+    return !(counts.unowned_cities || counts.user_cities || counts.unexplored);
 }
 
 /*
@@ -360,19 +364,20 @@ static view_map_t amap[MAP_SIZE]; /* temp view map */
 static path_map_t path_map[MAP_SIZE];
 
 void
-do_pieces(void) { /* move pieces */
-       void cpiece_move();
-
-       int i;
-       piece_info_t *obj, *next_obj;
-
-       for (i = 0; i < NUM_OBJECTS; i++) { /* loop through obj lists */
-               for (obj = comp_obj[move_order[i]]; obj != NULL;
-                   obj = next_obj) { /* loop through objs in list */
-                       next_obj = obj->piece_link.next;
-                       cpiece_move (obj); /* yup; move the object */
-               }
+do_pieces(void) 
+{
+    void cpiece_move();
+
+    int i;
+    piece_info_t *obj, *next_obj;
+
+    for (i = 0; i < NUM_OBJECTS; i++) { /* loop through obj lists */
+       for (obj = comp_obj[move_order[i]]; obj != NULL;
+            obj = next_obj) { /* loop through objs in list */
+           next_obj = obj->piece_link.next;
+           cpiece_move (obj); /* yup; move the object */
        }
+    }
 }
 
 /*
@@ -384,48 +389,48 @@ objective.
 void
 cpiece_move(piece_info_t *obj)
 {
-       void move1();
+    void move1();
 
-       bool changed_loc;
-       int max_hits;
-       loc_t saved_loc;
-       city_info_t *cityp;
+    bool changed_loc;
+    int max_hits;
+    loc_t saved_loc;
+    city_info_t *cityp;
 
-       if (obj->type == SATELLITE) {
-               move_sat (obj);
-               return;
-       }
+    if (obj->type == SATELLITE) {
+       move_sat (obj);
+       return;
+    }
        
-       obj->moved = 0; /* not moved yet */
-       changed_loc = false; /* not changed yet */
-       max_hits = piece_attr[obj->type].max_hits;
-
-       if (obj->type == FIGHTER) { /* init fighter range */
-               cityp = find_city (obj->loc);
-               if (cityp != NULL) obj->range = piece_attr[FIGHTER].range;
-       }
+    obj->moved = 0; /* not moved yet */
+    changed_loc = false; /* not changed yet */
+    max_hits = piece_attr[obj->type].max_hits;
+
+    if (obj->type == FIGHTER) { /* init fighter range */
+       cityp = find_city (obj->loc);
+       if (cityp != NULL) obj->range = piece_attr[FIGHTER].range;
+    }
        
-       while (obj->moved < obj_moves (obj)) {
-               saved_loc = obj->loc; /* remember starting location */
-               move1 (obj);
-               if (saved_loc != obj->loc) changed_loc = true;
+    while (obj->moved < obj_moves (obj)) {
+       saved_loc = obj->loc; /* remember starting location */
+       move1 (obj);
+       if (saved_loc != obj->loc) changed_loc = true;
                
-               if (obj->type == FIGHTER && obj->hits > 0) {
-                       if (comp_map[obj->loc].contents == 'X')
-                               obj->moved = piece_attr[FIGHTER].speed;
-                       else if (obj->range == 0) {
-                               pdebug ("Fighter at %d crashed and burned\n", loc_disp(obj->loc));
-                               ksend ("Fighter at %d crashed and burned\n", loc_disp(obj->loc));
-                               kill_obj (obj, obj->loc); /* crash & burn */
-                       }
-               }
+       if (obj->type == FIGHTER && obj->hits > 0) {
+           if (comp_map[obj->loc].contents == 'X')
+               obj->moved = piece_attr[FIGHTER].speed;
+           else if (obj->range == 0) {
+               pdebug ("Fighter at %d crashed and burned\n", loc_disp(obj->loc));
+               ksend ("Fighter at %d crashed and burned\n", loc_disp(obj->loc));
+               kill_obj (obj, obj->loc); /* crash & burn */
+           }
        }
-       /* if a boat is in port, damaged, and never moved, fix some damage */
-       if (obj->hits > 0 /* live piece? */
-               && !changed_loc /* object never changed location? */
-               && obj->type != ARMY && obj->type != FIGHTER /* it is a boat? */
-               && obj->hits != max_hits /* it is damaged? */
-               && comp_map[obj->loc].contents == 'X') /* it is in port? */
+    }
+    /* if a boat is in port, damaged, and never moved, fix some damage */
+    if (obj->hits > 0 /* live piece? */
+       && !changed_loc /* object never changed location? */
+       && obj->type != ARMY && obj->type != FIGHTER /* it is a boat? */
+       && obj->hits != max_hits /* it is damaged? */
+       && comp_map[obj->loc].contents == 'X') /* it is in port? */
        obj->hits++; /* fix some damage */
 }
 
@@ -436,14 +441,14 @@ Move a piece one square.
 void
 move1(piece_info_t *obj)
 {
-       void army_move(), transport_move(), fighter_move(), ship_move();
-
-       switch (obj->type) {
-       case ARMY: army_move (obj); break;
-       case TRANSPORT: transport_move (obj); break;
-       case FIGHTER: fighter_move (obj); break;
-       default: ship_move (obj); break;
-       }
+    void army_move(), transport_move(), fighter_move(), ship_move();
+
+    switch (obj->type) {
+    case ARMY: army_move (obj); break;
+    case TRANSPORT: transport_move (obj); break;
+    case FIGHTER: fighter_move (obj); break;
+    default: ship_move (obj); break;
+    }
 }
 
 /*
@@ -478,80 +483,80 @@ destination.  (If there is no destination, sit around and wait.)
 void
 army_move(piece_info_t *obj)
 {
-       loc_t move_away();
-       loc_t find_attack();
-       void make_army_load_map(), make_unload_map(), make_tt_load_map();
-       void board_ship();
+    loc_t move_away();
+    loc_t find_attack();
+    void make_army_load_map(), make_unload_map(), make_tt_load_map();
+    void board_ship();
        
-       loc_t new_loc;
-       path_map_t path_map2[MAP_SIZE];
-       loc_t new_loc2;
-       int cross_cost = 0; /* cost to enter water */
+    loc_t new_loc;
+    path_map_t path_map2[MAP_SIZE];
+    int cross_cost = 0; /* cost to enter water */
        
-       obj->func = 0; /* army doesn't want a tt */
-       if (vmap_at_sea (comp_map, obj->loc)) { /* army can't move? */
-               (void) load_army (obj);
-               obj->moved = piece_attr[ARMY].speed;
-               if (!obj->ship) obj->func = 1; /* load army on ship */
-               return;
-       }
-       if (obj->ship) /* is army on a transport? */
-               new_loc = find_attack (obj->loc, army_attack, "+*");
-       else new_loc = find_attack (obj->loc, army_attack, ".+*");
+    obj->func = 0; /* army doesn't want a tt */
+    if (vmap_at_sea (comp_map, obj->loc)) { /* army can't move? */
+       (void) load_army (obj);
+       obj->moved = piece_attr[ARMY].speed;
+       if (!obj->ship) obj->func = 1; /* load army on ship */
+       return;
+    }
+    if (obj->ship) /* is army on a transport? */
+       new_loc = find_attack (obj->loc, army_attack, "+*");
+    else new_loc = find_attack (obj->loc, army_attack, ".+*");
                
-       if (new_loc != obj->loc) { /* something to attack? */
-               attack (obj, new_loc); /* attack it */
-               if (map[new_loc].contents == '.' /* moved to ocean? */
-                 && obj->hits > 0) { /* object still alive? */
-                       kill_obj (obj, new_loc);
-                       scan (user_map, new_loc); /* rescan for user */
-               }
-               return;
+    if (new_loc != obj->loc) { /* something to attack? */
+       attack (obj, new_loc); /* attack it */
+       if (map[new_loc].contents == '.' /* moved to ocean? */
+           && obj->hits > 0) { /* object still alive? */
+           kill_obj (obj, new_loc);
+           scan (user_map, new_loc); /* rescan for user */
        }
-       if (obj->ship) {
-               if (obj->ship->func == 0) {
-                       if (!load_army (obj)) ABORT; /* load army on best ship */
-                       return; /* armies stay on a loading ship */
-               }
-               make_unload_map (amap, comp_map);
-               new_loc = vmap_find_wlobj (path_map, amap, obj->loc, &tt_unload);
-               move_objective (obj, path_map, new_loc, " ");
-               return;
+       return;
+    }
+    if (obj->ship) {
+       if (obj->ship->func == 0) {
+           if (!load_army (obj)) ABORT; /* load army on best ship */
+           return; /* armies stay on a loading ship */
        }
+       make_unload_map (amap, comp_map);
+       new_loc = vmap_find_wlobj (path_map, amap, obj->loc, &tt_unload);
+       move_objective (obj, path_map, new_loc, " ");
+       return;
+    }
 
-       new_loc = vmap_find_lobj (path_map, comp_map, obj->loc, &army_fight);
+    new_loc = vmap_find_lobj (path_map, comp_map, obj->loc, &army_fight);
        
-       if (new_loc != obj->loc) { /* something interesting on land? */
-               switch (comp_map[new_loc].contents) {
-               case 'A':
-               case 'O':
-                       cross_cost = 60; /* high cost if enemy present */
-                       break;
-               case '*':
-                       cross_cost = 30; /* medium cost for attackable city */
-                       break;
-               case ' ':
-                       cross_cost = 14; /* low cost for exploring */
-                       break;
-               default:
-                       ABORT;
-               }
-               cross_cost = path_map[new_loc].cost * 2 - cross_cost;
+    if (new_loc != obj->loc) { /* something interesting on land? */
+       switch (comp_map[new_loc].contents) {
+       case 'A':
+       case 'O':
+           cross_cost = 60; /* high cost if enemy present */
+           break;
+       case '*':
+           cross_cost = 30; /* medium cost for attackable city */
+           break;
+       case ' ':
+           cross_cost = 14; /* low cost for exploring */
+           break;
+       default:
+           ABORT;
        }
-       else cross_cost = INFINITY;
+       cross_cost = path_map[new_loc].cost * 2 - cross_cost;
+    }
+    else cross_cost = INFINITY;
        
-       if (new_loc == obj->loc || cross_cost > 0) {
-               /* see if there is something interesting to load */
-               make_army_load_map (obj, amap, comp_map);
-               new_loc2 = vmap_find_lwobj (path_map2, amap, obj->loc, &army_load, cross_cost);
+    if (new_loc == obj->loc || cross_cost > 0) {
+       loc_t new_loc2;
+       /* see if there is something interesting to load */
+       make_army_load_map (obj, amap, comp_map);
+       new_loc2 = vmap_find_lwobj (path_map2, amap, obj->loc, &army_load, cross_cost);
                
-               if (new_loc2 != obj->loc) { /* found something? */
-                       board_ship (obj, path_map2, new_loc2);
-                       return;
-               }
+       if (new_loc2 != obj->loc) { /* found something? */
+           board_ship (obj, path_map2, new_loc2);
+           return;
        }
+    }
 
-       move_objective (obj, path_map, new_loc, " ");
+    move_objective (obj, path_map, new_loc, " ");
 }
 
 /*
@@ -561,11 +566,11 @@ Remove pruned explore locs from a view map.
 void
 unmark_explore_locs(view_map_t *xmap)
 {
-       count_t i;
+    count_t i;
 
-       for (i = 0; i < MAP_SIZE; i++)
-                if (map[i].on_board && xmap[i].contents == ' ')
-                        xmap[i].contents = emap[i].contents;
+    for (i = 0; i < MAP_SIZE; i++)
+       if (map[i].on_board && xmap[i].contents == ' ')
+           xmap[i].contents = emap[i].contents;
 }
 
 /*
@@ -576,25 +581,25 @@ transport and tt producing city with a '$'.
 void
 make_army_load_map(piece_info_t *obj, view_map_t *xmap, view_map_t *vmap)
 {
-       piece_info_t *p;
-       int i;
+    piece_info_t *p;
+    int i;
        
-       (void) memcpy (xmap, vmap, sizeof (view_map_t) * MAP_SIZE);
+    (void) memcpy (xmap, vmap, sizeof (view_map_t) * MAP_SIZE);
 
-       /* mark loading transports or cities building transports */
-       for (p = comp_obj[TRANSPORT]; p; p = p->piece_link.next)
+    /* mark loading transports or cities building transports */
+    for (p = comp_obj[TRANSPORT]; p; p = p->piece_link.next)
        if (p->func == 0) /* loading tt? */
-       xmap[p->loc].contents = '$';
+           xmap[p->loc].contents = '$';
        
-       for (i = 0; i < NUM_CITY; i++)
+    for (i = 0; i < NUM_CITY; i++)
        if (city[i].owner == COMP && city[i].prod == TRANSPORT) {
-               if (nearby_load (obj, city[i].loc))
-                       xmap[city[i].loc].contents = 'x'; /* army is nearby so it can load */
-               else if (nearby_count (city[i].loc) < piece_attr[TRANSPORT].capacity)
-                       xmap[city[i].loc].contents = 'x'; /* city needs armies */
+           if (nearby_load (obj, city[i].loc))
+               xmap[city[i].loc].contents = 'x'; /* army is nearby so it can load */
+           else if (nearby_count (city[i].loc) < piece_attr[TRANSPORT].capacity)
+               xmap[city[i].loc].contents = 'x'; /* city needs armies */
        }
        
-       if (print_vmap == 'A') print_xzoom (xmap);
+    if (print_vmap == 'A') print_xzoom (xmap);
 }
 
 /* Return true if an army is considered near a location for loading. */
@@ -610,14 +615,14 @@ nearby_load(piece_info_t *obj, loc_t loc)
 count_t
 nearby_count(loc_t loc)
 {
-       piece_info_t *obj;
-       int count;
-
-       count = 0;
-       for (obj = comp_obj[ARMY]; obj; obj = obj->piece_link.next) {
-               if (nearby_load (obj, loc)) count += 1;
-       }
-       return count;
+    piece_info_t *obj;
+    int count;
+
+    count = 0;
+    for (obj = comp_obj[ARMY]; obj; obj = obj->piece_link.next) {
+       if (nearby_load (obj, loc)) count += 1;
+    }
+    return count;
 }
 
 /* Make load map for a ship. */
@@ -625,16 +630,17 @@ nearby_count(loc_t loc)
 void
 make_tt_load_map(view_map_t *xmap, view_map_t *vmap)
 {
-       piece_info_t *p;
+    piece_info_t *p;
        
-       (void) memcpy (xmap, vmap, sizeof (view_map_t) * MAP_SIZE);
+    (void) memcpy (xmap, vmap, sizeof (view_map_t) * MAP_SIZE);
 
-       /* mark loading armies */
-       for (p = comp_obj[ARMY]; p; p = p->piece_link.next)
+    /* mark loading armies */
+    for (p = comp_obj[ARMY]; p; p = p->piece_link.next)
        if (p->func == 1) /* loading army? */
-       xmap[p->loc].contents = '$';
+           xmap[p->loc].contents = '$';
        
-       if (print_vmap == 'L') print_xzoom (xmap);
+    if (print_vmap == 'L')
+       print_xzoom (xmap);
 }
        
 /*
@@ -670,45 +676,45 @@ static int tcont_map[MAP_SIZE];
 void
 make_unload_map(view_map_t *xmap, view_map_t *vmap)
 {
-       count_t i;
-       scan_counts_t counts;
+    count_t i;
+    scan_counts_t counts;
 
-       (void) memcpy (xmap, vmap, sizeof (view_map_t) * MAP_SIZE);
-       unmark_explore_locs (xmap);
+    (void) memcpy (xmap, vmap, sizeof (view_map_t) * MAP_SIZE);
+    unmark_explore_locs (xmap);
        
-       for (i = 0; i < MAP_SIZE; i++)
-               owncont_map[i] = 0; /* nothing marked */
+    for (i = 0; i < MAP_SIZE; i++)
+       owncont_map[i] = 0; /* nothing marked */
 
-       for (i = 0; i < NUM_CITY; i++)
+    for (i = 0; i < NUM_CITY; i++)
        if (city[i].owner == COMP)
-       vmap_mark_up_cont (owncont_map, xmap, city[i].loc, '.');
+           vmap_mark_up_cont (owncont_map, xmap, city[i].loc, '.');
 
-       for (i = 0; i < MAP_SIZE; i++)
+    for (i = 0; i < MAP_SIZE; i++)
        if (strchr ("O*", vmap[i].contents)) {
-               int total_cities;
+           int total_cities;
                
-               vmap_cont (tcont_map, xmap, i, '.'); /* map continent */
-               counts = vmap_cont_scan (tcont_map, xmap);
+           vmap_cont (tcont_map, xmap, i, '.'); /* map continent */
+           counts = vmap_cont_scan (tcont_map, xmap);
                
-               total_cities = counts.unowned_cities
-                            + counts.user_cities
-                            + counts.comp_cities;
+           total_cities = counts.unowned_cities
+               + counts.user_cities
+               + counts.comp_cities;
                             
-               if (total_cities > 9) total_cities = 0;
+           if (total_cities > 9) total_cities = 0;
                
-               if (counts.user_cities && counts.comp_cities)
-                       xmap[i].contents = '0' + total_cities;
+           if (counts.user_cities && counts.comp_cities)
+               xmap[i].contents = '0' + total_cities;
 
-               else if (counts.unowned_cities > counts.user_cities
-                        && counts.comp_cities == 0)
-                       xmap[i].contents = '0' + total_cities;
+           else if (counts.unowned_cities > counts.user_cities
+                    && counts.comp_cities == 0)
+               xmap[i].contents = '0' + total_cities;
 
-               else if (counts.user_cities == 1 && counts.comp_cities == 0)
-                       xmap[i].contents = '2';
+           else if (counts.user_cities == 1 && counts.comp_cities == 0)
+               xmap[i].contents = '2';
                        
-               else xmap[i].contents = '0';
+           else xmap[i].contents = '0';
        }
-       if (print_vmap == 'U') print_xzoom (xmap);
+    if (print_vmap == 'U') print_xzoom (xmap);
 }
 
 /*
@@ -720,10 +726,10 @@ close to the ocean.
 void
 board_ship(piece_info_t *obj, path_map_t *pmap, loc_t dest)
 {
-       if (!load_army (obj)) {
-               obj->func = 1; /* loading */
-               move_objective (obj, pmap, dest, "t.");
-       }
+    if (!load_army (obj)) {
+       obj->func = 1; /* loading */
+       move_objective (obj, pmap, dest, "t.");
+    }
 }
 
 /*
@@ -735,14 +741,14 @@ one of the ships to become more full.
 piece_info_t *
 find_best_tt(piece_info_t *best, loc_t loc)
 {
-       piece_info_t *p;
+    piece_info_t *p;
 
-       for (p = map[loc].objp; p != NULL; p = p->loc_link.next)
+    for (p = map[loc].objp; p != NULL; p = p->loc_link.next)
        if (p->type == TRANSPORT && obj_capacity (p) > p->count) {
-               if (!best) best = p;
-               else if (p->count >= best->count) best = p;
+           if (!best) best = p;
+           else if (p->count >= best->count) best = p;
        }
-       return best;
+    return best;
 }
 
 /*
@@ -752,30 +758,30 @@ Load an army onto the most full non-full ship.
 bool
 load_army(piece_info_t *obj)
 {
-       piece_info_t *p;
-       int i;
-       loc_t x_loc;
-
-       p = find_best_tt (obj->ship, obj->loc); /* look here first */
-
-       for (i = 0; i < 8; i++) { /* try surrounding squares */
-               x_loc = obj->loc + dir_offset[i];
-               if (map[x_loc].on_board)
-                       p = find_best_tt (p, x_loc);
-
-       }
-       if (!p) return false; /* no tt to be found */
-
-       if (p->loc == obj->loc) { /* stay in same place */
-               obj->moved = piece_attr[ARMY].speed;
-       }
-       else move_obj (obj, p->loc); /* move to square with ship */
-
-       if (p->ship != obj->ship) { /* reload army to new ship */
-               disembark (obj);
-               embark (p, obj);
-       }
-       return true;
+    piece_info_t *p;
+    int i;
+    loc_t x_loc;
+
+    p = find_best_tt (obj->ship, obj->loc); /* look here first */
+
+    for (i = 0; i < 8; i++) { /* try surrounding squares */
+       x_loc = obj->loc + dir_offset[i];
+       if (map[x_loc].on_board)
+           p = find_best_tt (p, x_loc);
+
+    }
+    if (!p) return false; /* no tt to be found */
+
+    if (p->loc == obj->loc) { /* stay in same place */
+       obj->moved = piece_attr[ARMY].speed;
+    }
+    else move_obj (obj, p->loc); /* move to square with ship */
+
+    if (p->ship != obj->ship) { /* reload army to new ship */
+       disembark (obj);
+       embark (p, obj);
+    }
+    return true;
 }
 
 /*
@@ -786,16 +792,16 @@ the correct terrain.
 loc_t
 move_away(view_map_t *vmap, loc_t loc, char *terrain)
 {
-       loc_t new_loc;
-       int i;
-
-       for (i = 0; i < 8; i++) {
-               new_loc = loc + dir_offset[i];
-               if (map[new_loc].on_board
-                && strchr (terrain, vmap[new_loc].contents))
-                       return (new_loc);
-       }
-       return (loc);
+    loc_t new_loc;
+    int i;
+
+    for (i = 0; i < 8; i++) {
+       new_loc = loc + dir_offset[i];
+       if (map[new_loc].on_board
+           && strchr (terrain, vmap[new_loc].contents))
+           return (new_loc);
+    }
+    return (loc);
 }
 
 /*
@@ -809,25 +815,25 @@ best of these.
 loc_t
 find_attack(loc_t loc, char *obj_list, char *terrain)
 {
-       loc_t new_loc, best_loc;
-       int i, best_val;
-       char *p;
-
-       best_loc = loc; /* nothing found yet */
-       best_val = INFINITY;
-       for (i = 0; i < 8; i++) {
-               new_loc = loc + dir_offset[i];
-
-               if (map[new_loc].on_board /* can we move here? */
-                   && strchr (terrain, map[new_loc].contents)) {
-                       p = strchr (obj_list, comp_map[new_loc].contents);
-                       if (p != NULL && p - obj_list < best_val) {
-                               best_val = p - obj_list;
-                               best_loc = new_loc;
-                       }
-               }
+    loc_t new_loc, best_loc;
+    int i, best_val;
+    char *p;
+
+    best_loc = loc; /* nothing found yet */
+    best_val = INFINITY;
+    for (i = 0; i < 8; i++) {
+       new_loc = loc + dir_offset[i];
+
+       if (map[new_loc].on_board /* can we move here? */
+           && strchr (terrain, map[new_loc].contents)) {
+           p = strchr (obj_list, comp_map[new_loc].contents);
+           if (p != NULL && p - obj_list < best_val) {
+               best_val = p - obj_list;
+               best_loc = new_loc;
+           }
        }
-       return (best_loc);
+    }
+    return (best_loc);
 }
 
 /*
@@ -845,41 +851,41 @@ Transports become 'loading' when empty, and 'unloading' when full.
 void
 transport_move(piece_info_t *obj)
 {
-       void tt_do_move();
-
-       loc_t new_loc;
-
-       /* empty transports can attack */
-       if (obj->count == 0) { /* empty? */
-               obj->func = 0; /* transport is loading */
-               new_loc = find_attack (obj->loc, tt_attack, ".");
-               if (new_loc != obj->loc) { /* something to attack? */
-                       attack (obj, new_loc); /* attack it */
-                       return;
-               }
+    void tt_do_move();
+
+    loc_t new_loc;
+
+    /* empty transports can attack */
+    if (obj->count == 0) { /* empty? */
+       obj->func = 0; /* transport is loading */
+       new_loc = find_attack (obj->loc, tt_attack, ".");
+       if (new_loc != obj->loc) { /* something to attack? */
+           attack (obj, new_loc); /* attack it */
+           return;
        }
+    }
 
-       if (obj->count == obj_capacity (obj)) /* full? */
-               obj->func = 1; /* unloading */
+    if (obj->count == obj_capacity (obj)) /* full? */
+       obj->func = 1; /* unloading */
 
-       if (obj->func == 0) { /* loading? */
-               make_tt_load_map (amap, comp_map);
-               new_loc = vmap_find_wlobj (path_map, amap, obj->loc, &tt_load);
+    if (obj->func == 0) { /* loading? */
+       make_tt_load_map (amap, comp_map);
+       new_loc = vmap_find_wlobj (path_map, amap, obj->loc, &tt_load);
                
-               if (new_loc == obj->loc) { /* nothing to load? */
-                       (void) memcpy (amap, comp_map, MAP_SIZE * sizeof (view_map_t));
-                       unmark_explore_locs (amap);
-                       if (print_vmap == 'S') print_xzoom (amap);
-                       new_loc = vmap_find_wobj (path_map, amap, obj->loc,&tt_explore);
-               }
-               
-               move_objective (obj, path_map, new_loc, "a ");
-       }
-       else {
-               make_unload_map (amap, comp_map);
-               new_loc = vmap_find_wlobj (path_map, amap, obj->loc, &tt_unload);
-               move_objective (obj, path_map, new_loc, " ");
+       if (new_loc == obj->loc) { /* nothing to load? */
+           (void) memcpy (amap, comp_map, MAP_SIZE * sizeof (view_map_t));
+           unmark_explore_locs (amap);
+           if (print_vmap == 'S') print_xzoom (amap);
+           new_loc = vmap_find_wobj (path_map, amap, obj->loc,&tt_explore);
        }
+               
+       move_objective (obj, path_map, new_loc, "a ");
+    }
+    else {
+       make_unload_map (amap, comp_map);
+       new_loc = vmap_find_wlobj (path_map, amap, obj->loc, &tt_unload);
+       move_objective (obj, path_map, new_loc, " ");
+    }
 }
 
 /*
@@ -897,26 +903,26 @@ if there is one in range.
 void
 fighter_move(piece_info_t *obj)
 {
-       loc_t new_loc;
-
-       new_loc = find_attack (obj->loc, fighter_attack, ".+");
-       if (new_loc != obj->loc) { /* something to attack? */
-               attack (obj, new_loc); /* attack it */
-               return;
-       }
-       /* return to base if low on fuel */
-       if (obj->range <= find_nearest_city (obj->loc, COMP, &new_loc) + 2) {
-               if (new_loc != obj->loc)
-                       new_loc = vmap_find_dest (path_map, comp_map, obj->loc,
-                                                 new_loc, COMP, T_AIR);
-       }
-       else new_loc = obj->loc;
+    loc_t new_loc;
+
+    new_loc = find_attack (obj->loc, fighter_attack, ".+");
+    if (new_loc != obj->loc) { /* something to attack? */
+       attack (obj, new_loc); /* attack it */
+       return;
+    }
+    /* return to base if low on fuel */
+    if (obj->range <= find_nearest_city (obj->loc, COMP, &new_loc) + 2) {
+       if (new_loc != obj->loc)
+           new_loc = vmap_find_dest (path_map, comp_map, obj->loc,
+                                     new_loc, COMP, T_AIR);
+    }
+    else new_loc = obj->loc;
        
-       if (new_loc == obj->loc) { /* no nearby city? */
-               new_loc = vmap_find_aobj (path_map, comp_map, obj->loc,
-                                              &fighter_fight);
-       }
-       move_objective (obj, path_map, new_loc, " ");
+    if (new_loc == obj->loc) { /* no nearby city? */
+       new_loc = vmap_find_aobj (path_map, comp_map, obj->loc,
+                                 &fighter_fight);
+    }
+    move_objective (obj, path_map, new_loc, " ");
 }
 
 /*
@@ -929,34 +935,34 @@ something to attack.
 void
 ship_move(piece_info_t *obj)
 {
-       loc_t new_loc;
-       char *adj_list;
+    loc_t new_loc;
+    char *adj_list;
 
-       if (obj->hits < piece_attr[obj->type].max_hits) { /* head to port */
-               if (comp_map[obj->loc].contents == 'X') { /* stay in port */
-                       obj->moved = piece_attr[obj->type].speed;
-                       return;
-               }
-               new_loc = vmap_find_wobj (path_map, comp_map, obj->loc, &ship_repair);
-               adj_list = ".";
+    if (obj->hits < piece_attr[obj->type].max_hits) { /* head to port */
+       if (comp_map[obj->loc].contents == 'X') { /* stay in port */
+           obj->moved = piece_attr[obj->type].speed;
+           return;
+       }
+       new_loc = vmap_find_wobj (path_map, comp_map, obj->loc, &ship_repair);
+       adj_list = ".";
 
+    }
+    else {
+       new_loc = find_attack (obj->loc, ship_attack, ".");
+       if (new_loc != obj->loc) { /* something to attack? */
+           attack (obj, new_loc); /* attack it */
+           return;
        }
-       else {
-               new_loc = find_attack (obj->loc, ship_attack, ".");
-               if (new_loc != obj->loc) { /* something to attack? */
-                       attack (obj, new_loc); /* attack it */
-                       return;
-               }
-               /* look for an objective */
-               (void) memcpy (amap, comp_map, MAP_SIZE * sizeof (view_map_t));
-               unmark_explore_locs (amap);
-               if (print_vmap == 'S') print_xzoom (amap);
+       /* look for an objective */
+       (void) memcpy (amap, comp_map, MAP_SIZE * sizeof (view_map_t));
+       unmark_explore_locs (amap);
+       if (print_vmap == 'S') print_xzoom (amap);
                
-               new_loc = vmap_find_wobj (path_map, amap, obj->loc,&ship_fight);
-               adj_list = ship_fight.objectives;
-       }
+       new_loc = vmap_find_wobj (path_map, amap, obj->loc,&ship_fight);
+       adj_list = ship_fight.objectives;
+    }
 
-       move_objective (obj, path_map, new_loc, adj_list);
+    move_objective (obj, path_map, new_loc, adj_list);
 }
 
 /*
@@ -967,101 +973,101 @@ void
 move_objective(piece_info_t *obj, path_map_t pathmap[], 
                loc_t new_loc, char *adj_list)
 {
-       char *terrain;
-       char *attack_list;
-       int d;
-       int reuse; /* true iff we should reuse old map */
-       loc_t old_loc;
-       loc_t old_dest;
+    char *terrain;
+    int d;
+    int reuse; /* true iff we should reuse old map */
+    loc_t old_loc;
+    loc_t old_dest;
        
-       if (new_loc == obj->loc) {
-               obj->moved = piece_attr[obj->type].speed;
-               obj->range -= 1;
-               pdebug ("No destination found for %d at %d; func=%d\n", obj->type, loc_disp(obj->loc), obj->func);
-               return;
-       }
-       old_loc = obj->loc; /* remember where we are */
-       old_dest = new_loc; /* and where we're going */
+    if (new_loc == obj->loc) {
+       obj->moved = piece_attr[obj->type].speed;
+       obj->range -= 1;
+       pdebug ("No destination found for %d at %d; func=%d\n", obj->type, loc_disp(obj->loc), obj->func);
+       return;
+    }
+    old_loc = obj->loc; /* remember where we are */
+    old_dest = new_loc; /* and where we're going */
        
-       d = dist (new_loc, obj->loc);
-       reuse = 1; /* try to reuse unless we learn otherwise */
+    d = dist (new_loc, obj->loc);
+    reuse = 1; /* try to reuse unless we learn otherwise */
        
-       if (comp_map[new_loc].contents == ' ' && d == 2) { /* are we exploring? */
-               vmap_mark_adjacent (pathmap, obj->loc);
-               reuse = 0;
-       }
-       else vmap_mark_path (pathmap, comp_map, new_loc); /* find routes to destination */
+    if (comp_map[new_loc].contents == ' ' && d == 2) { /* are we exploring? */
+       vmap_mark_adjacent (pathmap, obj->loc);
+       reuse = 0;
+    }
+    else vmap_mark_path (pathmap, comp_map, new_loc); /* find routes to destination */
        
-       /* path terrain and move terrain may differ */
-       switch (obj->type) {
-       case ARMY: terrain = "+"; break;
-       case FIGHTER: terrain = "+.X"; break;
-       default: terrain = ".X"; break;
-       }
+    /* path terrain and move terrain may differ */
+    switch (obj->type) {
+    case ARMY: terrain = "+"; break;
+    case FIGHTER: terrain = "+.X"; break;
+    default: terrain = ".X"; break;
+    }
        
+    new_loc = vmap_find_dir (pathmap, comp_map, obj->loc,
+                            terrain, adj_list);
+       
+    if (new_loc == obj->loc /* path is blocked? */
+       && (obj->type != ARMY || !obj->ship)) { /* don't unblock armies on a ship */
+       vmap_mark_near_path (pathmap, obj->loc);
+       reuse = 0;
        new_loc = vmap_find_dir (pathmap, comp_map, obj->loc,
                                 terrain, adj_list);
+    }
        
-       if (new_loc == obj->loc /* path is blocked? */
-           && (obj->type != ARMY || !obj->ship)) { /* don't unblock armies on a ship */
-               vmap_mark_near_path (pathmap, obj->loc);
-               reuse = 0;
-               new_loc = vmap_find_dir (pathmap, comp_map, obj->loc,
-                                        terrain, adj_list);
-       }
-       
-       /* encourage army to leave city */
-       if (new_loc == obj->loc && map[obj->loc].cityp != NULL
-                               && obj->type == ARMY) {
-               new_loc = move_away (comp_map, obj->loc, "+");
-               reuse = 0;
-       }
-       if (new_loc == obj->loc) {
-               obj->moved = piece_attr[obj->type].speed;
+    /* encourage army to leave city */
+    if (new_loc == obj->loc && map[obj->loc].cityp != NULL
+       && obj->type == ARMY) {
+       new_loc = move_away (comp_map, obj->loc, "+");
+       reuse = 0;
+    }
+    if (new_loc == obj->loc) {
+       obj->moved = piece_attr[obj->type].speed;
                
-               if (obj->type == ARMY && obj->ship) ;
-               else pdebug ("Cannot move %d at %d toward objective; func=%d\n", obj->type, loc_disp(obj->loc), obj->func);
-       }
-       else move_obj (obj, new_loc);
+       if (obj->type == ARMY && obj->ship) ;
+       else pdebug ("Cannot move %d at %d toward objective; func=%d\n", obj->type, loc_disp(obj->loc), obj->func);
+    }
+    else move_obj (obj, new_loc);
        
-       /* Try to make more moves using same path map. */
-       if (reuse && obj->moved < obj_moves (obj) && obj->loc != old_dest) {
-               /* check for immediate attack */
-               switch (obj->type) {
-               case FIGHTER:
-                       if (comp_map[old_dest].contents != 'X' /* watch fuel */
-                               && obj->range <= piece_attr[FIGHTER].range / 2)
-                                       return;
-                       attack_list = fighter_attack;
-                       terrain = "+.";
-                       break;
-               case ARMY:
-                       attack_list = army_attack;
-                       if (obj->ship) terrain = "+*";
-                       else terrain = "+.*";
-                       break;
-               case TRANSPORT:
-                       terrain = ".*";
-                       if (obj->cargo) attack_list = tt_attack;
-                       else attack_list = "*O"; /* causes tt to wake up */
-                       break;
-               default:
-                       attack_list = ship_attack;
-                       terrain = ".";
-                       break;
-               }
-               if (find_attack (obj->loc, attack_list, terrain) != obj->loc)
-                       return;
+    /* Try to make more moves using same path map. */
+    if (reuse && obj->moved < obj_moves (obj) && obj->loc != old_dest) {
+       char *attack_list;
+       /* check for immediate attack */
+       switch (obj->type) {
+       case FIGHTER:
+           if (comp_map[old_dest].contents != 'X' /* watch fuel */
+               && obj->range <= piece_attr[FIGHTER].range / 2)
+               return;
+           attack_list = fighter_attack;
+           terrain = "+.";
+           break;
+       case ARMY:
+           attack_list = army_attack;
+           if (obj->ship) terrain = "+*";
+           else terrain = "+.*";
+           break;
+       case TRANSPORT:
+           terrain = ".*";
+           if (obj->cargo) attack_list = tt_attack;
+           else attack_list = "*O"; /* causes tt to wake up */
+           break;
+       default:
+           attack_list = ship_attack;
+           terrain = ".";
+           break;
+       }
+       if (find_attack (obj->loc, attack_list, terrain) != obj->loc)
+           return;
                
-               /* clear old path */
-               pathmap[old_loc].terrain = T_UNKNOWN;
-               for (d = 0; d < 8; d++) {
-                       new_loc = old_loc + dir_offset[d];
-                       pathmap[new_loc].terrain = T_UNKNOWN;
-               }
-               /* pathmap is already marked, but this should work */
-               move_objective (obj, pathmap, old_dest, adj_list);
+       /* clear old path */
+       pathmap[old_loc].terrain = T_UNKNOWN;
+       for (d = 0; d < 8; d++) {
+           new_loc = old_loc + dir_offset[d];
+           pathmap[new_loc].terrain = T_UNKNOWN;
        }
+       /* pathmap is already marked, but this should work */
+       move_objective (obj, pathmap, old_dest, adj_list);
+    }
 }
 
 /*
@@ -1072,62 +1078,64 @@ and armies as the user, then the computer will give up.
 */
 
 void
-check_endgame(void) { /* see if game is over */
-
-       int nuser_city, ncomp_city;
-       int nuser_army, ncomp_army;
-       piece_info_t *p;
-       int i;
+check_endgame(void)
+{
+    int nuser_city, ncomp_city;
+    int nuser_army, ncomp_army;
+    piece_info_t *p;
+    int i;
        
-       date += 1; /* one more turn has passed */
-       if (win != 0) return; /* we already know game is over */
+    date += 1; /* one more turn has passed */
+    if (win != 0) return; /* we already know game is over */
 
-       nuser_city = 0; /* nothing counted yet */
-       ncomp_city = 0;
-       nuser_army = 0;
-       ncomp_army = 0;
+    nuser_city = 0; /* nothing counted yet */
+    ncomp_city = 0;
+    nuser_army = 0;
+    ncomp_army = 0;
        
-       for (i = 0; i < NUM_CITY; i++) {
-               if (city[i].owner == USER) nuser_city++;
-               else if (city[i].owner == COMP) ncomp_city++;
-       }
+    for (i = 0; i < NUM_CITY; i++) {
+       if (city[i].owner == USER) nuser_city++;
+       else if (city[i].owner == COMP) ncomp_city++;
+    }
        
-       for (p = user_obj[ARMY]; p != NULL; p = p->piece_link.next)
-               nuser_army++;
+    for (p = user_obj[ARMY]; p != NULL; p = p->piece_link.next)
+       nuser_army++;
        
-       for (p = comp_obj[ARMY]; p != NULL; p = p->piece_link.next)
-               ncomp_army++;
+    for (p = comp_obj[ARMY]; p != NULL; p = p->piece_link.next)
+       ncomp_army++;
                
-       if (ncomp_city < nuser_city/3 && ncomp_army < nuser_army/3) {
-               clear_screen ();
-               prompt ("The computer acknowledges defeat. Do");
-               ksend ("The computer acknowledges defeat.");
-               error ("you wish to smash the rest of the enemy?");
-
-               if (get_chx() !=  'Y') empend ();
-               announce ("\nThe enemy inadvertantly revealed its code used for");
-               announce ("\nreceiving battle information. You can display what");
-               announce ("\nthey've learned with the ''E'' command.");
-               resigned = true;
-               win = 2;
-               automove = false;
-       }
-       else if (ncomp_city == 0 && ncomp_army == 0) {
-               clear_screen ();
-               announce ("The enemy is incapable of defeating you.\n");
-               announce ("You are free to rape the empire as you wish.\n");
-               announce ("There may be, however, remnants of the enemy fleet\n");
-               announce ("to be routed out and destroyed.\n");
-               win = 1;
-               automove = false;
-       }
-       else if (nuser_city == 0 && nuser_army == 0) {
-               clear_screen ();
-               announce ("You have been rendered incapable of\n");
-               announce ("defeating the rampaging enemy fascists! The\n");
-               announce ("empire is lost. If you have any ships left, you\n");
-               announce ("may attempt to harass enemy shipping.");
-               win = 1;
-               automove = false;
-       }
+    if (ncomp_city < nuser_city/3 && ncomp_army < nuser_army/3) {
+       clear_screen ();
+       prompt ("The computer acknowledges defeat. Do");
+       ksend ("The computer acknowledges defeat.");
+       error ("you wish to smash the rest of the enemy?");
+
+       if (get_chx() !=  'Y') empend ();
+       announce ("\nThe enemy inadvertantly revealed its code used for");
+       announce ("\nreceiving battle information. You can display what");
+       announce ("\nthey've learned with the ''E'' command.");
+       resigned = true;
+       win = 2;
+       automove = false;
+    }
+    else if (ncomp_city == 0 && ncomp_army == 0) {
+       clear_screen ();
+       announce ("The enemy is incapable of defeating you.\n");
+       announce ("You are free to rape the empire as you wish.\n");
+       announce ("There may be, however, remnants of the enemy fleet\n");
+       announce ("to be routed out and destroyed.\n");
+       win = 1;
+       automove = false;
+    }
+    else if (nuser_city == 0 && nuser_army == 0) {
+       clear_screen ();
+       announce ("You have been rendered incapable of\n");
+       announce ("defeating the rampaging enemy fascists! The\n");
+       announce ("empire is lost. If you have any ships left, you\n");
+       announce ("may attempt to harass enemy shipping.");
+       win = 1;
+       automove = false;
+    }
 }
+
+/* end */
index 04f2f3a..590dc7f 100644 (file)
--- a/display.c
+++ b/display.c
@@ -54,7 +54,8 @@ void init_colors(void)
 /*
 Used for win announcements 
  */
-void announce (char *msg) {
+void announce (char *msg)
+{
     (void) addstr (msg);
 }
 
@@ -121,8 +122,9 @@ This routine is called when the current display has been
 trashed and no sector is shown on the screen.
 */
 
-void kill_display (void) {
-       whose_map = UNOWNED;
+void kill_display (void)
+{
+    whose_map = UNOWNED;
 }
 
 /*
@@ -130,8 +132,9 @@ This routine is called when a new sector may be displayed on the
 screen even if the location to be displayed is already on the screen.
 */
 
-void sector_change (void) {
-       change_ok = true;
+void sector_change (void)
+{
+    change_ok = true;
 }
 
 /*
@@ -139,9 +142,11 @@ Return the currently displayed user sector, if any.  If a user
 sector is not displayed, return -1.
 */
 
-int cur_sector (void) {
-       if (whose_map != USER) return (-1);
-       return (save_sector);
+int cur_sector (void)
+{
+    if (whose_map != USER)
+       return (-1);
+    return (save_sector);
 }
 
 /*
@@ -149,9 +154,11 @@ Return the current position of the cursor.  If the user's map
 is not on the screen, we return -1.
 */
 
-loc_t cur_cursor (void) {
-       if (whose_map != USER) return (-1);
-       return (save_cursor);
+loc_t cur_cursor (void)
+{
+    if (whose_map != USER)
+       return (-1);
+    return (save_cursor);
 }
 
 /*
@@ -167,10 +174,10 @@ void
 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));
+    if (change_ok || whose != whose_map || !on_screen (loc))
+       print_sector (whose, vmap, loc_sector (loc));
                
-       show_loc (vmap, loc);
+    show_loc (vmap, loc);
 }
 
 /*
@@ -181,8 +188,8 @@ void
 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);
+    if (whose == whose_map && on_screen (loc))
+       show_loc (vmap, loc);
 }
 
 /*
@@ -192,14 +199,14 @@ Display a location which exists on the screen.
 void
 show_loc (view_map_t vmap[], loc_t loc)
 {
-       int r, c;
+    int r, c;
        
-       r = loc_row (loc);
-       c = loc_col (loc);
-       (void) move (r-ref_row+NUMTOPS, c-ref_col);
-       disp_square(&vmap[loc]);
-       save_cursor = loc; /* remember cursor location */
-       (void) move (r-ref_row+NUMTOPS, c-ref_col);
+    r = loc_row (loc);
+    c = loc_col (loc);
+    (void) move (r-ref_row+NUMTOPS, c-ref_col);
+    disp_square(&vmap[loc]);
+    save_cursor = loc; /* remember cursor location */
+    (void) move (r-ref_row+NUMTOPS, c-ref_col);
 }
 
 /*
@@ -225,71 +232,71 @@ void
 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();
+    void display_screen();
 
-       int first_row, first_col, last_row, last_col;
-       int display_rows, display_cols;
-       int r, c;
+    int first_row, first_col, last_row, last_col;
+    int display_rows, display_cols;
+    int r, c;
 
-       save_sector = sector; /* remember last sector displayed */
-       change_ok = false; /* we are displaying a new sector */
+    save_sector = sector; /* remember last sector displayed */
+    change_ok = false; /* we are displaying a new sector */
 
-       display_rows = lines - NUMTOPS - 1; /* num lines to display */
-       display_cols = cols - NUMSIDES;
+    display_rows = lines - NUMTOPS - 1; /* num lines to display */
+    display_cols = cols - NUMSIDES;
 
-       /* compute row and column edges of sector */
-       first_row = sector_row (sector) * ROWS_PER_SECTOR;
-       first_col = sector_col (sector) * COLS_PER_SECTOR;
-       last_row = first_row + ROWS_PER_SECTOR - 1;
-       last_col = first_col + COLS_PER_SECTOR - 1;
+    /* compute row and column edges of sector */
+    first_row = sector_row (sector) * ROWS_PER_SECTOR;
+    first_col = sector_col (sector) * COLS_PER_SECTOR;
+    last_row = first_row + ROWS_PER_SECTOR - 1;
+    last_col = first_col + COLS_PER_SECTOR - 1;
 
-       if (!(whose == whose_map /* correct map is on screen? */
-          && ref_row <= first_row /* top row on screen? */
-          && ref_col <= first_col /* first col on screen? */
-          && ref_row + display_rows - 1 >= last_row /* bot row on screen? */
-          && ref_col + display_cols - 1 >= last_col)) /* last col on screen? */
+    if (!(whose == whose_map /* correct map is on screen? */
+         && ref_row <= first_row /* top row on screen? */
+         && ref_col <= first_col /* first col on screen? */
+         && ref_row + display_rows - 1 >= last_row /* bot row on screen? */
+         && ref_col + display_cols - 1 >= last_col)) /* last col on screen? */
        (void) clear (); /* erase current screen */
 
-       /* figure out first row and col to print; subtract half
-          the extra lines from the first line */
+    /* figure out first row and col to print; subtract half
+       the extra lines from the first line */
 
-       ref_row = first_row - (display_rows - ROWS_PER_SECTOR) / 2;
-       ref_col = first_col - (display_cols - COLS_PER_SECTOR) / 2;
+    ref_row = first_row - (display_rows - ROWS_PER_SECTOR) / 2;
+    ref_col = first_col - (display_cols - COLS_PER_SECTOR) / 2;
 
-       /* try not to go past bottom of map */
-       if (ref_row + display_rows - 1 > MAP_HEIGHT - 1)
-               ref_row = MAP_HEIGHT - 1 - (display_rows - 1);
+    /* try not to go past bottom of map */
+    if (ref_row + display_rows - 1 > MAP_HEIGHT - 1)
+       ref_row = MAP_HEIGHT - 1 - (display_rows - 1);
 
-       /* never go past top of map */
-        if (ref_row < 0) ref_row = 0;
+    /* never go past top of map */
+    if (ref_row < 0) ref_row = 0;
 
-       /* same with columns */
-       if (ref_col + display_cols - 1 > MAP_WIDTH - 1)
-               ref_col = MAP_WIDTH - 1 - (display_cols - 1);
+    /* same with columns */
+    if (ref_col + display_cols - 1 > MAP_WIDTH - 1)
+       ref_col = MAP_WIDTH - 1 - (display_cols - 1);
 
-       if (ref_col < 0) ref_col = 0;
+    if (ref_col < 0) ref_col = 0;
 
-        whose_map = whose; /* remember whose map is displayed */
-       display_screen (vmap);
+    whose_map = whose; /* remember whose map is displayed */
+    display_screen (vmap);
 
-       /* print x-coordinates along bottom of screen */
-       for (c = ref_col; c < ref_col + display_cols && c < MAP_WIDTH; c++)
+    /* print x-coordinates along bottom of screen */
+    for (c = ref_col; c < ref_col + display_cols && c < MAP_WIDTH; c++)
        if (c % 10 == 0) {
-               pos_str (lines-1, c-ref_col, "%d", c,0,0,0,0,0,0,0);
-       }
-       /* print y-coordinates along right of screen */
-       for (r = ref_row; r < ref_row + display_rows && r < MAP_HEIGHT; r++) {
-               if (r % 2 == 0)
-                       pos_str (r-ref_row+NUMTOPS, cols-NUMSIDES+1, "%2d", r,0,0,0,0,0,0,0);
-               else pos_str (r-ref_row+NUMTOPS, cols-NUMSIDES+1, "  ",0,0,0,0,0,0,0,0);
-       }
-       /* print round number */
-       (void) sprintf (jnkbuf, "Sector %d Round %ld", sector, date);
-       for (r = 0; jnkbuf[r] != '\0'; r++) {
-               if (r+NUMTOPS >= MAP_HEIGHT) break;
-               (void) move (r+NUMTOPS, cols-NUMSIDES+4);
-               (void) addch ((chtype)jnkbuf[r]);
+           pos_str (lines-1, c-ref_col, "%d", c,0,0,0,0,0,0,0);
        }
+    /* print y-coordinates along right of screen */
+    for (r = ref_row; r < ref_row + display_rows && r < MAP_HEIGHT; r++) {
+       if (r % 2 == 0)
+           pos_str (r-ref_row+NUMTOPS, cols-NUMSIDES+1, "%2d", r,0,0,0,0,0,0,0);
+       else pos_str (r-ref_row+NUMTOPS, cols-NUMSIDES+1, "  ",0,0,0,0,0,0,0,0);
+    }
+    /* print round number */
+    (void) sprintf (jnkbuf, "Sector %d Round %ld", sector, date);
+    for (r = 0; jnkbuf[r] != '\0'; r++) {
+       if (r+NUMTOPS >= MAP_HEIGHT) break;
+       (void) move (r+NUMTOPS, cols-NUMSIDES+4);
+       (void) addch ((chtype)jnkbuf[r]);
+    }
 }
 
 /*
@@ -304,38 +311,38 @@ pretty.
 static void disp_square(view_map_t *vp)
 {
 #ifdef A_COLOR
-       chtype attr;
-
-       switch(vp->contents)
-       {
-       case '+':
-           attr = COLOR_PAIR(COLOR_GREEN);
-               break;
-       case '.':
-               attr = COLOR_PAIR(COLOR_CYAN);
-               break;
-       case 'a':
-       case 'f':
-       case 'p':
-       case 'd':
-       case 'b':
-       case 't':
-       case 'c':
-       case 's':
-       case 'z':
-       case 'X':
-               attr = COLOR_PAIR(COLOR_RED);
-               break;
-       default:
-               attr = COLOR_PAIR(COLOR_WHITE);
-               break;
-       }
-       attron(attr);
+    chtype attr;
+
+    switch(vp->contents)
+    {
+    case '+':
+       attr = COLOR_PAIR(COLOR_GREEN);
+       break;
+    case '.':
+       attr = COLOR_PAIR(COLOR_CYAN);
+       break;
+    case 'a':
+    case 'f':
+    case 'p':
+    case 'd':
+    case 'b':
+    case 't':
+    case 'c':
+    case 's':
+    case 'z':
+    case 'X':
+       attr = COLOR_PAIR(COLOR_RED);
+       break;
+    default:
+       attr = COLOR_PAIR(COLOR_WHITE);
+       break;
+    }
+    attron(attr);
 #endif /* A_COLOR */
-       (void) addch ((chtype)vp->contents);
+    (void) addch ((chtype)vp->contents);
 #ifdef A_COLOR
-       attroff(attr);
-       attron(COLOR_PAIR(COLOR_WHITE));
+    attroff(attr);
+    attron(COLOR_PAIR(COLOR_WHITE));
 #endif /* A_COLOR */
 }
 
@@ -346,18 +353,18 @@ Display the portion of the map that appears on the screen.
 
 void display_screen(view_map_t vmap[])
 {
-       int display_rows, display_cols;
-       int r, c;
-       loc_t t;
+    int display_rows, display_cols;
+    int r, c;
+    loc_t t;
 
-       display_rows = lines - NUMTOPS - 1; /* num lines to display */
-       display_cols = cols - NUMSIDES;
+    display_rows = lines - NUMTOPS - 1; /* num lines to display */
+    display_cols = cols - NUMSIDES;
 
-       for (r = ref_row; r < ref_row + display_rows && r < MAP_HEIGHT; r++)
+    for (r = ref_row; r < ref_row + display_rows && r < MAP_HEIGHT; r++)
        for (c = ref_col; c < ref_col + display_cols && c < MAP_WIDTH; c++) {
-               t = row_col_loc (r, c);
-               (void) move (r-ref_row+NUMTOPS, c-ref_col);
-               disp_square(&vmap[t]);
+           t = row_col_loc (r, c);
+           (void) move (r-ref_row+NUMTOPS, c-ref_col);
+           disp_square(&vmap[t]);
        }
 }
 
@@ -371,21 +378,21 @@ bool
 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;
+    loc_t t;
+    int r, c;
  
-       t = *cursor + offset; /* proposed location */
-       if (!map[t].on_board) return (false); /* trying to move off map */
-       if (!on_screen (t)) return (false); /* loc is off screen */
+    t = *cursor + offset; /* proposed location */
+    if (!map[t].on_board) return (false); /* trying to move off map */
+    if (!on_screen (t)) return (false); /* loc is off screen */
        
-       *cursor = t; /* update cursor position */
-       save_cursor = *cursor;
+    *cursor = t; /* update cursor position */
+    save_cursor = *cursor;
               
-       r = loc_row (save_cursor);
-       c = loc_col (save_cursor);
-       (void) move (r-ref_row+NUMTOPS, c-ref_col);
+    r = loc_row (save_cursor);
+    c = loc_col (save_cursor);
+    (void) move (r-ref_row+NUMTOPS, c-ref_col);
        
-       return (true);
+    return (true);
 }
 
 /*
@@ -394,18 +401,18 @@ See if a location is displayed on the screen.
 
 bool on_screen (loc_t loc)
 {
-       int new_r, new_c;
+    int new_r, new_c;
        
-       new_r = loc_row (loc);
-       new_c = loc_col (loc);
+    new_r = loc_row (loc);
+    new_c = loc_col (loc);
 
-       if (new_r < ref_row /* past top of screen */
-        || new_r - ref_row > lines - NUMTOPS - 1 /* past bot of screen? */
-        || new_c < ref_col /* past left edge of screen? */
-        || new_c - ref_col > cols - NUMSIDES) /* past right edge of screen? */
+    if (new_r < ref_row /* past top of screen */
+       || new_r - ref_row > lines - NUMTOPS - 1 /* past bot of screen? */
+       || new_c < ref_col /* past left edge of screen? */
+       || new_c - ref_col > cols - NUMSIDES) /* past right edge of screen? */
        return (false);
 
-       return (true);
+    return (true);
 }
 
 /* Print a view map for debugging. */
@@ -413,10 +420,10 @@ bool on_screen (loc_t loc)
 void
 print_xzoom(view_map_t *vmap)
 {
-       print_zoom (vmap);
+    print_zoom (vmap);
 #if 0
-       prompt ("Hit a key: ",0,0,0,0,0,0,0,0);
-       (void) get_chx (); /* wait for user */
+    prompt ("Hit a key: ",0,0,0,0,0,0,0,0);
+    (void) get_chx (); /* wait for user */
 #endif
 }
 
@@ -429,23 +436,23 @@ char zoom_list[] = "XO*tcbsdpfaTCBSDPFAzZ+. ";
 void
 print_zoom(view_map_t *vmap)
 {
-       void print_zoom_cell ();
+    void print_zoom_cell ();
 
-       int row_inc, col_inc;
-       int r, c;
+    int row_inc, col_inc;
+    int r, c;
 
-       kill_display ();
+    kill_display ();
 
-       row_inc = (MAP_HEIGHT + lines - NUMTOPS - 1) / (lines - NUMTOPS);
-       col_inc = (MAP_WIDTH + cols - 1) / (cols - 1);
+    row_inc = (MAP_HEIGHT + lines - NUMTOPS - 1) / (lines - NUMTOPS);
+    col_inc = (MAP_WIDTH + cols - 1) / (cols - 1);
 
-       for (r = 0; r < MAP_HEIGHT; r += row_inc)
+    for (r = 0; r < MAP_HEIGHT; r += row_inc)
        for (c = 0; c < MAP_WIDTH; c += col_inc)
-       print_zoom_cell (vmap, r, c, row_inc, col_inc);
+           print_zoom_cell (vmap, r, c, row_inc, col_inc);
 
-       pos_str (0, 0, "Round #%d", date,0,0,0,0,0,0,0);
+    pos_str (0, 0, "Round #%d", date,0,0,0,0,0,0,0);
        
-       (void) refresh ();
+    (void) refresh ();
 }
 
 /*
@@ -456,18 +463,18 @@ void
 print_zoom_cell(view_map_t *vmap, 
                 int row, int col, int row_inc, int col_inc)
 {
-       int r, c;
-       char cell;
+    int r, c;
+    char cell;
 
-       cell = ' ';
-       for (r = row; r < row + row_inc; r++)
+    cell = ' ';
+    for (r = row; r < row + row_inc; r++)
        for (c = col; c < col + col_inc; c++)
-       if (strchr (zoom_list, vmap[row_col_loc(r,c)].contents)
+           if (strchr (zoom_list, vmap[row_col_loc(r,c)].contents)
                < strchr (zoom_list, cell))
-       cell = vmap[row_col_loc(r,c)].contents;
+               cell = vmap[row_col_loc(r,c)].contents;
        
-       (void) move (row/row_inc + NUMTOPS, col/col_inc);
-       (void) addch ((chtype)cell);
+    (void) move (row/row_inc + NUMTOPS, col/col_inc);
+    (void) addch ((chtype)cell);
 }
 
 /*
@@ -477,24 +484,24 @@ Print a condensed version of a pathmap.
 void
 print_pzoom(char *s, path_map_t *pmap, view_map_t *vmap)
 {
-       void print_pzoom_cell();
+    void print_pzoom_cell();
 
-       int row_inc, col_inc;
-       int r, c;
+    int row_inc, col_inc;
+    int r, c;
 
-       kill_display ();
+    kill_display ();
 
-       row_inc = (MAP_HEIGHT + lines - NUMTOPS - 1) / (lines - NUMTOPS);
-       col_inc = (MAP_WIDTH + cols - 1) / (cols - 1);
+    row_inc = (MAP_HEIGHT + lines - NUMTOPS - 1) / (lines - NUMTOPS);
+    col_inc = (MAP_WIDTH + cols - 1) / (cols - 1);
 
-       for (r = 0; r < MAP_HEIGHT; r += row_inc)
+    for (r = 0; r < MAP_HEIGHT; r += row_inc)
        for (c = 0; c < MAP_WIDTH; c += col_inc)
-       print_pzoom_cell (pmap, vmap, r, c, row_inc, col_inc);
+           print_pzoom_cell (pmap, vmap, r, c, row_inc, col_inc);
 
-       prompt (s,0,0,0,0,0,0,0,0);
-       (void) get_chx (); /* wait for user */
+    prompt (s,0,0,0,0,0,0,0,0);
+    (void) get_chx (); /* wait for user */
        
-       (void) refresh ();
+    (void) refresh ();
 }
 
 /*
@@ -510,37 +517,37 @@ void
 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;
-       char cell;
+    int r, c;
+    int sum, d;
+    char cell;
 
-       sum = 0;
-       d = 0; /* number of squares in cell */
+    sum = 0;
+    d = 0; /* number of squares in cell */
        
-       for (r = row; r < row + row_inc; r++)
+    for (r = row; r < row + row_inc; r++)
        for (c = col; c < col + col_inc; c++) {
-               sum += pmap[row_col_loc(r,c)].cost;
-               d += 1;
+           sum += pmap[row_col_loc(r,c)].cost;
+           d += 1;
        }
-       sum /= d;
+    sum /= d;
        
-       if (pmap[row_col_loc(row,col)].terrain == T_PATH) cell = '-';
-       else if (sum < 0) cell = '!';
-       else if (sum == INFINITY/2) cell = 'P';
-       else if (sum == INFINITY) cell = ' ';
-       else if (sum > INFINITY/2) cell = 'U';
-       else {
-               sum %= 36;
-               if (sum < 10) cell = sum + '0';
-               else cell = sum - 10 + 'a';
-       }
+    if (pmap[row_col_loc(row,col)].terrain == T_PATH) cell = '-';
+    else if (sum < 0) cell = '!';
+    else if (sum == INFINITY/2) cell = 'P';
+    else if (sum == INFINITY) cell = ' ';
+    else if (sum > INFINITY/2) cell = 'U';
+    else {
+       sum %= 36;
+       if (sum < 10) cell = sum + '0';
+       else cell = sum - 10 + 'a';
+    }
        
-       if (cell == ' ')
-               print_zoom_cell (vmap, row, col, row_inc, col_inc);
-       else {
-               (void) move (row/row_inc + NUMTOPS, col/col_inc);
-               (void) addch ((chtype)cell);
-       }
+    if (cell == ' ')
+       print_zoom_cell (vmap, row, col, row_inc, col_inc);
+    else {
+       (void) move (row/row_inc + NUMTOPS, col/col_inc);
+       (void) addch ((chtype)cell);
+    }
 }
 
 /*
@@ -550,8 +557,8 @@ Display the score off in the corner of the screen.
 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);
+    pos_str (1, cols-12, " User  Comp");
+    pos_str (2, cols-12, "%5d %5d", user_score, comp_score);
 }
 
 /*
@@ -561,8 +568,8 @@ Clear the end of a specified line starting at the specified column.
 void
 clreol(int linep, int colp)
 {
-       (void) move (linep, colp);
-       (void) clrtoeol();
+    (void) move (linep, colp);
+    (void) clrtoeol();
 }
 
 /*
@@ -572,18 +579,18 @@ Initialize the terminal.
 void
 ttinit(void)
 {
-       (void) initscr();
-       (void) noecho();
-       (void) crmode();
+    (void) initscr();
+    (void) noecho();
+    (void) crmode();
 #ifdef A_COLOR
-       init_colors();
+    init_colors();
 #endif /* A_COLOR */
-       lines = LINES;
-       cols = COLS;
-       if (lines > MAP_HEIGHT + NUMTOPS + 1)
-               lines = MAP_HEIGHT + NUMTOPS + 1;
-       if (cols > MAP_WIDTH + NUMSIDES)
-               cols = MAP_WIDTH + NUMSIDES;
+    lines = LINES;
+    cols = COLS;
+    if (lines > MAP_HEIGHT + NUMTOPS + 1)
+       lines = MAP_HEIGHT + NUMTOPS + 1;
+    if (cols > MAP_WIDTH + NUMSIDES)
+       cols = MAP_WIDTH + NUMSIDES;
 }
 
 
@@ -595,9 +602,9 @@ display.
 void
 clear_screen(void)
 {
-       (void) clear ();
-       (void) refresh ();
-       kill_display ();
+    (void) clear ();
+    (void) refresh ();
+    kill_display ();
 }
 
 /*
@@ -607,7 +614,7 @@ Audible complaint.
 void 
 complain(void)
 {
-       (void) beep ();
+    (void) beep ();
 }
 
 /*
@@ -617,14 +624,14 @@ Redraw the screen.
 void 
 redisplay(void)
 {
-       (void) refresh ();
+    (void) refresh ();
 }
 
 void
 redraw(void)
 {
-       (void) clearok (curscr, TRUE);
-       (void) refresh ();
+    (void) clearok (curscr, TRUE);
+    (void) refresh ();
 }
 
 /*
@@ -635,19 +642,19 @@ the screen and pause for a few milliseconds.
 void
 delay(void)
 {
-        int t = delay_time;
-        int i = 500;
-       (void) refresh ();
-        if (t > i) {
-          (void) move (LINES - 1, 0);
-        }
-        for (; t > 0; t -= i) {
-          (void) napms ((t > i) ? i : t); /* pause a bit */
-          if (t > i) {
+    int t = delay_time;
+    int i = 500;
+    (void) refresh ();
+    if (t > i) {
+       (void) move (LINES - 1, 0);
+    }
+    for (; t > 0; t -= i) {
+       (void) napms ((t > i) ? i : t); /* pause a bit */
+       if (t > i) {
             addstr ("*");
             refresh (); 
-          }
-        }
+       }
+    }
 }
 
 /*
@@ -657,10 +664,10 @@ Clean up the display.  This routine gets called as we leave the game.
 void
 close_disp(void)
 {
-       (void) move (LINES - 1, 0);
-       (void) clrtoeol ();
-       (void) refresh ();
-       (void) endwin ();
+    (void) move (LINES - 1, 0);
+    (void) clrtoeol ();
+    (void) refresh ();
+    (void) endwin ();
 }
 
 /*
@@ -668,29 +675,29 @@ Position the cursor and output a string.
 */
 
 void
-pos_str1(int row, int col, char *str, ...)
+pos_str(int row, int col, char *str, ...)
 {
-       va_list ap;
-       char junkbuf[STRSIZE];
+    va_list ap;
+    char junkbuf[STRSIZE];
 
-       va_start(ap, str);
-       (void) move (row, col);
-       vsprintf(junkbuf, str, ap);
-       (void) addstr (junkbuf);
-       va_end(ap);
+    va_start(ap, str);
+    (void) move (row, col);
+    vsprintf(junkbuf, str, ap);
+    (void) addstr (junkbuf);
+    va_end(ap);
 }
 
 void
-pos_str(int row, int col, char *str, ...)
+pos_str1(int row, int col, char *str, ...)
 {
-       va_list ap;
-       char junkbuf[STRSIZE];
+    va_list ap;
+    char junkbuf[STRSIZE];
 
-       va_start(ap, str);
-       (void) move (row, col);
-       vsprintf(junkbuf, str, ap);
-       (void) addstr (junkbuf);
-       va_end(ap);
+    va_start(ap, str);
+    (void) move (row, col);
+    vsprintf(junkbuf, str, ap);
+    (void) addstr (junkbuf);
+    va_end(ap);
 }
 
 /*
@@ -702,16 +709,18 @@ extern char zoom_list[];
 void
 print_movie_cell(char *mbuf, int row, int col, int row_inc, int col_inc)
 {
-       int r, c;
-       char cell;
+    int r, c;
+    char cell;
 
-       cell = ' ';
-       for (r = row; r < row + row_inc; r++)
+    cell = ' ';
+    for (r = row; r < row + row_inc; r++)
        for (c = col; c < col + col_inc; c++)
-       if (strchr (zoom_list, mbuf[row_col_loc(r,c)])
+           if (strchr (zoom_list, mbuf[row_col_loc(r,c)])
                < strchr (zoom_list, cell))
-       cell = mbuf[row_col_loc(r,c)];
+               cell = mbuf[row_col_loc(r,c)];
        
-       (void) move (row/row_inc + NUMTOPS, col/col_inc);
-       (void) addch ((chtype)cell);
+    (void) move (row/row_inc + NUMTOPS, col/col_inc);
+    (void) addch ((chtype)cell);
 }
+
+/* end */
diff --git a/edit.c b/edit.c
index 109735a..7e55f17 100644 (file)
--- a/edit.c
+++ b/edit.c
@@ -22,87 +22,87 @@ extern int get_piece_name(void);
 void
 edit(loc_t edit_cursor)
 {
-       char e_cursor();
-       void e_leave(), e_print(), e_random();
-       void e_stasis(), e_end(), e_wake(), e_sleep();
-       void e_info(), e_prod(), e_help(), e_explore();
-       void e_fill(), e_land(), e_city_func(), e_transport();
-       void e_attack(), e_repair();
-
-       loc_t path_start;
-       int path_type;
-       char e;
+    char e_cursor();
+    void e_leave(), e_print(), e_random();
+    void e_stasis(), e_end(), e_wake(), e_sleep();
+    void e_info(), e_prod(), e_help(), e_explore();
+    void e_fill(), e_land(), e_city_func(), e_transport();
+    void e_attack(), e_repair();
+
+    loc_t path_start;
+    int path_type;
+    char e;
        
-       path_start = -1; /* not building a path yet */
+    path_start = -1; /* not building a path yet */
        
-       for (;;) { /* until user gives command to leave */
-               display_loc_u (edit_cursor); /* position cursor */
-               e = e_cursor (&edit_cursor); /* handle cursor movement */
-
-               switch (e) {
-               case 'B': /* change city production */
-                       e_prod (edit_cursor);
-                       break;
-               case 'F': /* fill */
-                       e_fill (edit_cursor);
-                       break;
-               case 'G': /* explore */
-                       e_explore (edit_cursor);
-                       break;
-               case 'H': /* help */
-                       e_help ();
-                       break;
-               case 'I': /* directional stasis */
-                       e_stasis (edit_cursor);
-                       break;
-               case 'K': /* wake up anything and everything */
-                       e_wake (edit_cursor);
-                       break;
-               case 'L': /* land plane */
-                       e_land (edit_cursor);
-                       break;
-               case 'M': /* start move to location */
-                       path_type = NOPIECE;
-                       e_move (&path_start, edit_cursor);
-                       break;
-               case 'N': /* end move to location */
-                       e_end (&path_start, edit_cursor, path_type);
-                       break;
-               case 'O': /* leave display mode */
-                       e_leave ();
-                       return;
-               case 'P': /* print new sector */
-                       e_print (&edit_cursor);
-                       break;
-               case 'R': /* make piece move randomly */
-                       e_random (edit_cursor);
-                       break;
-               case 'S': /* sleep */
-                       e_sleep (edit_cursor);
-                       break;
-               case 'T': /* transport army */
-                       e_transport (edit_cursor);
-                       break;
-               case 'U': /* repair ship */
-                       e_repair (edit_cursor);
-                       break;
-               case 'V': /* set city function */
-                       e_city_func (&path_start, edit_cursor, &path_type);
-                       break;
-               case 'Y': /* set army func to attack */
-                       e_attack (edit_cursor);
-                       break;
-               case '?': /* request info */
-                       e_info (edit_cursor);
-                       break;
-               case '\014': /* control-L */
-                       redraw ();
-                       break;
-               default: /* bad command? */
-                       huh ();
-                       break;
-               }
+    for (;;) { /* until user gives command to leave */
+       display_loc_u (edit_cursor); /* position cursor */
+       e = e_cursor (&edit_cursor); /* handle cursor movement */
+
+       switch (e) {
+       case 'B': /* change city production */
+           e_prod (edit_cursor);
+           break;
+       case 'F': /* fill */
+           e_fill (edit_cursor);
+           break;
+       case 'G': /* explore */
+           e_explore (edit_cursor);
+           break;
+       case 'H': /* help */
+           e_help ();
+           break;
+       case 'I': /* directional stasis */
+           e_stasis (edit_cursor);
+           break;
+       case 'K': /* wake up anything and everything */
+           e_wake (edit_cursor);
+           break;
+       case 'L': /* land plane */
+           e_land (edit_cursor);
+           break;
+       case 'M': /* start move to location */
+           path_type = NOPIECE;
+           e_move (&path_start, edit_cursor);
+           break;
+       case 'N': /* end move to location */
+           e_end (&path_start, edit_cursor, path_type);
+           break;
+       case 'O': /* leave display mode */
+           e_leave ();
+           return;
+       case 'P': /* print new sector */
+           e_print (&edit_cursor);
+           break;
+       case 'R': /* make piece move randomly */
+           e_random (edit_cursor);
+           break;
+       case 'S': /* sleep */
+           e_sleep (edit_cursor);
+           break;
+       case 'T': /* transport army */
+           e_transport (edit_cursor);
+           break;
+       case 'U': /* repair ship */
+           e_repair (edit_cursor);
+           break;
+       case 'V': /* set city function */
+           e_city_func (&path_start, edit_cursor, &path_type);
+           break;
+       case 'Y': /* set army func to attack */
+           e_attack (edit_cursor);
+           break;
+       case '?': /* request info */
+           e_info (edit_cursor);
+           break;
+       case '\014': /* control-L */
+           redraw ();
+           break;
+       default: /* bad command? */
+           huh ();
+           break;
        }
+    }
 }
 
 /*
@@ -114,27 +114,27 @@ fast.
 char
 e_cursor(loc_t *edit_cursor)
 {
-       chtype e;
-       int p;
+    chtype e;
+    int p;
        
-       /* set up terminal */
-       (void) crmode ();
+    /* set up terminal */
+    (void) crmode ();
+    (void) refresh ();
+    e = getch ();
+    topini (); /* clear any error messages */
+
+    for (;;) {
+       p = direction (e);
+       if (p == -1) break;
+
+       if (!move_cursor (edit_cursor, dir_offset[p]))
+           (void) beep ();
+               
        (void) refresh ();
        e = getch ();
-       topini (); /* clear any error messages */
-
-       for (;;) {
-               p = direction (e);
-               if (p == -1) break;
-
-               if (!move_cursor (edit_cursor, dir_offset[p]))
-                       (void) beep ();
-               
-               (void) refresh ();
-               e = getch ();
-       }
-       (void) nocrmode (); /* reset terminal */
-       return toupper(e);
+    }
+    (void) nocrmode (); /* reset terminal */
+    return toupper(e);
 }
 
 /*
@@ -142,7 +142,8 @@ Leave edit mode.
 */
 
 void
-e_leave(void) {
+e_leave(void)
+{
 }
 
 /*
@@ -152,13 +153,13 @@ Print new sector.
 void
 e_print(loc_t *edit_cursor)
 {
-        int sector;
+    int sector;
        
-       sector = get_range ("New Sector? ", 0, NUM_SECTORS-1);
+    sector = get_range ("New Sector? ", 0, NUM_SECTORS-1);
 
-       /* position cursor at center of sector */
-       *edit_cursor = sector_loc (sector);
-       sector_change (); /* allow change of sector */
+    /* position cursor at center of sector */
+    *edit_cursor = sector_loc (sector);
+    sector_change (); /* allow change of sector */
 }
 
 /*
@@ -168,13 +169,13 @@ Set the function of a piece.
 void
 e_set_func(loc_t loc, long func)
 {
-       piece_info_t *obj;
-       obj = find_obj_at_loc (loc);
-       if (obj != NULL && obj->owner == USER) {
-               obj->func = func;
-               return;
-       }
-       huh (); /* no object here */
+    piece_info_t *obj;
+    obj = find_obj_at_loc (loc);
+    if (obj != NULL && obj->owner == USER) {
+       obj->func = func;
+       return;
+    }
+    huh (); /* no object here */
 }
        
 /* Set the function of a city for some piece. */
@@ -182,7 +183,7 @@ e_set_func(loc_t loc, long func)
 void
 e_set_city_func(city_info_t *cityp, int type, long func)
 {
-       cityp->func[type] = func;
+    cityp->func[type] = func;
 }
 
 /*
@@ -192,13 +193,13 @@ Set a piece to move randomly.
 void
 e_random(loc_t loc)
 {
-       e_set_func (loc, RANDOM);
+    e_set_func (loc, RANDOM);
 }
 
 void
 e_city_random(city_info_t *cityp, int type)
 {
-       e_set_city_func (cityp, type, RANDOM);
+    e_set_city_func (cityp, type, RANDOM);
 }
 
 /*
@@ -208,17 +209,17 @@ Put a ship in fill mode.
 void
 e_fill(loc_t loc)
 {
-       if (user_map[loc].contents == 'T' || user_map[loc].contents == 'C')
-               e_set_func (loc, FILL);
-       else huh ();
+    if (user_map[loc].contents == 'T' || user_map[loc].contents == 'C')
+       e_set_func (loc, FILL);
+    else huh ();
 }
 
 void
 e_city_fill(city_info_t *cityp, int type)
 {
-       if (type == TRANSPORT || type == CARRIER)
-               e_set_city_func (cityp, type, FILL);
-       else huh ();
+    if (type == TRANSPORT || type == CARRIER)
+       e_set_city_func (cityp, type, FILL);
+    else huh ();
 }
 
 /*
@@ -228,13 +229,13 @@ Set a piece to explore.
 void
 e_explore(loc_t loc)
 {
-       e_set_func (loc, EXPLORE);
+    e_set_func (loc, EXPLORE);
 }
 
 void
 e_city_explore(city_info_t *cityp, loc_t type)
 {
-       e_set_city_func (cityp, type, EXPLORE);
+    e_set_city_func (cityp, type, EXPLORE);
 }
 
 /*
@@ -244,9 +245,9 @@ Set a fighter to land.
 void
 e_land(loc_t loc)
 {
-       if (user_map[loc].contents == 'F')
-               e_set_func (loc, LAND);
-       else huh ();
+    if (user_map[loc].contents == 'F')
+       e_set_func (loc, LAND);
+    else huh ();
 }
 
 /*
@@ -256,9 +257,9 @@ Set an army's function to TRANSPORT.
 void
 e_transport(loc_t loc)
 {
-       if (user_map[loc].contents == 'A')
-               e_set_func (loc, WFTRANSPORT);
-       else huh ();
+    if (user_map[loc].contents == 'A')
+       e_set_func (loc, WFTRANSPORT);
+    else huh ();
 }
 
 /*
@@ -268,17 +269,17 @@ Set an army's function to ATTACK.
 void
 e_attack(loc_t loc)
 {
-       if (user_map[loc].contents == 'A')
-               e_set_func (loc, ARMYATTACK);
-       else huh ();
+    if (user_map[loc].contents == 'A')
+       e_set_func (loc, ARMYATTACK);
+    else huh ();
 }
 
 void
 e_city_attack(city_info_t *cityp, int type)
 {
-       if (type == ARMY)
-               e_set_city_func (cityp, type, ARMYATTACK);
-       else huh ();
+    if (type == ARMY)
+       e_set_city_func (cityp, type, ARMYATTACK);
+    else huh ();
 }
 
 /*
@@ -288,9 +289,9 @@ Set a ship's function to REPAIR.
 void
 e_repair(loc_t loc)
 {
-       if (strchr ("PDSTBC", user_map[loc].contents))
-               e_set_func (loc, REPAIR);
-       else huh ();
+    if (strchr ("PDSTBC", user_map[loc].contents))
+       e_set_func (loc, REPAIR);
+    else huh ();
 }
 
 void
@@ -310,31 +311,37 @@ static char dirs[] = "WEDCXZAQ";
 void
 e_stasis(loc_t loc)
 {
-       char e;
-       char *p;
+    char e;
+    char *p;
        
-       if (!isupper (user_map[loc].contents)) huh (); /* no object here */
-       else if (user_map[loc].contents == 'X') huh ();
-       else {
-               e = get_chx(); /* get a direction */
-               p = strchr (dirs, e);
-
-               if (p == NULL) huh ();
-               else e_set_func (loc, (long)(MOVE_N - (p - dirs)));
-       }
+    if (!isupper (user_map[loc].contents))
+       huh (); /* no object here */
+    else if (user_map[loc].contents == 'X')
+       huh ();
+    else {
+       e = get_chx(); /* get a direction */
+       p = strchr (dirs, e);
+
+       if (p == NULL)
+           huh ();
+       else
+           e_set_func (loc, (long)(MOVE_N - (p - dirs)));
+    }
 }
 
 void
 e_city_stasis(city_info_t *cityp, int type)
 {
-       char e;
-       char *p;
+    char e;
+    char *p;
        
-       e = get_chx(); /* get a direction */
-       p = strchr (dirs, e);
+    e = get_chx(); /* get a direction */
+    p = strchr (dirs, e);
 
-       if (p == NULL) huh ();
-       else e_set_city_func (cityp, type, (long)(MOVE_N - (p - dirs)));
+    if (p == NULL)
+       huh ();
+    else
+       e_set_city_func (cityp, type, (long)(MOVE_N - (p - dirs)));
 }
 
 /*
@@ -344,23 +351,23 @@ Wake up anything and everything.
 void
 e_wake(loc_t loc)
 {
-       city_info_t *cityp;
-       piece_info_t *obj;
-       int i;
-
-       cityp = find_city (loc);
-        if (cityp != NULL) {
-               for (i = 0; i < NUM_OBJECTS; i++)
-                       cityp->func[i] = NOFUNC;
-       }
-       for (obj = map[loc].objp; obj != NULL; obj = obj->loc_link.next)
-               obj->func = NOFUNC;
+    city_info_t *cityp;
+    piece_info_t *obj;
+    int i;
+
+    cityp = find_city (loc);
+    if (cityp != NULL) {
+       for (i = 0; i < NUM_OBJECTS; i++)
+           cityp->func[i] = NOFUNC;
+    }
+    for (obj = map[loc].objp; obj != NULL; obj = obj->loc_link.next)
+       obj->func = NOFUNC;
 }
 
 void
 e_city_wake(city_info_t *cityp, int type)
 {
-       e_set_city_func (cityp, type, NOFUNC);
+    e_set_city_func (cityp, type, NOFUNC);
 }
 
 /*
@@ -371,54 +378,54 @@ the function itself.
 void
 e_city_func(loc_t *path_start, loc_t loc, int *path_type)
 {
-       int type;
-       char e;
-       city_info_t *cityp;
-
-       cityp = find_city (loc);
-       if (!cityp || cityp->owner != USER) {
-               huh ();
-               return;
-       }
-
-       type = get_piece_name();
-       if (type == NOPIECE) {
-               huh ();
-               return;
-       }
+    int type;
+    char e;
+    city_info_t *cityp;
+
+    cityp = find_city (loc);
+    if (!cityp || cityp->owner != USER) {
+       huh ();
+       return;
+    }
+
+    type = get_piece_name();
+    if (type == NOPIECE) {
+       huh ();
+       return;
+    }
        
-       e = get_chx ();
+    e = get_chx ();
        
-       switch (e) {
-       case 'F': /* fill */
-               e_city_fill (cityp, type);
-               break;
-       case 'G': /* explore */
-               e_city_explore (cityp, type);
-               break;
-       case 'I': /* directional stasis */
-               e_city_stasis (cityp, type);
-               break;
-       case 'K': /* turn off function */
-               e_city_wake (cityp, type);
-               break;
-       case 'M': /* start move to location */
-               *path_type = type;
-               e_move (path_start, loc);
-               break;
-       case 'R': /* make piece move randomly */
-               e_city_random (cityp, type);
-               break;
-       case 'U': /* repair ship */
-               e_city_repair (cityp, type);
-               break;
-       case 'Y': /* set army func to attack */
-               e_city_attack (cityp, type);
-               break;
-       default: /* bad command? */
-               huh ();
-               break;
-       }
+    switch (e) {
+    case 'F': /* fill */
+       e_city_fill (cityp, type);
+       break;
+    case 'G': /* explore */
+       e_city_explore (cityp, type);
+       break;
+    case 'I': /* directional stasis */
+       e_city_stasis (cityp, type);
+       break;
+    case 'K': /* turn off function */
+       e_city_wake (cityp, type);
+       break;
+    case 'M': /* start move to location */
+       *path_type = type;
+       e_move (path_start, loc);
+       break;
+    case 'R': /* make piece move randomly */
+       e_city_random (cityp, type);
+       break;
+    case 'U': /* repair ship */
+       e_city_repair (cityp, type);
+       break;
+    case 'Y': /* set army func to attack */
+       e_city_attack (cityp, type);
+       break;
+    default: /* bad command? */
+       huh ();
+       break;
+    }
 }
 
 /*
@@ -428,9 +435,9 @@ Beginning of move to location.
 void
 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? */
-        else *path_start = loc;
+    if (!isupper(user_map[loc].contents)) huh (); /* nothing there? */
+    else if (user_map[loc].contents == 'X') huh (); /* enemy city? */
+    else *path_start = loc;
 }
 
 /*
@@ -440,17 +447,17 @@ End of move to location.
 void
 e_end(loc_t *path_start, loc_t loc, int path_type)
 {
-       city_info_t *cityp;
+    city_info_t *cityp;
        
-       if (*path_start == -1) huh (); /* no path started? */
-       else if (path_type == NOPIECE) e_set_func (*path_start, loc);
-       else {
-               cityp = find_city (*path_start);
-               ASSERT (cityp);
-               e_set_city_func (cityp, path_type, loc);
-       }
-
-       *path_start = -1; /* remember no path in progress */
+    if (*path_start == -1) huh (); /* no path started? */
+    else if (path_type == NOPIECE) e_set_func (*path_start, loc);
+    else {
+       cityp = find_city (*path_start);
+       ASSERT (cityp);
+       e_set_city_func (cityp, path_type, loc);
+    }
+
+    *path_start = -1; /* remember no path in progress */
 }
 
 /*
@@ -460,8 +467,8 @@ Put a piece to sleep.
 void
 e_sleep(loc_t loc)
 {
-       if (user_map[loc].contents == 'O') huh (); /* can't sleep a city */
-       else e_set_func (loc, SENTRY);
+    if (user_map[loc].contents == 'O') huh (); /* can't sleep a city */
+    else e_set_func (loc, SENTRY);
 }
 
 /*
@@ -471,19 +478,22 @@ Print out information about a piece.
 void
 e_info(loc_t edit_cursor)
 {
-       void e_city_info(loc_t), e_piece_info(loc_t edit_cursor, char ab);
-
-       char ab;
-
-       ab = user_map[edit_cursor].contents;
-
-       if (ab == 'O') e_city_info (edit_cursor);
-       else if (ab == 'X' && debug) e_city_info (edit_cursor);
-       else if ((ab >= 'A') && (ab <= 'T'))
-               e_piece_info (edit_cursor, ab);
-       else if ((ab >= 'a') && (ab <= 't') && (debug))
-               e_piece_info (edit_cursor, ab);
-       else huh ();
+    void e_city_info(loc_t), e_piece_info(loc_t edit_cursor, char ab);
+
+    char ab;
+
+    ab = user_map[edit_cursor].contents;
+
+    if (ab == 'O')
+       e_city_info (edit_cursor);
+    else if (ab == 'X' && debug)
+       e_city_info (edit_cursor);
+    else if ((ab >= 'A') && (ab <= 'T'))
+       e_piece_info (edit_cursor, ab);
+    else if ((ab >= 'a') && (ab <= 't') && (debug))
+       e_piece_info (edit_cursor, ab);
+    else
+       huh ();
 }
 
 /*
@@ -493,17 +503,17 @@ Print info about a piece.
 void
 e_piece_info(loc_t edit_cursor, char ab)
 {
-       piece_info_t *obj;
-       int type;
-       char *p;
+    piece_info_t *obj;
+    int type;
+    char *p;
 
-       ab = toupper (ab);
-       p = strchr (type_chars, ab);
-       type = p - type_chars;
+    ab = toupper (ab);
+    p = strchr (type_chars, ab);
+    type = p - type_chars;
 
-       obj = find_obj (type, edit_cursor);
-       ASSERT (obj != NULL);
-       describe_obj (obj);
+    obj = find_obj (type, edit_cursor);
+    ASSERT (obj != NULL);
+    describe_obj (obj);
 }
 
 /*
@@ -513,56 +523,57 @@ Display info on a city.
 void
 e_city_info(loc_t edit_cursor)
 {
-       piece_info_t *obj;
-       city_info_t *cityp;
-       int f, s;
-       char func_buf[STRSIZE];
-       char temp_buf[STRSIZE];
-       char junk_buf2[STRSIZE];
-
-       error (""); /* clear line */
-
-       f = 0; /* no fighters counted yet */
-       for (obj = map[edit_cursor].objp; obj != NULL;
-               obj = obj->loc_link.next)
-                       if (obj->type == FIGHTER) f++;
-
-       s = 0; /* no ships counted yet */
-       for (obj = map[edit_cursor].objp; obj != NULL;
-               obj = obj->loc_link.next)
-                       if (obj->type >= DESTROYER) s++;
-
-       if (f == 1 && s == 1) 
-               (void) sprintf (jnkbuf, "1 fighter landed, 1 ship docked");
-       else if (f == 1)
-               (void) sprintf (jnkbuf, "1 fighter landed, %d ships docked", s);
-       else if (s == 1)
-               (void) sprintf (jnkbuf, "%d fighters landed, 1 ship docked", f);
-       else (void) sprintf (jnkbuf, "%d fighters landed, %d ships docked", f, s);
-
-       cityp = find_city (edit_cursor);
-       ASSERT (cityp != NULL);
-
-       *func_buf = 0; /* nothing in buffer */
-       for (s = 0; s < NUM_OBJECTS; s++) { /* for each piece */
-               if (cityp->func[s] < 0)
-                       (void) sprintf (temp_buf, "%c:%s; ",
-                               piece_attr[s].sname,
-                               func_name[FUNCI(cityp->func[s])]);
-               else (void) sprintf (temp_buf, "%c: %d;",
-                               piece_attr[s].sname,
-                               loc_disp(cityp->func[s]));
+    piece_info_t *obj;
+    city_info_t *cityp;
+    int f, s;
+    char func_buf[STRSIZE];
+    char temp_buf[STRSIZE];
+    char junk_buf2[STRSIZE];
+
+    error (""); /* clear line */
+
+    f = 0; /* no fighters counted yet */
+    for (obj = map[edit_cursor].objp; obj != NULL;
+        obj = obj->loc_link.next)
+       if (obj->type == FIGHTER) f++;
+
+    s = 0; /* no ships counted yet */
+    for (obj = map[edit_cursor].objp; obj != NULL;
+        obj = obj->loc_link.next)
+       if (obj->type >= DESTROYER) s++;
+
+    if (f == 1 && s == 1) 
+       (void) sprintf (jnkbuf, "1 fighter landed, 1 ship docked");
+    else if (f == 1)
+       (void) sprintf (jnkbuf, "1 fighter landed, %d ships docked", s);
+    else if (s == 1)
+       (void) sprintf (jnkbuf, "%d fighters landed, 1 ship docked", f);
+    else
+       (void) sprintf (jnkbuf, "%d fighters landed, %d ships docked", f, s);
+
+    cityp = find_city (edit_cursor);
+    ASSERT (cityp != NULL);
+
+    *func_buf = 0; /* nothing in buffer */
+    for (s = 0; s < NUM_OBJECTS; s++) { /* for each piece */
+       if (cityp->func[s] < 0)
+           (void) sprintf (temp_buf, "%c:%s; ",
+                           piece_attr[s].sname,
+                           func_name[FUNCI(cityp->func[s])]);
+       else (void) sprintf (temp_buf, "%c: %d;",
+                            piece_attr[s].sname,
+                            loc_disp(cityp->func[s]));
                
-               (void) strcat (func_buf, temp_buf);
-       }
+       (void) strcat (func_buf, temp_buf);
+    }
 
-       (void) sprintf (junk_buf2,
-               "City at location %d will complete %s on round %ld",
-               loc_disp(cityp->loc),
-               piece_attr[(int)cityp->prod].article,
-               date + piece_attr[(int)cityp->prod].build_time - cityp->work);
+    (void) sprintf (junk_buf2,
+                   "City at location %d will complete %s on round %ld",
+                   loc_disp(cityp->loc),
+                   piece_attr[(int)cityp->prod].article,
+                   date + piece_attr[(int)cityp->prod].build_time - cityp->work);
 
-       info (junk_buf2, jnkbuf, func_buf);
+    info (junk_buf2, jnkbuf, func_buf);
 }
 
 /*
@@ -572,12 +583,12 @@ Change city production.
 void
 e_prod(loc_t loc)
 {
-       city_info_t *cityp;
+    city_info_t *cityp;
        
-       cityp = find_city (loc);
+    cityp = find_city (loc);
 
-       if (cityp == NULL) huh (); /* no city? */
-       else set_prod (cityp);
+    if (cityp == NULL) huh (); /* no city? */
+    else set_prod (cityp);
 }
 
 /*
@@ -585,8 +596,11 @@ get help
 */
 
 void
-e_help(void) {
-       help (help_edit, edit_lines);
-       prompt ("Press any key to continue: ");
-       (void) get_chx ();
+e_help(void)
+{
+    help (help_edit, edit_lines);
+    prompt ("Press any key to continue: ");
+    (void) get_chx ();
 }
+
+/* end */
index 0768b23..831aec2 100644 (file)
--- a/empire.c
+++ b/empire.c
@@ -25,41 +25,42 @@ void c_examine(void), c_movie(void);
  */
 
 void
-empire(void) {
-       void do_command(char);
-       void print_zoom();
-
-       char order;
-       int turn = 0;
-
-       ttinit (); /* init tty */
-       rndini (); /* init random number generator */
-
-       clear_screen (); /* nothing on screen */
-       pos_str (7, 0, "EMPIRE, Version 5.00 site Amdahl 1-Apr-1988");
-       pos_str (8, 0, "Detailed directions are in EMPIRE.DOC\n");
-       (void) redisplay ();
-
-       if (!restore_game ()) /* try to restore previous game */
-               init_game (); /* otherwise init a new game */
-
-       /* Command loop starts here. */
-
-       for (;;) { /* until user quits */
-           if (automove) { /* don't ask for cmd in auto mode */
-               user_move ();
-               comp_move (1);
-               if (++turn % save_interval == 0)
-                       save_game ();
-           }
-           else {
-               prompt (""); /* blank top line */
-               void redisplay();
-               prompt ("Your orders? ");
-               order = get_chx (); /* get a command */
-               do_command (order);
-           }
+empire(void)
+{
+    void do_command(char);
+    void print_zoom();
+
+    char order;
+    int turn = 0;
+
+    ttinit (); /* init tty */
+    rndini (); /* init random number generator */
+
+    clear_screen (); /* nothing on screen */
+    pos_str (7, 0, "EMPIRE, Version 5.00 site Amdahl 1-Apr-1988");
+    pos_str (8, 0, "Detailed directions are in EMPIRE.DOC\n");
+    (void) redisplay ();
+
+    if (!restore_game ()) /* try to restore previous game */
+       init_game (); /* otherwise init a new game */
+
+    /* Command loop starts here. */
+
+    for (;;) { /* until user quits */
+       if (automove) { /* don't ask for cmd in auto mode */
+           user_move ();
+           comp_move (1);
+           if (++turn % save_interval == 0)
+               save_game ();
+       }
+       else {
+           prompt (""); /* blank top line */
+           void redisplay();
+           prompt ("Your orders? ");
+           order = get_chx (); /* get a command */
+           do_command (order);
        }
+    }
 }
 
 /*
@@ -69,114 +70,114 @@ Execute a command.
 void
 do_command(char orders)
 {
-       void c_debug(char order), c_quit(void), c_sector(void), c_map(void);
-       void c_give(void);
-
-       char e;
-       int ncycle;
-
-       switch (orders) {
-       case 'A': /* turn on auto move mode */
-               automove = true;
-               error ("Now in Auto-Mode");
-               user_move ();
-               comp_move (1);
-               save_game ();
-               break;
-
-       case 'C': /* give a city to the computer */
-               c_give ();
-               break;
+    void c_debug(char order), c_quit(void), c_sector(void), c_map(void);
+    void c_give(void);
+
+    char e;
+    int ncycle;
+
+    switch (orders) {
+    case 'A': /* turn on auto move mode */
+       automove = true;
+       error ("Now in Auto-Mode");
+       user_move ();
+       comp_move (1);
+       save_game ();
+       break;
+
+    case 'C': /* give a city to the computer */
+       c_give ();
+       break;
        
-       case 'D': /* display round number */
-               error ("Round #%d", date);
-               break;
-
-       case 'E': /* examine enemy map */
-               if (resigned) c_examine ();
-               else huh (); /* illegal command */
-               break;
-
-       case 'F': /* print map to file */
-               c_map ();
-               break;
-
-       case 'G': /* give one free enemy move */
-               comp_move (1);
-               break;
-
-       case 'H': /* help */
-               help (help_cmd, cmd_lines);
-               break;
-
-       case 'J': /* edit mode */
-               ncycle = cur_sector ();
-               if (ncycle == -1) ncycle = 0;
-               edit (sector_loc (ncycle));
-               break;
-
-       case 'M': /* move */
-               user_move ();
-               comp_move (1);
-               save_game ();
-               break;
-
-       case 'N': /* give enemy free moves */
-               ncycle = getint ("Number of free enemy moves: ");
-               comp_move (ncycle);
-               save_game ();
-               break;
-
-       case 'P': /* print a sector */
-               c_sector ();
-               break;
-
-       case '\026': /* some interrupt */
-       case 'Q': /* quit */
-               c_quit ();
-               break;
-
-       case 'R': /* restore game */
-               clear_screen ();
-               e = restore_game ();
-               break;
-
-       case 'S': /* save game */
-               save_game ();
-               break;
+    case 'D': /* display round number */
+       error ("Round #%d", date);
+       break;
+
+    case 'E': /* examine enemy map */
+       if (resigned) c_examine ();
+       else huh (); /* illegal command */
+       break;
+
+    case 'F': /* print map to file */
+       c_map ();
+       break;
+
+    case 'G': /* give one free enemy move */
+       comp_move (1);
+       break;
+
+    case 'H': /* help */
+       help (help_cmd, cmd_lines);
+       break;
+
+    case 'J': /* edit mode */
+       ncycle = cur_sector ();
+       if (ncycle == -1) ncycle = 0;
+       edit (sector_loc (ncycle));
+       break;
+
+    case 'M': /* move */
+       user_move ();
+       comp_move (1);
+       save_game ();
+       break;
+
+    case 'N': /* give enemy free moves */
+       ncycle = getint ("Number of free enemy moves: ");
+       comp_move (ncycle);
+       save_game ();
+       break;
+
+    case 'P': /* print a sector */
+       c_sector ();
+       break;
+
+    case '\026': /* some interrupt */
+    case 'Q': /* quit */
+       c_quit ();
+       break;
+
+    case 'R': /* restore game */
+       clear_screen ();
+       e = restore_game ();
+       break;
+
+    case 'S': /* save game */
+       save_game ();
+       break;
        
-       case 'T': /* trace: toggle save_movie flag */
-               save_movie = !save_movie;
-               if (save_movie) comment ("Saving movie screens to 'empmovie.dat'.");
-               else comment ("No longer saving movie screens.");
-               break;
-
-       case 'W': /* watch movie */
-               if (resigned || debug) replay_movie ();
-               else error ("You cannot watch movie until computer resigns.");
-               break;
-
-       case 'Z': /* print compressed map */
-               print_zoom (user_map);
-               break;
-
-       case '\014': /* redraw the screen */
-               redraw ();
-               break;
-
-       case '+': /* change debug state */
-               e = get_chx();
-               if ( e  ==  '+' ) debug = true;
-               else if ( e  ==  '-' ) debug = false;
-               else huh ();
-               break;
-
-       default:
-               if (debug) c_debug (orders); /* debug */
-               else huh (); /* illegal command */
-               break;
-       }
-       e = e; /* keep lint quiet */
+    case 'T': /* trace: toggle save_movie flag */
+       save_movie = !save_movie;
+       if (save_movie) comment ("Saving movie screens to 'empmovie.dat'.");
+       else comment ("No longer saving movie screens.");
+       break;
+
+    case 'W': /* watch movie */
+       if (resigned || debug) replay_movie ();
+       else error ("You cannot watch movie until computer resigns.");
+       break;
+
+    case 'Z': /* print compressed map */
+       print_zoom (user_map);
+       break;
+
+    case '\014': /* redraw the screen */
+       redraw ();
+       break;
+
+    case '+': /* change debug state */
+       e = get_chx();
+       if ( e  ==  '+' ) debug = true;
+       else if ( e  ==  '-' ) debug = false;
+       else huh ();
+       break;
+
+    default:
+       if (debug) c_debug (orders); /* debug */
+       else huh (); /* illegal command */
+       break;
+    }
+    e = e; /* keep lint quiet */
 }
 
 /*
@@ -186,28 +187,29 @@ it as the computers.
 */
 
 void
-c_give(void) {
-       int unowned[NUM_CITY];
-       count_t i, count;
-
-       count = 0; /* nothing in list yet */
-       for (i = 0; i < NUM_CITY; i++) {
-               if (city[i].owner == UNOWNED) {
-                       unowned[count] = i; /* remember this city */
-                       count += 1;
-               }
-       }
-       if (count == 0) {
-               error ("There are no unowned cities.");
-               ksend ("There are no unowned cities.");
-               return;
+c_give(void)
+{
+    int unowned[NUM_CITY];
+    count_t i, count;
+
+    count = 0; /* nothing in list yet */
+    for (i = 0; i < NUM_CITY; i++) {
+       if (city[i].owner == UNOWNED) {
+           unowned[count] = i; /* remember this city */
+           count += 1;
        }
-       i = irand (count);
-       i = unowned[i]; /* get city index */
-       city[i].owner = COMP;
-       city[i].prod = NOPIECE;
-       city[i].work = 0;
-       scan (comp_map, city[i].loc);
+    }
+    if (count == 0) {
+       error ("There are no unowned cities.");
+       ksend ("There are no unowned cities.");
+       return;
+    }
+    i = irand (count);
+    i = unowned[i]; /* get city index */
+    city[i].owner = COMP;
+    city[i].prod = NOPIECE;
+    city[i].work = 0;
+    scan (comp_map, city[i].loc);
 }
 
 /*
@@ -218,32 +220,38 @@ The order cannot be any legal command.
 void
 c_debug(char order)
 {
-       char e;
+    char e;
 
-       switch (order) {
-       case '#' : c_examine (); break;
-       case '%' : c_movie (); break;
+    switch (order) {
+    case '#' : c_examine (); break;
+    case '%' : c_movie (); break;
        
-       case '@': /* change trace state */
-               e = get_chx();
-               if ( e  ==  '+' ) trace_pmap = true;
-               else if ( e  ==  '-' ) trace_pmap = false;
-               else huh ();
-               break;
-
-       case '$': /* change print_debug state */
-               e = get_chx();
-               if ( e  ==  '+' ) print_debug = true;
-               else if ( e  ==  '-' ) print_debug = false;
-               else huh ();
-               break;
-
-       case '&': /* change print_vmap state */
-               print_vmap = get_chx();
-               break;
-
-       default: huh (); break;
-       }
+    case '@': /* change trace state */
+       e = get_chx();
+       if ( e  ==  '+' )
+           trace_pmap = true;
+       else if ( e  ==  '-' )
+           trace_pmap = false;
+       else
+           huh ();
+       break;
+
+    case '$': /* change print_debug state */
+       e = get_chx();
+       if ( e  ==  '+' )
+           print_debug = true;
+       else if ( e  ==  '-' )
+           print_debug = false;
+       else
+           huh ();
+       break;
+
+    case '&': /* change print_vmap state */
+       print_vmap = get_chx();
+       break;
+
+    default: huh (); break;
+    }
 }
 
 /*
@@ -251,10 +259,11 @@ The quit command.  Make sure the user really wants to quit.
 */
 
 void
-c_quit(void) {
-       if (getyn ("QUIT - Are you sure? ")) {
-           empend ();
-       }
+c_quit(void)
+{
+    if (getyn ("QUIT - Are you sure? ")) {
+       empend ();
+    }
 }
 
 /*
@@ -263,11 +272,12 @@ and print it.
 */
 
 void
-c_sector(void) {
-       int num;
+c_sector(void)
+{
+    int num;
 
-       num = get_range ("Sector number? ", 0, NUM_SECTORS-1);
-       print_sector_u (num);
+    num = get_range ("Sector number? ", 0, NUM_SECTORS-1);
+    print_sector_u (num);
 }
 
 /*
@@ -278,32 +288,33 @@ out the map.
 */
 
 void
-c_map(void) {
-       FILE *f;
-       int i, j;
-       char line[MAP_HEIGHT+2];
-
-       prompt ("Filename? ");
-       get_str (jnkbuf, STRSIZE);
-
-       f = fopen (jnkbuf, "w");
-       if (f == NULL) {
-               error ("I can't open that file.");
-               return;
+c_map(void)
+{
+    FILE *f;
+    int i, j;
+    char line[MAP_HEIGHT+2];
+
+    prompt ("Filename? ");
+    get_str (jnkbuf, STRSIZE);
+
+    f = fopen (jnkbuf, "w");
+    if (f == NULL) {
+       error ("I can't open that file.");
+       return;
+    }
+    for (i = 0; i < MAP_WIDTH; i++) { /* for each column */
+       for (j = MAP_HEIGHT-1; j >= 0; j--) { /* for each row */
+           line[MAP_HEIGHT-1-j] = user_map[row_col_loc(j,i)].contents;
        }
-       for (i = 0; i < MAP_WIDTH; i++) { /* for each column */
-               for (j = MAP_HEIGHT-1; j >= 0; j--) { /* for each row */
-                        line[MAP_HEIGHT-1-j] = user_map[row_col_loc(j,i)].contents;
-               }
-               j = MAP_HEIGHT-1;
-               while (j >= 0 && line[j] == ' ') /* scan off trailing blanks */
-                       j -= 1;
+       j = MAP_HEIGHT-1;
+       while (j >= 0 && line[j] == ' ') /* scan off trailing blanks */
+           j -= 1;
                        
-               line[++j] = '\n';
-               line[++j] = 0; /* trailing null */
-               (void) fputs (line, f);
-       }
-       (void) fclose (f);
+       line[++j] = '\n';
+       line[++j] = 0; /* trailing null */
+       (void) fputs (line, f);
+    }
+    (void) fclose (f);
 }
 
 /*
@@ -311,11 +322,12 @@ Allow user to examine the computer's map.
 */
 
 void
-c_examine(void) {
-       int num;
+c_examine(void)
+{
+    int num;
 
-       num = get_range ("Sector number? ", 0, NUM_SECTORS-1);
-       print_sector_c (num);
+    num = get_range ("Sector number? ", 0, NUM_SECTORS-1);
+    print_sector_c (num);
 }
 
 /*
@@ -324,13 +336,16 @@ Print a "zoomed" version of the computer's map.
 */
 
 void
-c_movie(void) {
-       for (;;) {
-               comp_move (1);
-               print_zoom (comp_map);
-               save_game ();
+c_movie(void)
+{
+    for (;;) {
+       comp_move (1);
+       print_zoom (comp_map);
+       save_game ();
 #ifdef PROFILE
-               if (date == 125) empend();
+       if (date == 125) empend();
 #endif
-       }
+    }
 }
+
+/* end */
diff --git a/game.c b/game.c
index cac4ef0..d2d132b 100644 (file)
--- a/game.c
+++ b/game.c
@@ -30,51 +30,53 @@ on the map, select cities for each opponent, and zero out the lists of
 pieces on the board.
 */
 
-void init_game(void) {
-       void make_map(void), place_cities(void);
-
-       count_t i;
-
-       kill_display (); /* nothing on screen */
-       automove = false;
-       resigned = false;
-       debug = false;
-       print_debug = false;
-       print_vmap = false;
-       trace_pmap = false;
-       save_movie = false;
-       win = 0;
-       date = 0; /* no date yet */
-       user_score = 0;
-       comp_score = 0;
+void init_game(void)
+{
+    void make_map(void), place_cities(void);
+
+    count_t i;
+
+    kill_display (); /* nothing on screen */
+    automove = false;
+    resigned = false;
+    debug = false;
+    print_debug = false;
+    print_vmap = false;
+    trace_pmap = false;
+    save_movie = false;
+    win = 0;
+    date = 0; /* no date yet */
+    user_score = 0;
+    comp_score = 0;
        
-       for (i = 0; i < MAP_SIZE; i++) {
-               user_map[i].contents = ' '; /* nothing seen yet */
-               user_map[i].seen = 0;
-               comp_map[i].contents = ' ';
-               comp_map[i].seen = 0;
-       }
-       for (i = 0; i < NUM_OBJECTS; i++) {
-               user_obj[i] = NULL;
-               comp_obj[i] = NULL;
+    for (i = 0; i < MAP_SIZE; i++) {
+       user_map[i].contents = ' '; /* nothing seen yet */
+       user_map[i].seen = 0;
+       comp_map[i].contents = ' ';
+       comp_map[i].seen = 0;
+    }
+    for (i = 0; i < NUM_OBJECTS; i++) {
+       user_obj[i] = NULL;
+       comp_obj[i] = NULL;
+    }
+    free_list = NULL; /* nothing free yet */
+    for (i = 0; i < LIST_SIZE; i++) { /* for each object */
+       piece_info_t *obj = &(object[i]);
+       obj->hits = 0; /* mark object as dead */
+       obj->owner = UNOWNED;
+       LINK (free_list, obj, piece_link); 
+    }
+
+    make_map (); /* make land and water */
+
+    do {
+       for (i = 0; i < MAP_SIZE; i ++) { /* remove cities */
+           if (map[i].contents == '*')
+               map[i].contents = '+'; /* land */
        }
-       free_list = NULL; /* nothing free yet */
-       for (i = 0; i < LIST_SIZE; i++) { /* for each object */
-               piece_info_t *obj = &(object[i]);
-               obj->hits = 0; /* mark object as dead */
-               obj->owner = UNOWNED;
-               LINK (free_list, obj, piece_link); 
-       }
-
-       make_map (); /* make land and water */
-
-       do {
-               for (i = 0; i < MAP_SIZE; i ++) { /* remove cities */
-                       if (map[i].contents == '*')
-                               map[i].contents = '+'; /* land */
-               }
-               place_cities (); /* place cities on map */
-       } while (!select_cities ()); /* choose a city for each player */
+       place_cities (); /* place cities on map */
+    } while
+       (!select_cities ()); /* choose a city for each player */
 }
 
 /*
@@ -95,65 +97,66 @@ at program start up.
 static int height[2][MAP_SIZE];
 static int height_count[MAX_HEIGHT+1];
 
-void make_map(void) {
-       int from, to, k;
-       count_t i, j, sum;
-       loc_t loc;
-
-       for (i = 0; i < MAP_SIZE; i++) /* fill map with random sand */
-               height[0][i] = irand (MAX_HEIGHT);
-
-       from = 0;
-       to = 1;
-       for (i = 0; i < SMOOTH; i++) { /* smooth the map */
-           for (j = 0; j < MAP_SIZE; j++) {
-               sum = height[from][j];
-               for (k = 0; k < 8; k++) {
-                       loc = j + dir_offset[k];
-                       /* edges get smoothed in a wierd fashion */
-                       if (loc < 0 || loc >= MAP_SIZE) loc = j;
-                       sum += height[from][loc];
-               }
-               height[to][j] = sum / 9;
+void make_map(void)
+{
+    int from, to, k;
+    count_t i, j, sum;
+    loc_t loc;
+
+    for (i = 0; i < MAP_SIZE; i++) /* fill map with random sand */
+       height[0][i] = irand (MAX_HEIGHT);
+
+    from = 0;
+    to = 1;
+    for (i = 0; i < SMOOTH; i++) { /* smooth the map */
+       for (j = 0; j < MAP_SIZE; j++) {
+           sum = height[from][j];
+           for (k = 0; k < 8; k++) {
+               loc = j + dir_offset[k];
+               /* edges get smoothed in a wierd fashion */
+               if (loc < 0 || loc >= MAP_SIZE) loc = j;
+               sum += height[from][loc];
            }
-           k = to; /* swap to and from */
-           to = from;
-           from = k;
+           height[to][j] = sum / 9;
        }
-
-       /* count the number of cells at each height */
-       for (i = 0; i <= MAX_HEIGHT; i++)
-               height_count[i] = 0;
-
-       for (i = 0; i <= MAP_SIZE; i++)
-               height_count[height[from][i]]++;
-
-       /* find the water line */
-       loc = MAX_HEIGHT; /* default to all water */
-       sum = 0;
-       for (i = 0; i <= MAX_HEIGHT; i++) {
-               sum += height_count[i];
-               if (sum * 100 / MAP_SIZE > WATER_RATIO && sum >= NUM_CITY) {
-                       loc = i; /* this is last height that is water */
-                       break;
-               }
+       k = to; /* swap to and from */
+       to = from;
+       from = k;
+    }
+
+    /* count the number of cells at each height */
+    for (i = 0; i <= MAX_HEIGHT; i++)
+       height_count[i] = 0;
+
+    for (i = 0; i <= MAP_SIZE; i++)
+       height_count[height[from][i]]++;
+
+    /* find the water line */
+    loc = MAX_HEIGHT; /* default to all water */
+    sum = 0;
+    for (i = 0; i <= MAX_HEIGHT; i++) {
+       sum += height_count[i];
+       if (sum * 100 / MAP_SIZE > WATER_RATIO && sum >= NUM_CITY) {
+           loc = i; /* this is last height that is water */
+           break;
        }
+    }
 
-       /* mark the land and water */
-       for (i = 0; i < MAP_SIZE; i ++) {
-               if (height[from][i] > loc)
-                       map[i].contents = '+'; /* land */
-               else map[i].contents = '.'; /* water */
+    /* mark the land and water */
+    for (i = 0; i < MAP_SIZE; i ++) {
+       if (height[from][i] > loc)
+           map[i].contents = '+'; /* land */
+       else map[i].contents = '.'; /* water */
 
-               map[i].objp = NULL; /* nothing in cell yet */
-               map[i].cityp = NULL;
+       map[i].objp = NULL; /* nothing in cell yet */
+       map[i].cityp = NULL;
 
-               j = loc_col (i);
-               k = loc_row (i);
+       j = loc_col (i);
+       k = loc_row (i);
 
-               map[i].on_board = !(j == 0 || j == MAP_WIDTH-1 
-                                || k == 0 || k == MAP_HEIGHT-1);
-       }
+       map[i].on_board = !(j == 0 || j == MAP_WIDTH-1 
+                           || k == 0 || k == MAP_HEIGHT-1);
+    }
 }
 
 /*
@@ -167,35 +170,36 @@ 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) {
-       count_t regen_land();
-
-       count_t placed, i;
-       loc_t loc;
-       count_t num_land;
-
-       num_land = 0; /* nothing in land array yet */
-       placed = 0; /* nothing placed yet */
-       while (placed < NUM_CITY) {
-               while (num_land == 0) num_land = regen_land (placed);
-               i = irand (num_land-1); /* select random piece of land */
-               loc = land[i];
+void place_cities(void)
+{
+    count_t regen_land();
+
+    count_t placed, i;
+    loc_t loc;
+    count_t num_land;
+
+    num_land = 0; /* nothing in land array yet */
+    placed = 0; /* nothing placed yet */
+    while (placed < NUM_CITY) {
+       while (num_land == 0) num_land = regen_land (placed);
+       i = irand (num_land-1); /* select random piece of land */
+       loc = land[i];
                
-               city[placed].loc = loc;
-               city[placed].owner = UNOWNED;
-               city[placed].work = 0;
-               city[placed].prod = NOPIECE;
+       city[placed].loc = loc;
+       city[placed].owner = UNOWNED;
+       city[placed].work = 0;
+       city[placed].prod = NOPIECE;
                
-               for (i = 0; i < NUM_OBJECTS; i++)
-                       city[placed].func[i] = NOFUNC; /* no function */
+       for (i = 0; i < NUM_OBJECTS; i++)
+           city[placed].func[i] = NOFUNC; /* no function */
                        
-               map[loc].contents = '*';
-               map[loc].cityp = &(city[placed]);
-               placed++;
+       map[loc].contents = '*';
+       map[loc].cityp = &(city[placed]);
+       placed++;
 
-               /* Now remove any land too close to selected land. */
-               num_land = remove_land (loc, num_land);
-       }
+       /* Now remove any land too close to selected land. */
+       num_land = remove_land (loc, num_land);
+    }
 }
 
 /*
@@ -206,24 +210,24 @@ remove any land which is too close to a city.
 
 count_t regen_land(count_t placed)
 {
-       count_t num_land;
-       count_t i;
-
-       num_land = 0;
-       for (i = 0; i < MAP_SIZE; i++) {
-               if (map[i].on_board && map[i].contents == '+') {
-                       land[num_land] = i; /* remember piece of land */
-                       num_land++; /* remember number of pieces */
-               }
-       }
-       if (placed > 0) { /* don't decrement 1st time */
-               MIN_CITY_DIST -= 1;
-               ASSERT (MIN_CITY_DIST >= 0);
+    count_t num_land;
+    count_t i;
+
+    num_land = 0;
+    for (i = 0; i < MAP_SIZE; i++) {
+       if (map[i].on_board && map[i].contents == '+') {
+           land[num_land] = i; /* remember piece of land */
+           num_land++; /* remember number of pieces */
        }
-       for (i = 0; i < placed; i++) { /* for each placed city */
-               num_land = remove_land (city[i].loc, num_land);
-       }
-       return (num_land);
+    }
+    if (placed > 0) { /* don't decrement 1st time */
+       MIN_CITY_DIST -= 1;
+       ASSERT (MIN_CITY_DIST >= 0);
+    }
+    for (i = 0; i < placed; i++) { /* for each placed city */
+       num_land = remove_land (city[i].loc, num_land);
+    }
+    return (num_land);
 }
 
 /*
@@ -232,16 +236,16 @@ Remove land that is too close to a city.
 
 count_t remove_land(loc_t loc, count_t num_land)
 {
-       count_t new, i;
+    count_t new, i;
 
-       new = 0; /* nothing kept yet */
-       for (i = 0; i < num_land; i++) {
-               if (dist (loc, land[i]) >= MIN_CITY_DIST) {
-                       land[new] = land[i];
-                       new++;
-               }
+    new = 0; /* nothing kept yet */
+    for (i = 0; i < num_land; i++) {
+       if (dist (loc, land[i]) >= MIN_CITY_DIST) {
+           land[new] = land[i];
+           new++;
        }
-       return (new);
+    }
+    return (new);
 }
 
 /*
@@ -294,49 +298,50 @@ 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 */
 
-bool select_cities(void) {
-       void find_cont(void), make_pair(void);
+bool select_cities(void)
+{
+    void find_cont(void), make_pair(void);
 
-       loc_t compi, useri;
-       city_info_t *compp, *userp;
-       int comp_cont, user_cont;
-       int pair;
+    loc_t compi, useri;
+    city_info_t *compp, *userp;
+    int comp_cont, user_cont;
+    int pair;
 
-       find_cont (); /* find and rank the continents */
-       if (ncont == 0) return (false); /* there are no good continents */
+    find_cont (); /* find and rank the continents */
+    if (ncont == 0) return (false); /* there are no good continents */
 
-       make_pair (); /* create list of ranked pairs */
+    make_pair (); /* create list of ranked pairs */
 
-       (void) sprintf (jnkbuf,
-               "Choose a difficulty level where 0 is easy and %d is hard: ",
-               ncont*ncont-1);
+    (void) sprintf (jnkbuf,
+                   "Choose a difficulty level where 0 is easy and %d is hard: ",
+                   ncont*ncont-1);
 
-       pair = get_range (jnkbuf, 0, ncont*ncont-1);
-       comp_cont = pair_tab[pair].comp_cont;
-       user_cont = pair_tab[pair].user_cont;
+    pair = get_range (jnkbuf, 0, ncont*ncont-1);
+    comp_cont = pair_tab[pair].comp_cont;
+    user_cont = pair_tab[pair].user_cont;
 
-       compi = irand ((long)cont_tab[comp_cont].ncity);
-       compp = cont_tab[comp_cont].cityp[compi];
+    compi = irand ((long)cont_tab[comp_cont].ncity);
+    compp = cont_tab[comp_cont].cityp[compi];
 
-       do { /* select different user city */
-               useri = irand ((long)cont_tab[user_cont].ncity);
-               userp = cont_tab[user_cont].cityp[useri];
-       } while (userp == compp);
+    do { /* select different user city */
+       useri = irand ((long)cont_tab[user_cont].ncity);
+       userp = cont_tab[user_cont].cityp[useri];
+    } while (userp == compp);
 
-       topmsg(1, "Your city is at %d.", loc_disp(userp->loc));
-       delay (); /* let user see output before we set_prod */
+    topmsg(1, "Your city is at %d.", loc_disp(userp->loc));
+    delay (); /* let user see output before we set_prod */
 
-       /* update city and map */
-       compp->owner = COMP;
-       compp->prod = ARMY;
-       compp->work = 0;
-       scan (comp_map, compp->loc);
+    /* update city and map */
+    compp->owner = COMP;
+    compp->prod = ARMY;
+    compp->work = 0;
+    scan (comp_map, compp->loc);
 
-       userp->owner = USER;
-       userp->work = 0;
-       scan (user_map, userp->loc);
-       set_prod (userp);
-       return (true);
+    userp->owner = USER;
+    userp->work = 0;
+    scan (user_map, userp->loc);
+    set_prod (userp);
+    return (true);
 }
 
 /*
@@ -344,17 +349,19 @@ Find all continents with 2 cities or more, one of which must be a shore
 city.  We rank the continents.
 */
 
-void find_cont(void) {
-       loc_t i;
-       loc_t mapi;
+void find_cont(void)
+{
+    loc_t i;
+    loc_t mapi;
 
-       for (i = 0; i < MAP_SIZE; i++) marked[i] = 0; /* nothing marked yet */
+    for (i = 0; i < MAP_SIZE; i++) marked[i] = 0; /* nothing marked yet */
 
-       ncont = 0; /* no continents found yet */
-       mapi = 0;
+    ncont = 0; /* no continents found yet */
+    mapi = 0;
 
-       while (ncont < MAX_CONT)
-               if (!find_next (&mapi)) return; /* all found */
+    while (ncont < MAX_CONT)
+       if (!find_next (&mapi))
+           return; /* all found */
 }
 
 /*
@@ -364,29 +371,29 @@ If there are no more continents, we return false.
 
 bool find_next(loc_t *mapi)
 {
-       count_t i;
-       long val;
-
-       for (;;) {
-               if (*mapi >= MAP_SIZE) return (false);
-
-               if (!map[*mapi].on_board || marked[*mapi]
-                       || map[*mapi].contents == '.') *mapi += 1;
-               else if (good_cont (*mapi)) {
-                       rank_tab[ncont] = ncont; /* insert cont in rank tab */
-                       val = cont_tab[ncont].value;
-
-                       for (i = ncont; i > 0; i--) { /* bubble up new rank */
-                               if (val > cont_tab[rank_tab[i-1]].value) {
-                                       rank_tab[i] = rank_tab[i-1];
-                                       rank_tab[i-1] = ncont;
-                               }
-                               else break;
-                       }
-                       ncont++; /* count continents */
-                       return (true);
+    count_t i;
+    long val;
+
+    for (;;) {
+       if (*mapi >= MAP_SIZE) return (false);
+
+       if (!map[*mapi].on_board || marked[*mapi]
+           || map[*mapi].contents == '.') *mapi += 1;
+       else if (good_cont (*mapi)) {
+           rank_tab[ncont] = ncont; /* insert cont in rank tab */
+           val = cont_tab[ncont].value;
+
+           for (i = ncont; i > 0; i--) { /* bubble up new rank */
+               if (val > cont_tab[rank_tab[i-1]].value) {
+                   rank_tab[i] = rank_tab[i-1];
+                   rank_tab[i-1] = ncont;
                }
+               else break;
+           }
+           ncont++; /* count continents */
+           return (true);
        }
+    }
 }
 
 /*
@@ -401,29 +408,29 @@ static void mark_cont(loc_t);
 
 bool good_cont(loc_t mapi)
 {
-       long val;
+    long val;
 
-       ncity = 0; /* nothing seen yet */
-       nland = 0;
-       nshore = 0;
+    ncity = 0; /* nothing seen yet */
+    nland = 0;
+    nshore = 0;
 
-       mark_cont (mapi);
+    mark_cont (mapi);
 
-       if (nshore < 1 || ncity < 2) return (false);
+    if (nshore < 1 || ncity < 2) return (false);
 
-       /* The first two cities, one of which must be a shore city,
-       don't contribute to the value.  Otherwise shore cities are
-       worth 3/2 an inland city.  A city is worth 1000 times as much
-       as land area. */
+    /* The first two cities, one of which must be a shore city,
+       don't contribute to the value.  Otherwise shore cities are
+       worth 3/2 an inland city.  A city is worth 1000 times as much
+       as land area. */
 
-       if (ncity == nshore) val = (nshore - 2) * 3;
-       else val = (nshore-1) * 3 + (ncity - nshore - 1) * 2;
+    if (ncity == nshore) val = (nshore - 2) * 3;
+    else val = (nshore-1) * 3 + (ncity - nshore - 1) * 2;
 
-       val *= 1000; /* cities are worth a lot */
-       val += nland;
-       cont_tab[ncont].value = val;
-       cont_tab[ncont].ncity = ncity;
-       return (true);
+    val *= 1000; /* cities are worth a lot */
+    val += nland;
+    cont_tab[ncont].value = val;
+    cont_tab[ncont].ncity = ncity;
+    return (true);
 }
 
 /*
@@ -436,22 +443,22 @@ cities for the continent.  We then examine each surrounding cell.
 static void
 mark_cont(loc_t mapi)
 {
-       int i;
+    int i;
 
-       if (marked[mapi] || map[mapi].contents == '.'
-               || !map[mapi].on_board) return;
+    if (marked[mapi] || map[mapi].contents == '.'
+       || !map[mapi].on_board) return;
 
-       marked[mapi] = 1; /* mark this cell seen */
-       nland++; /* count land on continent */
+    marked[mapi] = 1; /* mark this cell seen */
+    nland++; /* count land on continent */
 
-       if (map[mapi].contents == '*') { /* a city? */
-               cont_tab[ncont].cityp[ncity] = map[mapi].cityp;
-               ncity++;
-               if (rmap_shore (mapi)) nshore++;
-       }
+    if (map[mapi].contents == '*') { /* a city? */
+       cont_tab[ncont].cityp[ncity] = map[mapi].cityp;
+       ncity++;
+       if (rmap_shore (mapi)) nshore++;
+    }
 
-       for (i = 0; i < 8; i++) /* look at surrounding squares */
-               mark_cont (mapi + dir_offset[i]);
+    for (i = 0; i < 8; i++) /* look at surrounding squares */
+       mark_cont (mapi + dir_offset[i]);
 }
 
 /*
@@ -461,28 +468,29 @@ 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) {
-       int i, j, k, npair;
-       long val;
+void make_pair(void)
+{
+    int i, j, k, npair;
+    long val;
 
-       npair = 0; /* none yet */
+    npair = 0; /* none yet */
 
-       for (i = 0; i < ncont; i++)
+    for (i = 0; i < ncont; i++)
        for (j = 0; j < ncont; j++) { /* loop through all continents */
-               val = cont_tab[i].value - cont_tab[j].value;
-               pair_tab[npair].value = val;
-               pair_tab[npair].user_cont = i;
-               pair_tab[npair].comp_cont = j;
-
-               for (k = npair; k > 0; k--) { /* bubble up new rank */
-                       if (val > pair_tab[k-1].value) {
-                               pair_tab[k] = pair_tab[k-1];
-                               pair_tab[k-1].user_cont = i;
-                               pair_tab[k-1].comp_cont = j;
-                       }
-                       else break;
+           val = cont_tab[i].value - cont_tab[j].value;
+           pair_tab[npair].value = val;
+           pair_tab[npair].user_cont = i;
+           pair_tab[npair].comp_cont = j;
+
+           for (k = npair; k > 0; k--) { /* bubble up new rank */
+               if (val > pair_tab[k-1].value) {
+                   pair_tab[k] = pair_tab[k-1];
+                   pair_tab[k-1].user_cont = i;
+                   pair_tab[k-1].comp_cont = j;
                }
-               npair++; /* count pairs */
+               else break;
+           }
+           npair++; /* count pairs */
        }
 }
 
@@ -496,33 +504,34 @@ 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) {
-       FILE *f; /* file to save game in */
-
-       f = fopen (savefile, "w"); /* open for output */
-       if (f == NULL) {
-               perror ("Cannot save saved game");
-               return;
-       }
-       wbuf (map);
-       wbuf (comp_map);
-       wbuf (user_map);
-       wbuf (city);
-       wbuf (object);
-       wbuf (user_obj);
-       wbuf (comp_obj);
-       wval (free_list);
-       wval (date);
-       wval (automove);
-       wval (resigned);
-       wval (debug);
-       wval (win);
-       wval (save_movie);
-       wval (user_score);
-       wval (comp_score);
-
-       (void) fclose (f);
-       topmsg (3, "Game saved.");
+void save_game(void)
+{
+    FILE *f; /* file to save game in */
+
+    f = fopen (savefile, "w"); /* open for output */
+    if (f == NULL) {
+       perror ("Cannot save saved game");
+       return;
+    }
+    wbuf (map);
+    wbuf (comp_map);
+    wbuf (user_map);
+    wbuf (city);
+    wbuf (object);
+    wbuf (user_obj);
+    wbuf (comp_obj);
+    wval (free_list);
+    wval (date);
+    wval (automove);
+    wval (resigned);
+    wval (debug);
+    wval (win);
+    wval (save_movie);
+    wval (user_score);
+    wval (comp_score);
+
+    (void) fclose (f);
+    topmsg (3, "Game saved.");
 }
 
 /*
@@ -533,85 +542,86 @@ 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) {
-       void read_embark();
+int restore_game(void)
+{
+    void read_embark();
        
-       FILE *f; /* file to save game in */
-       long i;
-       piece_info_t **list;
-       piece_info_t *obj;
-
-       f = fopen (savefile, "r"); /* open for input */
-       if (f == NULL) {
-               perror ("Cannot open saved game");
-               return (false);
-       }
-       rbuf (map);
-       rbuf (comp_map);
-       rbuf (user_map);
-       rbuf (city);
-       rbuf (object);
-       rbuf (user_obj);
-       rbuf (comp_obj);
-       rval (free_list);
-       rval (date);
-       rval (automove);
-       rval (resigned);
-       rval (debug);
-       rval (win);
-       rval (save_movie);
-       rval (user_score);
-       rval (comp_score);
-
-       /* Our pointers may not be valid because of source
-       changes or other things.  We recreate them. */
+    FILE *f; /* file to save game in */
+    long i;
+    piece_info_t **list;
+    piece_info_t *obj;
+
+    f = fopen (savefile, "r"); /* open for input */
+    if (f == NULL) {
+       perror ("Cannot open saved game");
+       return (false);
+    }
+    rbuf (map);
+    rbuf (comp_map);
+    rbuf (user_map);
+    rbuf (city);
+    rbuf (object);
+    rbuf (user_obj);
+    rbuf (comp_obj);
+    rval (free_list);
+    rval (date);
+    rval (automove);
+    rval (resigned);
+    rval (debug);
+    rval (win);
+    rval (save_movie);
+    rval (user_score);
+    rval (comp_score);
+
+    /* Our pointers may not be valid because of source
+       changes or other things.  We recreate them. */
        
-       free_list = NULL; /* zero all ptrs */
-       for (i = 0; i < MAP_SIZE; i++) {
-               map[i].cityp = NULL;
-               map[i].objp = NULL;
-       }
-       for (i = 0; i < LIST_SIZE; i++) {
-               object[i].loc_link.next = NULL;
-               object[i].loc_link.prev = NULL;
-               object[i].cargo_link.next = NULL;
-               object[i].cargo_link.prev = NULL;
-               object[i].piece_link.next = NULL;
-               object[i].piece_link.prev = NULL;
-               object[i].ship = NULL;
-               object[i].cargo = NULL;
-       }
-       for (i = 0; i < NUM_OBJECTS; i++) {
-               comp_obj[i] = NULL;
-               user_obj[i] = NULL;
-       }
-       /* put cities on map */
-       for (i = 0; i < NUM_CITY; i++)
-               map[city[i].loc].cityp = &(city[i]);
+    free_list = NULL; /* zero all ptrs */
+    for (i = 0; i < MAP_SIZE; i++) {
+       map[i].cityp = NULL;
+       map[i].objp = NULL;
+    }
+    for (i = 0; i < LIST_SIZE; i++) {
+       object[i].loc_link.next = NULL;
+       object[i].loc_link.prev = NULL;
+       object[i].cargo_link.next = NULL;
+       object[i].cargo_link.prev = NULL;
+       object[i].piece_link.next = NULL;
+       object[i].piece_link.prev = NULL;
+       object[i].ship = NULL;
+       object[i].cargo = NULL;
+    }
+    for (i = 0; i < NUM_OBJECTS; i++) {
+       comp_obj[i] = NULL;
+       user_obj[i] = NULL;
+    }
+    /* put cities on map */
+    for (i = 0; i < NUM_CITY; i++)
+       map[city[i].loc].cityp = &(city[i]);
        
-       /* put pieces in free list or on map and in object lists */
-       for (i = 0; i < LIST_SIZE; i++) {
-               obj = &(object[i]);
-               if (object[i].owner == UNOWNED || object[i].hits == 0) {
-                       LINK (free_list, obj, piece_link);
-               }
-               else {
-                       list = LIST (object[i].owner);
-                       LINK (list[object[i].type], obj, piece_link);
-                       LINK (map[object[i].loc].objp, obj, loc_link);
-               }
+    /* put pieces in free list or on map and in object lists */
+    for (i = 0; i < LIST_SIZE; i++) {
+       obj = &(object[i]);
+       if (object[i].owner == UNOWNED || object[i].hits == 0) {
+           LINK (free_list, obj, piece_link);
+       }
+       else {
+           list = LIST (object[i].owner);
+           LINK (list[object[i].type], obj, piece_link);
+           LINK (map[object[i].loc].objp, obj, loc_link);
        }
+    }
        
-       /* Embark armies and fighters. */
-       read_embark (user_obj[TRANSPORT], ARMY);
-       read_embark (user_obj[CARRIER], FIGHTER);
-       read_embark (comp_obj[TRANSPORT], ARMY);
-       read_embark (comp_obj[CARRIER], FIGHTER);
+    /* Embark armies and fighters. */
+    read_embark (user_obj[TRANSPORT], ARMY);
+    read_embark (user_obj[CARRIER], FIGHTER);
+    read_embark (comp_obj[TRANSPORT], ARMY);
+    read_embark (comp_obj[CARRIER], FIGHTER);
        
-       (void) fclose (f);
-       kill_display (); /* what we had is no longer good */
-       topmsg (3, "Game restored from save file.");
-       return (true);
+    (void) fclose (f);
+    kill_display (); /* what we had is no longer good */
+    topmsg (3, "Game restored from save file.");
+    return (true);
 }
        
 /*
@@ -622,30 +632,31 @@ the ship has the same amount of cargo it previously had.
 
 void read_embark(piece_info_t *list, int piece_type)
 {
-       void inconsistent(void);
-
-       piece_info_t *ship;
-       piece_info_t *obj;
-       int count;
-
-       for (ship = list; ship != NULL; ship = ship->piece_link.next) {
-               count = ship->count; /* get # of pieces we need */
-               if (count < 0) inconsistent ();
-               ship->count = 0; /* nothing on board yet */
-               for (obj = map[ship->loc].objp; obj && count;
-                   obj = obj->loc_link.next) {
-                       if (obj->ship == NULL && obj->type == piece_type) {
-                               embark (ship, obj);
-                               count -= 1;
-                       }
-               }
-               if (count) inconsistent ();
+    void inconsistent(void);
+
+    piece_info_t *ship;
+    piece_info_t *obj;
+    int count;
+
+    for (ship = list; ship != NULL; ship = ship->piece_link.next) {
+       count = ship->count; /* get # of pieces we need */
+       if (count < 0) inconsistent ();
+       ship->count = 0; /* nothing on board yet */
+       for (obj = map[ship->loc].objp; obj && count;
+            obj = obj->loc_link.next) {
+           if (obj->ship == NULL && obj->type == piece_type) {
+               embark (ship, obj);
+               count -= 1;
+           }
        }
+       if (count) inconsistent ();
+    }
 }
 
-void inconsistent(void) {
-       (void) printf ("saved game is inconsistent.  Please remove it.\n");
-       exit (1);
+void inconsistent(void)
+{
+    (void) printf ("saved game is inconsistent.  Please remove it.\n");
+    exit (1);
 }
 
 /*
@@ -655,18 +666,18 @@ Also, tell the user why the write did not work if it didn't.
 
 bool xwrite(FILE *f, char *buf, int size)
 {
-       int bytes;
+    int bytes;
  
-       bytes = fwrite (buf, 1, size, f);
-       if (bytes == -1) {
-               perror ("Write to save file failed");
-               return (false);
-       }
-       if (bytes != size) {
-               perror ("Cannot complete write to save file.\n");
-               return (false);
-       }
-       return (true);
+    bytes = fwrite (buf, 1, size, f);
+    if (bytes == -1) {
+       perror ("Write to save file failed");
+       return (false);
+    }
+    if (bytes != size) {
+       perror ("Cannot complete write to save file.\n");
+       return (false);
+    }
+    return (true);
 }
 
 /*
@@ -676,18 +687,18 @@ and return false.
 
 bool xread(FILE *f, char *buf, int size)
 {
-       int bytes;
-
-       bytes = fread (buf, 1, size, f);
-       if (bytes == -1) {
-               perror ("Read from save file failed");
-               return (false);
-       }
-       if (bytes != size) {
-               perror ("Saved file is too short.\n");
-               return (false);
-       }
-       return (true);
+    int bytes;
+
+    bytes = fread (buf, 1, size, f);
+    if (bytes == -1) {
+       perror ("Read from save file failed");
+       return (false);
+    }
+    if (bytes != size) {
+       perror ("Saved file is too short.\n");
+       return (false);
+    }
+    return (true);
 }
 
 /*
@@ -702,29 +713,29 @@ static char mapbuf[MAP_SIZE];
 void
 save_movie_screen(void)
 {
-       FILE *f; /* file to save game in */
-       count_t i;
-       piece_info_t *p;
-
-       f = fopen ("empmovie.dat", "a"); /* open for append */
-       if (f == NULL) {
-               perror ("Cannot open empmovie.dat");
-               return;
-       }
-
-       for (i = 0; i < MAP_SIZE; i++) {
-               if (map[i].cityp) mapbuf[i] = city_char[map[i].cityp->owner];
-               else {
-                       p = find_obj_at_loc (i);
+    FILE *f; /* file to save game in */
+    count_t i;
+    piece_info_t *p;
+
+    f = fopen ("empmovie.dat", "a"); /* open for append */
+    if (f == NULL) {
+       perror ("Cannot open empmovie.dat");
+       return;
+    }
+
+    for (i = 0; i < MAP_SIZE; i++) {
+       if (map[i].cityp) mapbuf[i] = city_char[map[i].cityp->owner];
+       else {
+           p = find_obj_at_loc (i);
                        
-                       if (!p) mapbuf[i] = map[i].contents;
-                       else if (p->owner == USER)
-                               mapbuf[i] = piece_attr[p->type].sname;
-                       else mapbuf[i] = tolower (piece_attr[p->type].sname);
-               }
+           if (!p) mapbuf[i] = map[i].contents;
+           else if (p->owner == USER)
+               mapbuf[i] = piece_attr[p->type].sname;
+           else mapbuf[i] = tolower (piece_attr[p->type].sname);
        }
-       wbuf (mapbuf);
-       (void) fclose (f);
+    }
+    wbuf (mapbuf);
+    (void) fclose (f);
 }
 
 /*
@@ -735,38 +746,39 @@ print it using a zoomed display.
 void
 replay_movie(void)
 {
-       void print_movie_cell();
+    void print_movie_cell();
 
-       FILE *f; /* file to save game in */
-       int row_inc, col_inc;
-       int r, c;
-       int round;
+    FILE *f; /* file to save game in */
+    int row_inc, col_inc;
+    int r, c;
+    int round;
 
        
-       f = fopen ("empmovie.dat", "r"); /* open for input */
-       if (f == NULL) {
-               perror ("Cannot open empmovie.dat");
-               return;
-       }
-       round = 0;
-       clear_screen ();
-       for (;;) {
-               if (fread ((char *)mapbuf, 1, sizeof (mapbuf), f) != sizeof (mapbuf)) break;
-               round += 1;
+    f = fopen ("empmovie.dat", "r"); /* open for input */
+    if (f == NULL) {
+       perror ("Cannot open empmovie.dat");
+       return;
+    }
+    round = 0;
+    clear_screen ();
+    for (;;) {
+       if (fread ((char *)mapbuf, 1, sizeof (mapbuf), f) != sizeof (mapbuf))
+           break;
+       round += 1;
                
-               stat_display (mapbuf, round);
+       stat_display (mapbuf, round);
                
-               row_inc = (MAP_HEIGHT + lines - NUMTOPS - 1) / (lines - NUMTOPS);
-               col_inc = (MAP_WIDTH + cols - 1) / (cols - 1);
+       row_inc = (MAP_HEIGHT + lines - NUMTOPS - 1) / (lines - NUMTOPS);
+       col_inc = (MAP_WIDTH + cols - 1) / (cols - 1);
        
-               for (r = 0; r < MAP_HEIGHT; r += row_inc)
-               for (c = 0; c < MAP_WIDTH; c += col_inc)
+       for (r = 0; r < MAP_HEIGHT; r += row_inc)
+           for (c = 0; c < MAP_WIDTH; c += col_inc)
                print_movie_cell (mapbuf, r, c, row_inc, col_inc);
                
-               (void) redisplay ();
-               delay ();
-       }
-       (void) fclose (f);
+       (void) redisplay ();
+       delay ();
+    }
+    (void) fclose (f);
 }
 
 /*
@@ -785,32 +797,33 @@ static char *pieces = "OAFPDSTCBZXafpdstcbz";
 
 void stat_display(char *mbuf, int round)
 {
-       count_t i;
-       int counts[2*NUM_OBJECTS+2];
-       int user_cost, comp_cost;
-       char *p;
+    count_t i;
+    int counts[2*NUM_OBJECTS+2];
+    int user_cost, comp_cost;
+    char *p;
        
-       (void) bzero ((char *)counts, sizeof (counts));
+    (void) bzero ((char *)counts, sizeof (counts));
        
-       for (i = 0; i < MAP_SIZE; i++) {
-               p = strchr (pieces, mbuf[i]);
-               if (p) counts[p-pieces] += 1;
-       }
-       user_cost = 0;
-       for (i = 1; i <= NUM_OBJECTS; i++)
-               user_cost += counts[i] * piece_attr[i-1].build_time;
+    for (i = 0; i < MAP_SIZE; i++) {
+       p = strchr (pieces, mbuf[i]);
+       if (p) counts[p-pieces] += 1;
+    }
+    user_cost = 0;
+    for (i = 1; i <= NUM_OBJECTS; i++)
+       user_cost += counts[i] * piece_attr[i-1].build_time;
                
-       comp_cost = 0;
-       for (i = NUM_OBJECTS+2; i <= 2*NUM_OBJECTS+1; i++)
-               comp_cost += counts[i] * piece_attr[i-NUM_OBJECTS-2].build_time;
+    comp_cost = 0;
+    for (i = NUM_OBJECTS+2; i <= 2*NUM_OBJECTS+1; i++)
+       comp_cost += counts[i] * piece_attr[i-NUM_OBJECTS-2].build_time;
                
-       for (i = 0; i < NUM_OBJECTS+1; i++) {
-               pos_str (1, (int) i * 6, "%2d %c  ", counts[i], pieces[i]);
-               pos_str (2,(int) i * 6, "%2d %c  ", counts[i+NUM_OBJECTS+1], pieces[i+NUM_OBJECTS+1]);
-       }
-
-       pos_str (1, (int) i * 6, "%5d", user_cost);
-       pos_str (2, (int) i * 6, "%5d", comp_cost);
-       pos_str (0, 0, "Round %3d", (round + 1) / 2);
+    for (i = 0; i < NUM_OBJECTS+1; i++) {
+       pos_str (1, (int) i * 6, "%2d %c  ", counts[i], pieces[i]);
+       pos_str (2,(int) i * 6, "%2d %c  ", counts[i+NUM_OBJECTS+1], pieces[i+NUM_OBJECTS+1]);
+    }
+
+    pos_str (1, (int) i * 6, "%5d", user_cost);
+    pos_str (2, (int) i * 6, "%5d", comp_cost);
+    pos_str (0, 0, "Round %3d", (round + 1) / 2);
 }
 
+/* end */
diff --git a/main.c b/main.c
index 5d5df20..a66f858 100644 (file)
--- a/main.c
+++ b/main.c
@@ -35,75 +35,75 @@ int main(argc, argv)
 int argc;
 char *argv[];
 {
-       int c;
-       extern char *optarg;
-       extern int optind;
-       extern int opterr;      /* set to 1 to suppress error msg */
-       int errflg = 0;
-       int wflg, sflg, dflg, Sflg;
-       int land;
+    int c;
+    extern char *optarg;
+    extern int optind;
+    extern int opterr;      /* set to 1 to suppress error msg */
+    int errflg = 0;
+    int wflg, sflg, dflg, Sflg;
+    int land;
        
-       wflg = 70; /* set defaults */
-       sflg = 5;
-       dflg = 2000;
-       Sflg = 10;
-       savefile = "empsave.dat";
+    wflg = 70; /* set defaults */
+    sflg = 5;
+    dflg = 2000;
+    Sflg = 10;
+    savefile = "empsave.dat";
 
-       /*
-        * extract command line options
-        */
+    /*
+     * extract command line options
+     */
 
-       while ((c = getopt (argc, argv, OPTFLAGS)) != EOF) {
-               switch (c) {
-               case 'w':
-                       wflg = atoi (optarg);
-                       break;
-               case 's':
-                       sflg = atoi (optarg);
-                       break;
-               case 'd':
-                       dflg = atoi (optarg);
-                       break;
-               case 'S':
-                       Sflg = atoi (optarg);
-                       break;
-               case 'f':
-                       savefile = optarg;
-                       break;
-               case '?': /* illegal option? */
-                       errflg++;
-                       break;
-               }
-       }
-       if (errflg || (argc-optind) != 0) {
-               (void) printf ("empire: usage: empire [-w water] [-s smooth] [-d delay]\n");
-               exit (1);
+    while ((c = getopt (argc, argv, OPTFLAGS)) != EOF) {
+       switch (c) {
+       case 'w':
+           wflg = atoi (optarg);
+           break;
+       case 's':
+           sflg = atoi (optarg);
+           break;
+       case 'd':
+           dflg = atoi (optarg);
+           break;
+       case 'S':
+           Sflg = atoi (optarg);
+           break;
+       case 'f':
+           savefile = optarg;
+           break;
+       case '?': /* illegal option? */
+           errflg++;
+           break;
        }
+    }
+    if (errflg || (argc-optind) != 0) {
+       (void) printf ("empire: usage: empire [-w water] [-s smooth] [-d delay]\n");
+       exit (1);
+    }
 
-       if (wflg < 10 || wflg > 90) {
-               (void) printf ("empire: -w argument must be in the range 0..90.\n");
-               exit (1);
-       }
-       if (sflg < 0) {
-               (void) printf ("empire: -s argument must be greater or equal to zero.\n");
-               exit (1);
-       }
+    if (wflg < 10 || wflg > 90) {
+       (void) printf ("empire: -w argument must be in the range 0..90.\n");
+       exit (1);
+    }
+    if (sflg < 0) {
+       (void) printf ("empire: -s argument must be greater or equal to zero.\n");
+       exit (1);
+    }
        
-       if (dflg < 0 || dflg > 30000) {
-               (void) printf ("empire: -d argument must be in the range 0..30000.\n");
-               exit (1);
-       }
+    if (dflg < 0 || dflg > 30000) {
+       (void) printf ("empire: -d argument must be in the range 0..30000.\n");
+       exit (1);
+    }
 
-       SMOOTH = sflg;
-       WATER_RATIO = wflg;
-       delay_time = dflg;
-       save_interval = Sflg;
+    SMOOTH = sflg;
+    WATER_RATIO = wflg;
+    delay_time = dflg;
+    save_interval = Sflg;
 
-       /* compute min distance between cities */
-       land = MAP_SIZE * (100 - WATER_RATIO) / 100; /* available land */
-       land /= NUM_CITY; /* land per city */
-       MIN_CITY_DIST = isqrt (land); /* distance between cities */
+    /* compute min distance between cities */
+    land = MAP_SIZE * (100 - WATER_RATIO) / 100; /* available land */
+    land /= NUM_CITY; /* land per city */
+    MIN_CITY_DIST = isqrt (land); /* distance between cities */
 
-       empire (); /* call main routine */
-       return (0);
+    empire (); /* call main routine */
+    return (0);
 }
diff --git a/map.c b/map.c
index e675737..43fdb99 100644 (file)
--- a/map.c
+++ b/map.c
@@ -68,41 +68,41 @@ known to be either on the continent or adjacent to the continent.
 void
 vmap_mark_up_cont(int *cont_map, view_map_t *vmap, loc_t loc, char bad_terrain)
 {
-       int i, j;
-       loc_t new_loc;
-       char this_terrain;
-       perimeter_t *from, *to;
+    int i, j;
+    loc_t new_loc;
+    char this_terrain;
+    perimeter_t *from, *to;
 
-       from = &p1;
-       to = &p2;
+    from = &p1;
+    to = &p2;
        
-       from->len = 1; /* init perimeter */
-       from->list[0] = loc;
-       cont_map[loc] = 1; /* loc is on continent */
+    from->len = 1; /* init perimeter */
+    from->list[0] = loc;
+    cont_map[loc] = 1; /* loc is on continent */
        
-       while (from->len) {
-               to->len = 0; /* nothing in new perimeter yet */
+    while (from->len) {
+       to->len = 0; /* nothing in new perimeter yet */
                
-               for (i = 0; i < from->len; i++) /* expand perimeter */
-               FOR_ADJ_ON(from->list[i], new_loc, j)
+       for (i = 0; i < from->len; i++) /* expand perimeter */
+           FOR_ADJ_ON(from->list[i], new_loc, j)
                if (!cont_map[new_loc]) {
-                       /* mark, but don't expand, unexplored territory */
-                       if (vmap[new_loc].contents == ' ')
-                               cont_map[new_loc] = 1;
-                       else {
-                               if (vmap[new_loc].contents == '+') this_terrain = '+';
-                               else if (vmap[new_loc].contents == '.') this_terrain = '.';
-                               else this_terrain = map[new_loc].contents;
+                   /* mark, but don't expand, unexplored territory */
+                   if (vmap[new_loc].contents == ' ')
+                       cont_map[new_loc] = 1;
+                   else {
+                       if (vmap[new_loc].contents == '+') this_terrain = '+';
+                       else if (vmap[new_loc].contents == '.') this_terrain = '.';
+                       else this_terrain = map[new_loc].contents;
                                
-                               if (this_terrain != bad_terrain) { /* on continent? */
-                                       cont_map[new_loc] = 1;
-                                       to->list[to->len] = new_loc;
-                                       to->len += 1;
-                               }
+                       if (this_terrain != bad_terrain) { /* on continent? */
+                           cont_map[new_loc] = 1;
+                           to->list[to->len] = new_loc;
+                           to->len += 1;
                        }
+                   }
                }
-               SWAP (from, to);
-       }
+       SWAP (from, to);
+    }
 }
 
 /*
@@ -118,8 +118,8 @@ static void rmap_mark_up_cont(int *cont_map, loc_t loc, char bad_terrain);
 void
 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);
+    (void) bzero ((char *)cont_map, MAP_SIZE * sizeof (int));
+    rmap_mark_up_cont (cont_map, loc, bad_terrain);
 }
 
 /*
@@ -133,17 +133,17 @@ Someday this should be tweaked to use perimeter lists.
 static void
 rmap_mark_up_cont(int *cont_map, loc_t loc, char bad_terrain)
 {
-       int i;
-       loc_t new_loc;
+    int i;
+    loc_t new_loc;
        
-       if (!map[loc].on_board) return; /* off board */
-       if (cont_map[loc]) return; /* already marked */
-       if (map[loc].contents == bad_terrain) return; /* off continent */
+    if (!map[loc].on_board) return; /* off board */
+    if (cont_map[loc]) return; /* already marked */
+    if (map[loc].contents == bad_terrain) return; /* off continent */
        
-       cont_map[loc] = 1; /* on continent */
+    cont_map[loc] = 1; /* on continent */
 
-       FOR_ADJ (loc, new_loc, i)
-               rmap_mark_up_cont (cont_map, new_loc, bad_terrain);
+    FOR_ADJ (loc, new_loc, i)
+       rmap_mark_up_cont (cont_map, new_loc, bad_terrain);
 }
 
 /*
@@ -157,50 +157,50 @@ This could be done as we mark up the continent.
 scan_counts_t
 vmap_cont_scan(int *cont_map, view_map_t *vmap)
 {
-       scan_counts_t counts;
-       count_t i;
+    scan_counts_t counts;
+    count_t i;
 
-       (void) bzero ((char *)&counts, sizeof (scan_counts_t));
+    (void) bzero ((char *)&counts, sizeof (scan_counts_t));
        
-       for (i = 0; i < MAP_SIZE; i++) {
-               if (cont_map[i]) { /* cell on continent? */
-                       counts.size += 1;
+    for (i = 0; i < MAP_SIZE; i++) {
+       if (cont_map[i]) { /* cell on continent? */
+           counts.size += 1;
                        
-                       switch (vmap[i].contents) {
-                       COUNT (' ', counts.unexplored);
-                       COUNT ('O', counts.user_cities);
-                       COUNT ('A', counts.user_objects[ARMY]);
-                       COUNT ('F', counts.user_objects[FIGHTER]);
-                       COUNT ('P', counts.user_objects[PATROL]);
-                       COUNT ('D', counts.user_objects[DESTROYER]);
-                       COUNT ('S', counts.user_objects[SUBMARINE]);
-                       COUNT ('T', counts.user_objects[TRANSPORT]);
-                       COUNT ('C', counts.user_objects[CARRIER]);
-                       COUNT ('B', counts.user_objects[BATTLESHIP]);
-                       COUNT ('X', counts.comp_cities);
-                       COUNT ('a', counts.comp_objects[ARMY]);
-                       COUNT ('f', counts.comp_objects[FIGHTER]);
-                       COUNT ('p', counts.comp_objects[PATROL]);
-                       COUNT ('d', counts.comp_objects[DESTROYER]);
-                       COUNT ('s', counts.comp_objects[SUBMARINE]);
-                       COUNT ('t', counts.comp_objects[TRANSPORT]);
-                       COUNT ('c', counts.comp_objects[CARRIER]);
-                       COUNT ('b', counts.comp_objects[BATTLESHIP]);
-                       COUNT ('*', counts.unowned_cities);
-                       case '+': break;
-                       case '.': break;
-                       default: /* check for city underneath */
-                               if (map[i].contents == '*') {
-                                       switch (map[i].cityp->owner) {
-                                       COUNT (USER, counts.user_cities);
-                                       COUNT (COMP, counts.comp_cities);
-                                       COUNT (UNOWNED, counts.unowned_cities);
-                                       }
-                               }
-                       }
+           switch (vmap[i].contents) {
+               COUNT (' ', counts.unexplored);
+               COUNT ('O', counts.user_cities);
+               COUNT ('A', counts.user_objects[ARMY]);
+               COUNT ('F', counts.user_objects[FIGHTER]);
+               COUNT ('P', counts.user_objects[PATROL]);
+               COUNT ('D', counts.user_objects[DESTROYER]);
+               COUNT ('S', counts.user_objects[SUBMARINE]);
+               COUNT ('T', counts.user_objects[TRANSPORT]);
+               COUNT ('C', counts.user_objects[CARRIER]);
+               COUNT ('B', counts.user_objects[BATTLESHIP]);
+               COUNT ('X', counts.comp_cities);
+               COUNT ('a', counts.comp_objects[ARMY]);
+               COUNT ('f', counts.comp_objects[FIGHTER]);
+               COUNT ('p', counts.comp_objects[PATROL]);
+               COUNT ('d', counts.comp_objects[DESTROYER]);
+               COUNT ('s', counts.comp_objects[SUBMARINE]);
+               COUNT ('t', counts.comp_objects[TRANSPORT]);
+               COUNT ('c', counts.comp_objects[CARRIER]);
+               COUNT ('b', counts.comp_objects[BATTLESHIP]);
+               COUNT ('*', counts.unowned_cities);
+           case '+': break;
+           case '.': break;
+           default: /* check for city underneath */
+               if (map[i].contents == '*') {
+                   switch (map[i].cityp->owner) {
+                       COUNT (USER, counts.user_cities);
+                       COUNT (COMP, counts.comp_cities);
+                       COUNT (UNOWNED, counts.unowned_cities);
+                   }
                }
+           }
        }
-       return counts;
+    }
+    return counts;
 }
 
 /*
@@ -211,19 +211,19 @@ fields are valid.
 scan_counts_t
 rmap_cont_scan(int *cont_map)
 {
-       scan_counts_t counts;
-       count_t i;
+    scan_counts_t counts;
+    count_t i;
 
-       (void) bzero ((char *)&counts, sizeof (scan_counts_t));
+    (void) bzero ((char *)&counts, sizeof (scan_counts_t));
        
-       for (i = 0; i < MAP_SIZE; i++) {
-               if (cont_map[i]) { /* cell on continent? */
-                       counts.size += 1;
-                       if (map[i].contents == '*')
-                               counts.unowned_cities += 1;
-               }
+    for (i = 0; i < MAP_SIZE; i++) {
+       if (cont_map[i]) { /* cell on continent? */
+           counts.size += 1;
+           if (map[i].contents == '*')
+               counts.unowned_cities += 1;
        }
-       return counts;
+    }
+    return counts;
 }
 
 /*
@@ -233,14 +233,14 @@ Return true if a location is on the edge of a continent.
 bool
 map_cont_edge(int *cont_map, loc_t loc)
 {
-       loc_t i, j;
+    loc_t i, j;
 
-       if (!cont_map[loc]) return false; /* not on continent */
+    if (!cont_map[loc]) return false; /* not on continent */
  
-       FOR_ADJ (loc, j, i)
-               if (!cont_map[j]) return true; /* edge of continent */
+    FOR_ADJ (loc, j, i)
+       if (!cont_map[j]) return true; /* edge of continent */
 
-       return false;
+    return false;
 }
 
 /*
@@ -279,30 +279,30 @@ loc_t
 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;
-       int cur_cost;
+    perimeter_t *from;
+    perimeter_t *to;
+    int cur_cost;
 
-       from = &p1;
-       to = &p2;
+    from = &p1;
+    to = &p2;
        
-       start_perimeter (path_map, from, loc, start);
-       cur_cost = 0; /* cost to reach current perimeter */
+    start_perimeter (path_map, from, loc, start);
+    cur_cost = 0; /* cost to reach current perimeter */
 
-       for (;;) {
-               to->len = 0; /* nothing in perim yet */
-               expand_perimeter (path_map, vmap, move_info, from, expand,
-                                 cur_cost, 1, 1, to, to);
+    for (;;) {
+       to->len = 0; /* nothing in perim yet */
+       expand_perimeter (path_map, vmap, move_info, from, expand,
+                         cur_cost, 1, 1, to, to);
                
-               if (trace_pmap)
-                       print_pzoom ("After xobj loop:", path_map, vmap);
+       if (trace_pmap)
+           print_pzoom ("After xobj loop:", path_map, vmap);
 
-               cur_cost += 1;
-               if (to->len == 0 || best_cost <= cur_cost)
-                       return best_loc;
+       cur_cost += 1;
+       if (to->len == 0 || best_cost <= cur_cost)
+           return best_loc;
 
-               SWAP (from, to);
-       }
+       SWAP (from, to);
+    }
 }
        
 /* Find an objective for a piece that crosses land and water. */
@@ -311,7 +311,7 @@ loc_t
 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);
+    return vmap_find_xobj (path_map, vmap, loc, move_info, T_LAND, T_AIR);
 }
 
 /* Find an objective for a piece that crosses only water. */
@@ -320,7 +320,7 @@ loc_t
 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);
+    return vmap_find_xobj (path_map, vmap, loc, move_info, T_WATER, T_WATER);
 }
 
 /* Find an objective for a piece that crosses only land. */
@@ -329,7 +329,7 @@ loc_t
 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);
+    return vmap_find_xobj (path_map, vmap, loc, move_info, T_LAND, T_LAND);
 }
 
 /*
@@ -348,48 +348,48 @@ loc_t
 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;
-       perimeter_t *new_land;
-       perimeter_t *new_water;
-       int cur_cost;
-
-       cur_land = &p1;
-       cur_water = &p2;
-       new_water = &p3;
-       new_land = &p4;
+    perimeter_t *cur_land;
+    perimeter_t *cur_water;
+    perimeter_t *new_land;
+    perimeter_t *new_water;
+    int cur_cost;
+
+    cur_land = &p1;
+    cur_water = &p2;
+    new_water = &p3;
+    new_land = &p4;
        
-       start_perimeter (path_map, cur_land, loc, T_LAND);
-       cur_water->len = 0;
-       best_cost = beat_cost; /* we can do this well */
-       cur_cost = 0; /* cost to reach current perimeter */
-
-       for (;;) {
-               /* expand current perimeter one cell */
-               new_water->len = 0;
-               new_land->len = 0;
-               expand_perimeter (path_map, vmap, move_info, cur_water,
-                                 T_WATER, cur_cost, 1, 1, new_water, NULL);
-
-               expand_perimeter (path_map, vmap, move_info, cur_land,
-                                 T_AIR, cur_cost, 1, 2, new_water, new_land);
+    start_perimeter (path_map, cur_land, loc, T_LAND);
+    cur_water->len = 0;
+    best_cost = beat_cost; /* we can do this well */
+    cur_cost = 0; /* cost to reach current perimeter */
+
+    for (;;) {
+       /* expand current perimeter one cell */
+       new_water->len = 0;
+       new_land->len = 0;
+       expand_perimeter (path_map, vmap, move_info, cur_water,
+                         T_WATER, cur_cost, 1, 1, new_water, NULL);
+
+       expand_perimeter (path_map, vmap, move_info, cur_land,
+                         T_AIR, cur_cost, 1, 2, new_water, new_land);
                                  
-               /* expand new water one cell */
-               cur_water->len = 0;
-               expand_perimeter (path_map, vmap, move_info, new_water,
-                                 T_WATER, cur_cost+1, 1, 1, cur_water, NULL);
+       /* expand new water one cell */
+       cur_water->len = 0;
+       expand_perimeter (path_map, vmap, move_info, new_water,
+                         T_WATER, cur_cost+1, 1, 1, cur_water, NULL);
                                  
-               if (trace_pmap)
-                       print_pzoom ("After lwobj loop:", path_map, vmap);
+       if (trace_pmap)
+           print_pzoom ("After lwobj loop:", path_map, vmap);
                
-               cur_cost += 2;
-               if ( (cur_water->len == 0 && new_land->len == 0) || 
-                     (best_cost <= cur_cost) ) {
-                       return best_loc;
-               }
-
-               SWAP (cur_land, new_land);
+       cur_cost += 2;
+       if ( (cur_water->len == 0 && new_land->len == 0) || 
+            (best_cost <= cur_cost) ) {
+           return best_loc;
        }
+
+       SWAP (cur_land, new_land);
+    }
 }
 
 #ifdef FUNCTION_WAS_NEVER_CALLED
@@ -401,17 +401,17 @@ with the lowest cost.
 STATIC int
 best_adj(path_map_t *pmap, loc_t loc, int type)
 {
-       int i;
-       loc_t new_loc;
-       int best;
+    int i;
+    loc_t new_loc;
+    int best;
 
-       best = INFINITY;
+    best = INFINITY;
        
-       FOR_ADJ (loc, new_loc, i)
+    FOR_ADJ (loc, new_loc, i)
        if (pmap[new_loc].terrain == type && pmap[new_loc].cost < best)
-                       best = pmap[new_loc].cost;
+           best = pmap[new_loc].cost;
 
-       return best;
+    return best;
 }
 #endif
 
@@ -430,46 +430,46 @@ loc_t
 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;
-       perimeter_t *new_land;
-       perimeter_t *new_water;
-       int cur_cost;
-
-       cur_land = &p1;
-       cur_water = &p2;
-       new_water = &p3;
-       new_land = &p4;
+    perimeter_t *cur_land;
+    perimeter_t *cur_water;
+    perimeter_t *new_land;
+    perimeter_t *new_water;
+    int cur_cost;
+
+    cur_land = &p1;
+    cur_water = &p2;
+    new_water = &p3;
+    new_land = &p4;
        
-       start_perimeter (path_map, cur_water, loc, T_WATER);
-       cur_land->len = 0;
-       cur_cost = 0; /* cost to reach current perimeter */
-
-       for (;;) {
-               /* expand current perimeter one cell */
-               new_water->len = 0;
-               new_land->len = 0;
-               expand_perimeter (path_map, vmap, move_info, cur_water,
-                                 T_AIR, cur_cost, 1, 2, new_water, new_land);
-
-               expand_perimeter (path_map, vmap, move_info, cur_land,
-                                 T_LAND, cur_cost, 1, 2, NULL, new_land);
+    start_perimeter (path_map, cur_water, loc, T_WATER);
+    cur_land->len = 0;
+    cur_cost = 0; /* cost to reach current perimeter */
+
+    for (;;) {
+       /* expand current perimeter one cell */
+       new_water->len = 0;
+       new_land->len = 0;
+       expand_perimeter (path_map, vmap, move_info, cur_water,
+                         T_AIR, cur_cost, 1, 2, new_water, new_land);
+
+       expand_perimeter (path_map, vmap, move_info, cur_land,
+                         T_LAND, cur_cost, 1, 2, NULL, new_land);
                                  
-               /* expand new water one cell to water */
-               cur_water->len = 0;
-               expand_perimeter (path_map, vmap, move_info, new_water,
-                                 T_WATER, cur_cost+1, 1, 1, cur_water, NULL);
+       /* expand new water one cell to water */
+       cur_water->len = 0;
+       expand_perimeter (path_map, vmap, move_info, new_water,
+                         T_WATER, cur_cost+1, 1, 1, cur_water, NULL);
                                  
-               if (trace_pmap)
-                       print_pzoom ("After wlobj loop:", path_map, vmap);
+       if (trace_pmap)
+           print_pzoom ("After wlobj loop:", path_map, vmap);
                
-               cur_cost += 2;
-               if ( (cur_water->len == 0 && new_land->len == 0) || 
-                     (best_cost <= cur_cost) ) {
-                       return best_loc;
-               }
-               SWAP (cur_land, new_land);
+       cur_cost += 2;
+       if ( (cur_water->len == 0 && new_land->len == 0) || 
+            (best_cost <= cur_cost) ) {
+           return best_loc;
        }
+       SWAP (cur_land, new_land);
+    }
 }
 
 /*
@@ -486,28 +486,28 @@ static int init_done = 0;
 STATIC void
 start_perimeter(path_map_t *pmap, perimeter_t *perim, loc_t loc, int terrain)
 {
+    /* zap the path map */
+    if (!init_done) {
        int i;
        
-       /* zap the path map */
-       if (!init_done) {
-               init_done = 1;
-               for (i = 0; i < MAP_SIZE; i++) {
-                       pmap_init[i].cost = INFINITY; /* everything lies outside perim */
-                       pmap_init[i].terrain = T_UNKNOWN;
-               }
+       init_done = 1;
+       for (i = 0; i < MAP_SIZE; i++) {
+           pmap_init[i].cost = INFINITY; /* everything lies outside perim */
+           pmap_init[i].terrain = T_UNKNOWN;
        }
-       (void) memcpy ((char *)pmap, (char *)pmap_init, sizeof (pmap_init));
+    }
+    (void) memcpy ((char *)pmap, (char *)pmap_init, sizeof (pmap_init));
        
-       /* put first location in perimeter */
-       pmap[loc].cost = 0;
-       pmap[loc].inc_cost = 0;
-       pmap[loc].terrain = terrain;
+    /* put first location in perimeter */
+    pmap[loc].cost = 0;
+    pmap[loc].inc_cost = 0;
+    pmap[loc].terrain = terrain;
 
-       perim->len = 1;
-       perim->list[0] = loc;
+    perim->len = 1;
+    perim->list[0] = loc;
        
-       best_cost = INFINITY; /* no best yet */
-       best_loc = loc; /* if nothing found, result is current loc */
+    best_cost = INFINITY; /* no best yet */
+    best_loc = loc; /* if nothing found, result is current loc */
 }
 
 /*
@@ -540,41 +540,41 @@ expand_perimeter(path_map_t *pmap, view_map_t *vmap, move_info_t *move_info,
 /* waterp = pointer to new water perimeter */
 /* landp = pointer to new land perimeter */
 {
-       register long i;
-       register int j;
-       loc_t new_loc;
-       int obj_cost;
-       register int new_type;
-
-       for (i = 0; i < curp->len; i++) /* for each perimeter cell... */
-               FOR_ADJ_ON (curp->list[i], new_loc, j) {/* for each adjacent cell... */
-                       register path_map_t *pm = pmap + new_loc;
-
-                       if (pm->cost == INFINITY) {
-                               new_type = terrain_type (pmap, vmap, move_info, curp->list[i], new_loc);
-
-                               if (new_type == T_LAND && (type & T_LAND))
-                                       add_cell (pmap, new_loc, landp, new_type, cur_cost, inc_lcost);
-                               else if (new_type == T_WATER && (type & T_WATER))
-                                       add_cell (pmap, new_loc, waterp, new_type, cur_cost, inc_wcost);
-                               else if (new_type == T_UNKNOWN) { /* unreachable cell? */
-                                       pm->terrain = new_type;
-                                       pm->cost = cur_cost + INFINITY/2;
-                                       pm->inc_cost = INFINITY/2;
-                               }
-                               if (pmap[new_loc].cost != INFINITY) { /* did we expand? */
-                                       obj_cost = objective_cost (vmap, move_info, new_loc, cur_cost);
-                                       if (obj_cost < best_cost) {
-                                               best_cost = obj_cost;
-                                               best_loc = new_loc;
-                                               if (new_type == T_UNKNOWN) {
-                                                       pm->cost=cur_cost+2;
-                                                       pm->inc_cost = 2;
-                                               }
-                                       }
-                               }
+    register long i;
+    register int j;
+    loc_t new_loc;
+    int obj_cost;
+    register int new_type;
+
+    for (i = 0; i < curp->len; i++) /* for each perimeter cell... */
+       FOR_ADJ_ON (curp->list[i], new_loc, j) {/* for each adjacent cell... */
+           register path_map_t *pm = pmap + new_loc;
+
+           if (pm->cost == INFINITY) {
+               new_type = terrain_type (pmap, vmap, move_info, curp->list[i], new_loc);
+
+               if (new_type == T_LAND && (type & T_LAND))
+                   add_cell (pmap, new_loc, landp, new_type, cur_cost, inc_lcost);
+               else if (new_type == T_WATER && (type & T_WATER))
+                   add_cell (pmap, new_loc, waterp, new_type, cur_cost, inc_wcost);
+               else if (new_type == T_UNKNOWN) { /* unreachable cell? */
+                   pm->terrain = new_type;
+                   pm->cost = cur_cost + INFINITY/2;
+                   pm->inc_cost = INFINITY/2;
+               }
+               if (pmap[new_loc].cost != INFINITY) { /* did we expand? */
+                   obj_cost = objective_cost (vmap, move_info, new_loc, cur_cost);
+                   if (obj_cost < best_cost) {
+                       best_cost = obj_cost;
+                       best_loc = new_loc;
+                       if (new_type == T_UNKNOWN) {
+                           pm->cost=cur_cost+2;
+                           pm->inc_cost = 2;
                        }
+                   }
                }
+           }
+       }
 }
                        
 /* Add a cell to a perimeter list. */
@@ -583,14 +583,14 @@ STATIC void
 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];
+    register   path_map_t      *pm = &pmap[new_loc];
 
-       pm->terrain = terrain;
-       pm->inc_cost = inc_cost;
-       pm->cost = cur_cost + inc_cost;
+    pm->terrain = terrain;
+    pm->inc_cost = inc_cost;
+    pm->cost = cur_cost + inc_cost;
 
-       perim->list[perim->len] = new_loc;
-       perim->len += 1;
+    perim->list[perim->len] = new_loc;
+    perim->len += 1;
 }
 
 /* Compute the cost to move to an objective. */
@@ -599,34 +599,34 @@ STATIC int
 objective_cost(view_map_t *vmap, move_info_t *move_info, 
                loc_t loc, int base_cost)
 {
-       char *p;
-       int w;
-       city_info_t *cityp;
-
-       p = strchr (move_info->objectives, vmap[loc].contents);
-       if (!p) return INFINITY;
-
-       w = move_info->weights[p - move_info->objectives];
-       if (w >= 0) return w + base_cost;
-
-       switch (w) {
-       case W_TT_BUILD:
-               /* handle special case of moving to tt building city */
-               cityp = find_city (loc);
-               if (!cityp) return base_cost + 2; /* tt is already here */
-               if (cityp->prod != TRANSPORT) return base_cost + 2; /* just finished a tt */
+    char *p;
+    int w;
+    city_info_t *cityp;
+
+    p = strchr (move_info->objectives, vmap[loc].contents);
+    if (!p) return INFINITY;
+
+    w = move_info->weights[p - move_info->objectives];
+    if (w >= 0) return w + base_cost;
+
+    switch (w) {
+    case W_TT_BUILD:
+       /* handle special case of moving to tt building city */
+       cityp = find_city (loc);
+       if (!cityp) return base_cost + 2; /* tt is already here */
+       if (cityp->prod != TRANSPORT) return base_cost + 2; /* just finished a tt */
        
-               /* compute time to wait for tt to be built */
-               w = piece_attr[TRANSPORT].build_time - cityp->work;
-               w *= 2; /* had to cross land to get here */
-               if (w < base_cost + 2) w = base_cost + 2;
-               return w;
-
-       default:
-               ABORT;
-               /* NOTREACHED */
-                return -1;
-       }
+       /* compute time to wait for tt to be built */
+       w = piece_attr[TRANSPORT].build_time - cityp->work;
+       w *= 2; /* had to cross land to get here */
+       if (w < base_cost + 2) w = base_cost + 2;
+       return w;
+
+    default:
+       ABORT;
+       /* NOTREACHED */
+       return -1;
+    }
 }
 
 /*
@@ -637,22 +637,22 @@ STATIC int
 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;
-       if (vmap[to_loc].contents == '%') return T_UNKNOWN; /* magic objective */
-       if (vmap[to_loc].contents == ' ') return pmap[from_loc].terrain;
+    if (vmap[to_loc].contents == '+') return T_LAND;
+    if (vmap[to_loc].contents == '.') return T_WATER;
+    if (vmap[to_loc].contents == '%') return T_UNKNOWN; /* magic objective */
+    if (vmap[to_loc].contents == ' ') return pmap[from_loc].terrain;
        
-       switch (map[to_loc].contents) {
-       case '.': return T_WATER;
-       case '+': return T_LAND;
-       case '*':
-               if (map[to_loc].cityp->owner == move_info->city_owner)
-                       return T_WATER;
-               else return T_UNKNOWN; /* cannot cross */
-       }
-       ABORT;
-       /*NOTREACHED*/
-        return -1;
+    switch (map[to_loc].contents) {
+    case '.': return T_WATER;
+    case '+': return T_LAND;
+    case '*':
+       if (map[to_loc].cityp->owner == move_info->city_owner)
+           return T_WATER;
+       else return T_UNKNOWN; /* cannot cross */
+    }
+    ABORT;
+    /*NOTREACHED*/
+    return -1;
 }
 
 /*
@@ -688,119 +688,123 @@ So be careful.
 void
 vmap_prune_explore_locs(view_map_t *vmap)
 {
-       path_map_t pmap[MAP_SIZE];
-       perimeter_t *from, *to;
-       int explored;
-       loc_t loc, new_loc;
-       count_t i;
-       long copied;
-
-       (void) bzero (pmap, sizeof (pmap));
-       from = &p1;
-       to = &p2;
-       from->len = 0;
-       explored = 0;
+    path_map_t pmap[MAP_SIZE];
+    perimeter_t *from, *to;
+    int explored;
+    loc_t loc, new_loc;
+    count_t i;
+    long copied;
+
+    (void) bzero (pmap, sizeof (pmap));
+    from = &p1;
+    to = &p2;
+    from->len = 0;
+    explored = 0;
        
-       /* build initial path map and perimeter list */
-       for (loc = 0; loc < MAP_SIZE; loc++) {
-               if (vmap[loc].contents != ' ') explored += 1;
-               else { /* add unexplored cell to perim */
-                       FOR_ADJ (loc, new_loc, i) {
-                               if (new_loc < 0 || new_loc >= MAP_SIZE); /* ignore off map */
-                               else if (vmap[new_loc].contents == ' '); /* ignore adjacent unexplored */
-                               else if (map[new_loc].contents != '.')
-                                       pmap[loc].cost += 1; /* count land */
-                               else pmap[loc].inc_cost += 1; /* count water */
-                       }
-                       if (pmap[loc].cost || pmap[loc].inc_cost) {
-                               from->list[from->len] = loc;
-                               from->len += 1;
-                       }
-               }
+    /* build initial path map and perimeter list */
+    for (loc = 0; loc < MAP_SIZE; loc++) {
+       if (vmap[loc].contents != ' ')
+           explored += 1;
+       else { /* add unexplored cell to perim */
+           FOR_ADJ (loc, new_loc, i) {
+               if (new_loc < 0 || new_loc >= MAP_SIZE); /* ignore off map */
+               else if (vmap[new_loc].contents == ' '); /* ignore adjacent unexplored */
+               else if (map[new_loc].contents != '.')
+                   pmap[loc].cost += 1; /* count land */
+               else pmap[loc].inc_cost += 1; /* count water */
+           }
+           if (pmap[loc].cost || pmap[loc].inc_cost) {
+               from->list[from->len] = loc;
+               from->len += 1;
+           }
        }
+    }
                                
-       if (print_vmap == 'I') print_xzoom (vmap);
+    if (print_vmap == 'I')
+       print_xzoom (vmap);
                
-       for (;;) { /* do high probability predictions */
-               if (from->len + explored == MAP_SIZE) return;
-               to->len = 0;
-               copied = 0;
+    for (;;) { /* do high probability predictions */
+       if (from->len + explored == MAP_SIZE) return;
+       to->len = 0;
+       copied = 0;
                
-               for (i = 0; i < from->len; i++) {
-                       loc = from->list[i];
-                       if (pmap[loc].cost >= 5)
-                               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
-                       else if (pmap[loc].inc_cost >= 5)
-                               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
-                       else if ((loc < MAP_WIDTH || loc >= MAP_SIZE-MAP_WIDTH) && pmap[loc].cost >= 3)
-                               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
-                       else if ((loc < MAP_WIDTH || loc >= MAP_SIZE-MAP_WIDTH) && pmap[loc].inc_cost >= 3)
-                               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
-                       else if ((loc == 0 || loc == MAP_SIZE-1) && pmap[loc].cost >= 2)
-                               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
-                       else if ((loc == 0 || loc == MAP_SIZE-1) && pmap[loc].inc_cost >= 2)
-                               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
-                       else { /* copy perimeter cell */
-                               to->list[to->len] = loc;
-                               to->len += 1;
-                               copied += 1;
-                       }
-               }
-               if (copied == from->len) break; /* nothing expanded */
-               SWAP (from, to);
+       for (i = 0; i < from->len; i++) {
+           loc = from->list[i];
+           if (pmap[loc].cost >= 5)
+               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
+           else if (pmap[loc].inc_cost >= 5)
+               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
+           else if ((loc < MAP_WIDTH || loc >= MAP_SIZE-MAP_WIDTH) && pmap[loc].cost >= 3)
+               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
+           else if ((loc < MAP_WIDTH || loc >= MAP_SIZE-MAP_WIDTH) && pmap[loc].inc_cost >= 3)
+               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
+           else if ((loc == 0 || loc == MAP_SIZE-1) && pmap[loc].cost >= 2)
+               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
+           else if ((loc == 0 || loc == MAP_SIZE-1) && pmap[loc].inc_cost >= 2)
+               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
+           else { /* copy perimeter cell */
+               to->list[to->len] = loc;
+               to->len += 1;
+               copied += 1;
+           }
        }
+       if (copied == from->len) break; /* nothing expanded */
+       SWAP (from, to);
+    }
        
-       if (print_vmap == 'I') print_xzoom (vmap);
+    if (print_vmap == 'I')
+       print_xzoom (vmap);
                
-       /* one pass for medium probability predictions */
-       if (from->len + explored == MAP_SIZE) return;
-       to->len = 0;
+    /* one pass for medium probability predictions */
+    if (from->len + explored == MAP_SIZE)
+       return;
+    to->len = 0;
        
-       for (i = 0; i < from->len; i++) {
-               loc = from->list[i];
-               if (pmap[loc].cost > pmap[loc].inc_cost)
-                       expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
-               else if (pmap[loc].cost < pmap[loc].inc_cost)
-                       expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
-               else { /* copy perimeter cell */
-                       to->list[to->len] = loc;
-                       to->len += 1;
-               }
+    for (i = 0; i < from->len; i++) {
+       loc = from->list[i];
+       if (pmap[loc].cost > pmap[loc].inc_cost)
+           expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
+       else if (pmap[loc].cost < pmap[loc].inc_cost)
+           expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
+       else { /* copy perimeter cell */
+           to->list[to->len] = loc;
+           to->len += 1;
        }
-       SWAP (from, to);
+    }
+    SWAP (from, to);
 
-       if (print_vmap == 'I') print_xzoom (vmap);
+    if (print_vmap == 'I') print_xzoom (vmap);
                
-       /* multiple low probability passes */
-       for (;;) {
-               /* return if very little left to explore */
-               if (from->len + explored >= MAP_SIZE - MAP_HEIGHT) {
-                       if (print_vmap == 'I') print_xzoom (vmap);
-                       return;
-               }
-               to->len = 0;
-               copied = 0;
+    /* multiple low probability passes */
+    for (;;) {
+       /* return if very little left to explore */
+       if (from->len + explored >= MAP_SIZE - MAP_HEIGHT) {
+           if (print_vmap == 'I') print_xzoom (vmap);
+           return;
+       }
+       to->len = 0;
+       copied = 0;
                
-               for (i = 0; i < from->len; i++) {
-                       loc = from->list[i];
-                       if (pmap[loc].cost >= 4 && pmap[loc].inc_cost < 4)
-                               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
-                       else if (pmap[loc].inc_cost >= 4 && pmap[loc].cost < 4)
-                               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
-                       else if ((loc < MAP_WIDTH || loc >= MAP_SIZE-MAP_WIDTH) && pmap[loc].cost > pmap[loc].inc_cost)
-                               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
-                       else if ((loc < MAP_WIDTH || loc >= MAP_SIZE-MAP_WIDTH) && pmap[loc].inc_cost > pmap[loc].cost)
-                               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
-                       else { /* copy perimeter cell */
-                               to->list[to->len] = loc;
-                               to->len += 1;
-                               copied += 1;
-                       }
-               }
-               if (copied == from->len) break; /* nothing expanded */
-               SWAP (from, to);
+       for (i = 0; i < from->len; i++) {
+           loc = from->list[i];
+           if (pmap[loc].cost >= 4 && pmap[loc].inc_cost < 4)
+               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
+           else if (pmap[loc].inc_cost >= 4 && pmap[loc].cost < 4)
+               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
+           else if ((loc < MAP_WIDTH || loc >= MAP_SIZE-MAP_WIDTH) && pmap[loc].cost > pmap[loc].inc_cost)
+               expand_prune (vmap, pmap, loc, T_LAND, to, &explored);
+           else if ((loc < MAP_WIDTH || loc >= MAP_SIZE-MAP_WIDTH) && pmap[loc].inc_cost > pmap[loc].cost)
+               expand_prune (vmap, pmap, loc, T_WATER, to, &explored);
+           else { /* copy perimeter cell */
+               to->list[to->len] = loc;
+               to->len += 1;
+               copied += 1;
+           }
        }
-       if (print_vmap == 'I') print_xzoom (vmap);
+       if (copied == from->len) break; /* nothing expanded */
+       SWAP (from, to);
+    }
+    if (print_vmap == 'I') print_xzoom (vmap);
 }
 
 /*
@@ -816,23 +820,23 @@ STATIC void
 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;
+    int i;
+    loc_t new_loc;
        
-       *explored += 1;
+    *explored += 1;
        
-       if (type == T_LAND) vmap[loc].contents = '+';
-       else vmap[loc].contents = '.';
+    if (type == T_LAND) vmap[loc].contents = '+';
+    else vmap[loc].contents = '.';
        
-       FOR_ADJ (loc, new_loc, i)
+    FOR_ADJ (loc, new_loc, i)
        if (new_loc >= 0 && new_loc < MAP_SIZE && vmap[new_loc].contents == ' ') {
-               if (!pmap[new_loc].cost && !pmap[new_loc].inc_cost) {
-                       to->list[to->len] = new_loc;
-                       to->len += 1;
-               }
-               if (type == T_LAND)
-                       pmap[new_loc].cost += 1;
-               else pmap[new_loc].inc_cost += 1;
+           if (!pmap[new_loc].cost && !pmap[new_loc].inc_cost) {
+               to->list[to->len] = new_loc;
+               to->len += 1;
+           }
+           if (type == T_LAND)
+               pmap[new_loc].cost += 1;
+           else pmap[new_loc].inc_cost += 1;
        }
 }
        
@@ -853,39 +857,39 @@ vmap_find_dest(path_map_t path_map[], view_map_t vmap[],
 /* owner = owner of piece being moved */
 /* terrain = terrain we can cross */
 {
-       perimeter_t *from;
-       perimeter_t *to;
-       int cur_cost;
-       int start_terrain;
-       move_info_t move_info;
-       char old_contents;
-
-       old_contents = vmap[dest_loc].contents;
-       vmap[dest_loc].contents = '%'; /* mark objective */
-       move_info.city_owner = owner;
-       move_info.objectives = "%";
-       move_info.weights[0] = 1;
-
-       from = &p1;
-       to = &p2;
+    perimeter_t *from;
+    perimeter_t *to;
+    int cur_cost;
+    int start_terrain;
+    move_info_t move_info;
+    char old_contents;
+
+    old_contents = vmap[dest_loc].contents;
+    vmap[dest_loc].contents = '%'; /* mark objective */
+    move_info.city_owner = owner;
+    move_info.objectives = "%";
+    move_info.weights[0] = 1;
+
+    from = &p1;
+    to = &p2;
        
-       if (terrain == T_AIR) start_terrain = T_LAND;
-       else start_terrain = terrain;
+    if (terrain == T_AIR) start_terrain = T_LAND;
+    else start_terrain = terrain;
        
-       start_perimeter (path_map, from, cur_loc, start_terrain);
-       cur_cost = 0; /* cost to reach current perimeter */
-
-       for (;;) {
-               to->len = 0; /* nothing in perim yet */
-               expand_perimeter (path_map, vmap, &move_info, from,
-                                 terrain, cur_cost, 1, 1, to, to);
-               cur_cost += 1;
-               if (to->len == 0 || best_cost <= cur_cost) {
-                       vmap[dest_loc].contents = old_contents;
-                       return best_loc;
-               }
-               SWAP (from, to);
+    start_perimeter (path_map, from, cur_loc, start_terrain);
+    cur_cost = 0; /* cost to reach current perimeter */
+
+    for (;;) {
+       to->len = 0; /* nothing in perim yet */
+       expand_perimeter (path_map, vmap, &move_info, from,
+                         terrain, cur_cost, 1, 1, to, to);
+       cur_cost += 1;
+       if (to->len == 0 || best_cost <= cur_cost) {
+           vmap[dest_loc].contents = old_contents;
+           return best_loc;
        }
+       SWAP (from, to);
+    }
 }
 
 /*
@@ -906,18 +910,18 @@ Someday, this routine should probably use perimeter lists as well.
 void
 vmap_mark_path(path_map_t *path_map, view_map_t *vmap, loc_t dest)
 {
-       int n;
-       loc_t new_dest;
+    int n;
+    loc_t new_dest;
 
-       if (path_map[dest].cost == 0) return; /* reached end of path */
-       if (path_map[dest].terrain == T_PATH) return; /* already marked */
+    if (path_map[dest].cost == 0) return; /* reached end of path */
+    if (path_map[dest].terrain == T_PATH) return; /* already marked */
 
-       path_map[dest].terrain = T_PATH; /* this square is on path */
+    path_map[dest].terrain = T_PATH; /* this square is on path */
 
-       /* loop to mark adjacent squares on shortest path */
-       FOR_ADJ (dest, new_dest, n)
+    /* loop to mark adjacent squares on shortest path */
+    FOR_ADJ (dest, new_dest, n)
        if (path_map[new_dest].cost == path_map[dest].cost - path_map[dest].inc_cost)
-                       vmap_mark_path (path_map, vmap, new_dest);
+           vmap_mark_path (path_map, vmap, new_dest);
 
 }
 
@@ -930,11 +934,11 @@ invoked to decide which squares are actually valid.
 void
 vmap_mark_adjacent(path_map_t path_map[], loc_t loc)
 {
-       int i;
-       loc_t new_loc;
+    int i;
+    loc_t new_loc;
 
-       FOR_ADJ_ON (loc, new_loc, i)
-               path_map[new_loc].terrain = T_PATH;
+    FOR_ADJ_ON (loc, new_loc, i)
+       path_map[new_loc].terrain = T_PATH;
 }
 
 /*
@@ -946,22 +950,22 @@ to a location on the existing shortest path.
 void
 vmap_mark_near_path(path_map_t path_map[], loc_t loc)
 {
-       int i, j;
-       loc_t new_loc, xloc;
-       int hit_loc[8];
+    int i, j;
+    loc_t new_loc, xloc;
+    int hit_loc[8];
 
-       (void) bzero ((char *)hit_loc, sizeof(int)*8);
+    (void) bzero ((char *)hit_loc, sizeof(int)*8);
        
-       FOR_ADJ_ON (loc, new_loc, i) {
-               FOR_ADJ_ON (new_loc, xloc, j)
-               if (xloc != loc && path_map[xloc].terrain == T_PATH) {
-                       hit_loc[i] = 1;
-                       break;
-               }
-       }
-       for (i = 0; i < 8; i++)
+    FOR_ADJ_ON (loc, new_loc, i) {
+       FOR_ADJ_ON (new_loc, xloc, j)
+           if (xloc != loc && path_map[xloc].terrain == T_PATH) {
+               hit_loc[i] = 1;
+               break;
+           }
+    }
+    for (i = 0; i < 8; i++)
        if (hit_loc[i])
-       path_map[loc + dir_offset[i]].terrain = T_PATH;
+           path_map[loc + dir_offset[i]].terrain = T_PATH;
 }
 
 /*
@@ -997,38 +1001,38 @@ loc_t
 vmap_find_dir(path_map_t path_map[], view_map_t *vmap,
              loc_t loc, char *terrain, char *adj_char)
 {
-       int i, count, bestcount;
-       loc_t bestloc, new_loc;
-       int path_count, bestpath;
-       char *p;
+    int i, count, bestcount;
+    loc_t bestloc, new_loc;
+    int path_count, bestpath;
+    char *p;
        
-       if (trace_pmap)
-               print_pzoom ("Before vmap_find_dir:", path_map, vmap);
+    if (trace_pmap)
+       print_pzoom ("Before vmap_find_dir:", path_map, vmap);
                
-       bestcount = -INFINITY; /* no best yet */
-       bestpath = -1;
-       bestloc = loc;
+    bestcount = -INFINITY; /* no best yet */
+    bestpath = -1;
+    bestloc = loc;
        
-       for (i = 0; i < 8; i++) { /* for each adjacent square */
-               new_loc = loc + dir_offset[order[i]];
-               if (path_map[new_loc].terrain == T_PATH) { /* which is on path */
-                       p = strchr (terrain, vmap[new_loc].contents);
+    for (i = 0; i < 8; i++) { /* for each adjacent square */
+       new_loc = loc + dir_offset[order[i]];
+       if (path_map[new_loc].terrain == T_PATH) { /* which is on path */
+           p = strchr (terrain, vmap[new_loc].contents);
                        
-                       if (p != NULL) { /* desirable square? */
-                               count = vmap_count_adjacent (vmap, new_loc, adj_char);
-                               path_count = vmap_count_path (path_map, new_loc);
+           if (p != NULL) { /* desirable square? */
+               count = vmap_count_adjacent (vmap, new_loc, adj_char);
+               path_count = vmap_count_path (path_map, new_loc);
                                
-                               /* remember best location */
-                               if (count > bestcount
-                                   || (count == bestcount && path_count > bestpath) ) {
-                                       bestcount = count;
-                                       bestpath = path_count;
-                                       bestloc = new_loc;
-                               }
-                       }
+               /* remember best location */
+               if (count > bestcount
+                   || (count == bestcount && path_count > bestpath) ) {
+                   bestcount = count;
+                   bestpath = path_count;
+                   bestloc = new_loc;
                }
+           }
        }
-       return (bestloc);
+    }
+    return (bestloc);
 }
        
 /*
@@ -1040,20 +1044,20 @@ is the most interesting.
 int
 vmap_count_adjacent(view_map_t *vmap, loc_t loc, char *adj_char)
 {
-       int i, count;
-       loc_t new_loc;
-       char *p;
-       int len;
+    int i, count;
+    loc_t new_loc;
+    char *p;
+    int len;
 
-       len = strlen (adj_char);
+    len = strlen (adj_char);
 
-       count = 0;
+    count = 0;
        
-       FOR_ADJ_ON (loc, new_loc, i) {
-               p = strchr (adj_char, vmap[new_loc].contents);
-               if (p) count += 8 * (len - (p - adj_char));
-       }
-       return (count);
+    FOR_ADJ_ON (loc, new_loc, i) {
+       p = strchr (adj_char, vmap[new_loc].contents);
+       if (p) count += 8 * (len - (p - adj_char));
+    }
+    return (count);
 }
 
 /*
@@ -1063,16 +1067,16 @@ Count the number of adjacent cells that are on the path.
 int
 vmap_count_path(path_map_t *pmap, loc_t loc)
 {
-       int i, count;
-       loc_t new_loc;
+    int i, count;
+    loc_t new_loc;
 
-       count = 0;
+    count = 0;
        
-       FOR_ADJ_ON (loc, new_loc, i)
+    FOR_ADJ_ON (loc, new_loc, i)
        if (pmap[new_loc].terrain == T_PATH)
-               count += 1;
+           count += 1;
 
-       return (count);
+    return (count);
 }
 
 /*
@@ -1083,24 +1087,24 @@ cell contains water and is on the board.
 bool
 rmap_shore(loc_t loc)
 {
-       loc_t i, j;
+    loc_t i, j;
 
-       FOR_ADJ_ON (loc, j, i)
-           if (map[j].contents == '.') return (true);
+    FOR_ADJ_ON (loc, j, i)
+       if (map[j].contents == '.') return (true);
 
-       return (false);
+    return (false);
 }
 
 bool
 vmap_shore(view_map_t *vmap, loc_t loc)
 {
-       loc_t i, j;
+    loc_t i, j;
 
-       FOR_ADJ_ON (loc, j, i)
-               if (vmap[j].contents != ' ' && vmap[j].contents != '+' && map[j].contents == '.')
-                               return (true);
+    FOR_ADJ_ON (loc, j, i)
+       if (vmap[j].contents != ' ' && vmap[j].contents != '+' && map[j].contents == '.')
+           return (true);
 
-       return (false);
+    return (false);
 }
 
 /*
@@ -1111,25 +1115,26 @@ which cannot be moved to are treated as ocean.
 bool
 vmap_at_sea(view_map_t *vmap, loc_t loc)
 {
-       loc_t i, j;
+    loc_t i, j;
 
-       if (map[loc].contents != '.') return (false);
-               FOR_ADJ_ON (loc, j, i)
-                       if (vmap[j].contents == ' ' || vmap[j].contents == '+' || map[j].contents != '.')
-                                       return (false);
+    if (map[loc].contents != '.') return (false);
+    FOR_ADJ_ON (loc, j, i)
+       if (vmap[j].contents == ' ' || vmap[j].contents == '+' || map[j].contents != '.')
+           return (false);
 
-       return (true);
+    return (true);
 }
 
 bool
 rmap_at_sea (loc_t loc)
 {
-       loc_t i, j;
+    loc_t i, j;
 
-       if (map[loc].contents != '.') return (false);
-               FOR_ADJ_ON (loc, j, i) {
-                       if (map[j].contents != '.') return (false);
-               }
-       return (true);
+    if (map[loc].contents != '.') return (false);
+    FOR_ADJ_ON (loc, j, i) {
+       if (map[j].contents != '.') return (false);
+    }
+    return (true);
 }
 
+/* end */
index b8eb1c1..252a202 100644 (file)
--- a/object.c
+++ b/object.c
@@ -26,23 +26,23 @@ Distances are computed as straight-line distances.
 int
 find_nearest_city(loc_t loc, int owner, loc_t *city_loc)
 {
-       loc_t best_loc;
-       long best_dist;
-       long new_dist, i;
+    loc_t best_loc;
+    long best_dist;
+    long new_dist, i;
        
-       best_dist = INFINITY;
-       best_loc = loc;
+    best_dist = INFINITY;
+    best_loc = loc;
        
-       for (i = 0; i < NUM_CITY; i++) 
+    for (i = 0; i < NUM_CITY; i++) 
        if (city[i].owner == owner) {
-              new_dist = dist (loc, city[i].loc);
-              if (new_dist < best_dist) {
-                      best_dist = new_dist;
-                      best_loc = city[i].loc;
-              }
+           new_dist = dist (loc, city[i].loc);
+           if (new_dist < best_dist) {
+               best_dist = new_dist;
+               best_loc = city[i].loc;
+           }
        }
-       *city_loc = best_loc;
-       return best_dist;
+    *city_loc = best_loc;
+    return best_dist;
 }
 
 /*
@@ -51,7 +51,7 @@ Given the location of a city, return the index of that city.
 
 city_info_t *find_city(loc_t loc)
 {
-       return (map[loc].cityp);
+    return (map[loc].cityp);
 }
 
 /*
@@ -65,9 +65,9 @@ half of its hits moves at half-speed, for example.
 
 int obj_moves (piece_info_t *obj)
 {
-       return (piece_attr[obj->type].speed * obj->hits
-              + piece_attr[obj->type].max_hits - 1) /* round up */
-              / piece_attr[obj->type].max_hits;
+    return (piece_attr[obj->type].speed * obj->hits
+           + piece_attr[obj->type].max_hits - 1) /* round up */
+       / piece_attr[obj->type].max_hits;
 }
 
 /*
@@ -76,9 +76,9 @@ Figure out the capacity for an object.
 
 int obj_capacity(piece_info_t *obj)
 {
-       return (piece_attr[obj->type].capacity * obj->hits
-              + piece_attr[obj->type].max_hits - 1) /* round up */
-              / piece_attr[obj->type].max_hits;
+    return (piece_attr[obj->type].capacity * obj->hits
+           + piece_attr[obj->type].max_hits - 1) /* round up */
+       / piece_attr[obj->type].max_hits;
 }
 
 /*
@@ -88,12 +88,12 @@ list of objects at the given location for one of the given type.
 
 piece_info_t *find_obj(int type, loc_t loc)
 {
-       piece_info_t *p;
+    piece_info_t *p;
 
-       for (p = map[loc].objp; p != NULL; p = p->loc_link.next)
+    for (p = map[loc].objp; p != NULL; p = p->loc_link.next)
        if (p->type == type) return (p);
 
-       return (NULL);
+    return (NULL);
 }
 
 /*
@@ -102,13 +102,13 @@ Find a non-full item of the appropriate type at the given location.
 
 piece_info_t *find_nfull(int type, loc_t loc)
 {
-       piece_info_t *p;
+    piece_info_t *p;
 
-       for (p = map[loc].objp; p != NULL; p = p->loc_link.next)
+    for (p = map[loc].objp; p != NULL; p = p->loc_link.next)
        if (p->type == type) {
-               if (obj_capacity (p) > p->count) return (p);
+           if (obj_capacity (p) > p->count) return (p);
        }
-       return (NULL);
+    return (NULL);
 }
 
 /*
@@ -119,16 +119,16 @@ of the transport if there is one.
 loc_t
 find_transport(int owner, loc_t loc)
 {
-       int i;
-       loc_t new_loc;
-       piece_info_t *t;
-
-       for (i = 0; i < 8; i++) { /* look around */
-               new_loc = loc + dir_offset[i];
-               t = find_nfull (TRANSPORT, new_loc);
-               if (t != NULL && t->owner == owner) return (new_loc);
-       }
-       return (loc); /* no tt found */
+    int i;
+    loc_t new_loc;
+    piece_info_t *t;
+
+    for (i = 0; i < 8; i++) { /* look around */
+       new_loc = loc + dir_offset[i];
+       t = find_nfull (TRANSPORT, new_loc);
+       if (t != NULL && t->owner == owner) return (new_loc);
+    }
+    return (loc); /* no tt found */
 }
 
 /*
@@ -139,16 +139,16 @@ We prefer transports and carriers to other objects.
 piece_info_t *
 find_obj_at_loc(loc_t loc)
 {
-       piece_info_t *p, *best;
+    piece_info_t *p, *best;
        
-       best = map[loc].objp;
-       if (best == NULL) return (NULL); /* nothing here */
+    best = map[loc].objp;
+    if (best == NULL) return (NULL); /* nothing here */
 
-       for (p = best->loc_link.next; p != NULL; p = p->loc_link.next)
+    for (p = best->loc_link.next; p != NULL; p = p->loc_link.next)
        if (p->type > best->type && p->type != SATELLITE)
-               best = p;
+           best = p;
 
-       return (best);
+    return (best);
 }
 
 /*
@@ -157,11 +157,11 @@ If an object is on a ship, remove it from that ship.
 
 void disembark(piece_info_t *obj)
 {
-       if (obj->ship) {
-               UNLINK (obj->ship->cargo, obj, cargo_link);
-               obj->ship->count -= 1;
-               obj->ship = NULL;
-       }
+    if (obj->ship) {
+       UNLINK (obj->ship->cargo, obj, cargo_link);
+       obj->ship->count -= 1;
+       obj->ship = NULL;
+    }
 }
 
 /*
@@ -182,32 +182,32 @@ anything in the object, it is killed as well.
 
 void kill_obj(piece_info_t *obj, loc_t loc)
 {
-       void kill_one();
+    void kill_one();
 
-       piece_info_t **list;
-       view_map_t *vmap;
+    piece_info_t **list;
+    view_map_t *vmap;
        
-       vmap = MAP(obj->owner);
-       list = LIST(obj->owner);
+    vmap = MAP(obj->owner);
+    list = LIST(obj->owner);
        
-       while (obj->cargo != NULL) /* kill contents */
-               kill_one (list, obj->cargo);
+    while (obj->cargo != NULL) /* kill contents */
+       kill_one (list, obj->cargo);
 
-       kill_one (list, obj);
-       scan (vmap, loc); /* scan around new location */
+    kill_one (list, obj);
+    scan (vmap, loc); /* scan around new location */
 }
 
 /* kill an object without scanning */
 
 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);
-       disembark (obj);
+    UNLINK (list[obj->type], obj, piece_link); /* unlink obj from all lists */
+    UNLINK (map[obj->loc].objp, obj, loc_link);
+    disembark (obj);
 
-       LINK (free_list, obj, piece_link); /* return object to free list */
-       obj->hits = 0; /* let all know this object is dead */
-       obj->moved = piece_attr[obj->type].speed; /* object has moved */
+    LINK (free_list, obj, piece_link); /* return object to free list */
+    obj->hits = 0; /* let all know this object is dead */
+    obj->moved = piece_attr[obj->type].speed; /* object has moved */
 }
 
 /*
@@ -217,45 +217,45 @@ to unowned.  We scan around the city's location.
 
 void kill_city(city_info_t *cityp)
 {
-       view_map_t *vmap;
-       piece_info_t *p;
-       piece_info_t *next_p;
-       piece_info_t **list;
-       int i;
+    view_map_t *vmap;
+    piece_info_t *p;
+    piece_info_t *next_p;
+    piece_info_t **list;
+    int i;
        
-       /* change ownership of hardware at this location; but not satellites */
-       for (p = map[cityp->loc].objp; p; p = next_p) {
-               next_p = p->loc_link.next;
+    /* change ownership of hardware at this location; but not satellites */
+    for (p = map[cityp->loc].objp; p; p = next_p) {
+       next_p = p->loc_link.next;
                
-               if (p->type == ARMY) kill_obj (p, cityp->loc);
-               else if (p->type != SATELLITE) {
-                       if (p->type == TRANSPORT) {
-                               list = LIST(p->owner);
+       if (p->type == ARMY) kill_obj (p, cityp->loc);
+       else if (p->type != SATELLITE) {
+           if (p->type == TRANSPORT) {
+               list = LIST(p->owner);
                                
-                               while (p->cargo != NULL) /* kill contents */
-                                       kill_one (list, p->cargo);
-                       }
-                       list = LIST (p->owner);
-                       UNLINK (list[p->type], p, piece_link);
-                       p->owner = (p->owner == USER ? COMP : USER);
-                       list = LIST (p->owner);
-                       LINK (list[p->type], p, piece_link);
+               while (p->cargo != NULL) /* kill contents */
+                   kill_one (list, p->cargo);
+           }
+           list = LIST (p->owner);
+           UNLINK (list[p->type], p, piece_link);
+           p->owner = (p->owner == USER ? COMP : USER);
+           list = LIST (p->owner);
+           LINK (list[p->type], p, piece_link);
                        
-                       p->func = NOFUNC;
-               }
+           p->func = NOFUNC;
        }
+    }
 
-       if (cityp->owner != UNOWNED) {
-               vmap = MAP(cityp->owner);
-               cityp->owner = UNOWNED;
-               cityp->work = 0;
-               cityp->prod = NOPIECE;
+    if (cityp->owner != UNOWNED) {
+       vmap = MAP(cityp->owner);
+       cityp->owner = UNOWNED;
+       cityp->work = 0;
+       cityp->prod = NOPIECE;
                
-               for (i = 0; i < NUM_OBJECTS; i++)
-                       cityp->func[i] = NOFUNC;
+       for (i = 0; i < NUM_OBJECTS; i++)
+           cityp->func[i] = NOFUNC;
                
-               scan (vmap, cityp->loc);
-       }
+       scan (vmap, cityp->loc);
+    }
 }
 
 /*
@@ -267,35 +267,35 @@ static int sat_dir[4] = {MOVE_NW, MOVE_SW, MOVE_NE, MOVE_SE};
 void
 produce(city_info_t *cityp)
 {
-       piece_info_t **list;
-       piece_info_t *new;
+    piece_info_t **list;
+    piece_info_t *new;
        
-       list = LIST (cityp->owner);
+    list = LIST (cityp->owner);
 
-       cityp->work -= piece_attr[(int)cityp->prod].build_time;
+    cityp->work -= piece_attr[(int)cityp->prod].build_time;
        
-       ASSERT (free_list); /* can we allocate? */
-       new = free_list;
-       UNLINK (free_list, new, piece_link);
-       LINK (list[(int)cityp->prod], new, piece_link);
-       LINK (map[cityp->loc].objp, new, loc_link);
-       new->cargo_link.next = NULL;
-       new->cargo_link.prev = NULL;
+    ASSERT (free_list); /* can we allocate? */
+    new = free_list;
+    UNLINK (free_list, new, piece_link);
+    LINK (list[(int)cityp->prod], new, piece_link);
+    LINK (map[cityp->loc].objp, new, loc_link);
+    new->cargo_link.next = NULL;
+    new->cargo_link.prev = NULL;
        
-       new->loc = cityp->loc;
-       new->func = NOFUNC;
-       new->hits = piece_attr[(int)cityp->prod].max_hits;
-       new->owner = cityp->owner;
-       new->type = cityp->prod;
-       new->moved = 0;
-       new->cargo = NULL;
-       new->ship = NULL;
-       new->count = 0;
-       new->range = piece_attr[(int)cityp->prod].range;
+    new->loc = cityp->loc;
+    new->func = NOFUNC;
+    new->hits = piece_attr[(int)cityp->prod].max_hits;
+    new->owner = cityp->owner;
+    new->type = cityp->prod;
+    new->moved = 0;
+    new->cargo = NULL;
+    new->ship = NULL;
+    new->count = 0;
+    new->range = piece_attr[(int)cityp->prod].range;
        
-       if (new->type == SATELLITE) { /* set random move direction */
-               new->func = sat_dir[irand (4)];
-       }
+    if (new->type == SATELLITE) { /* set random move direction */
+       new->func = sat_dir[irand (4)];
+    }
 }
 
 /*
@@ -308,47 +308,47 @@ etc.
 
 void move_obj(piece_info_t *obj, loc_t new_loc)
 {
-       view_map_t *vmap;
-       loc_t old_loc;
-       piece_info_t *p;
+    view_map_t *vmap;
+    loc_t old_loc;
+    piece_info_t *p;
 
-       ASSERT (obj->hits);
-       vmap = MAP(obj->owner);
+    ASSERT (obj->hits);
+    vmap = MAP(obj->owner);
 
-       old_loc = obj->loc; /* save original location */
-       obj->moved += 1;
-       obj->loc = new_loc;
-       obj->range--;
+    old_loc = obj->loc; /* save original location */
+    obj->moved += 1;
+    obj->loc = new_loc;
+    obj->range--;
        
-       disembark (obj); /* remove object from any ship */
+    disembark (obj); /* remove object from any ship */
        
-       UNLINK (map[old_loc].objp, obj, loc_link);
-       LINK (map[new_loc].objp, obj, loc_link);
-
-       /* move any objects contained in object */
-       for (p = obj->cargo; p != NULL; p = p->cargo_link.next) {
-               p->loc = new_loc;
-               UNLINK (map[old_loc].objp, p, loc_link);
-               LINK (map[new_loc].objp, p, loc_link);
-       }
+    UNLINK (map[old_loc].objp, obj, loc_link);
+    LINK (map[new_loc].objp, obj, loc_link);
+
+    /* move any objects contained in object */
+    for (p = obj->cargo; p != NULL; p = p->cargo_link.next) {
+       p->loc = new_loc;
+       UNLINK (map[old_loc].objp, p, loc_link);
+       LINK (map[new_loc].objp, p, loc_link);
+    }
        
-       switch (obj->type) { /* board new ship */
-       case FIGHTER:
-               if (map[obj->loc].cityp == NULL) { /* not in a city? */
-                       p = find_nfull (CARRIER, obj->loc);
-                       if (p != NULL) embark (p, obj);
-               }
-               break;
-
-       case ARMY:
-               p = find_nfull (TRANSPORT, obj->loc);
-               if (p != NULL) embark (p, obj);
-               break;
+    switch (obj->type) { /* board new ship */
+    case FIGHTER:
+       if (map[obj->loc].cityp == NULL) { /* not in a city? */
+           p = find_nfull (CARRIER, obj->loc);
+           if (p != NULL) embark (p, obj);
        }
+       break;
+
+    case ARMY:
+       p = find_nfull (TRANSPORT, obj->loc);
+       if (p != NULL) embark (p, obj);
+       break;
+    }
 
-       if (obj->type == SATELLITE)
-               scan_sat (vmap, obj->loc);
-       scan (vmap, obj->loc);
+    if (obj->type == SATELLITE)
+       scan_sat (vmap, obj->loc);
+    scan (vmap, obj->loc);
 }
 
 /*
@@ -363,15 +363,15 @@ We start off with some preliminary routines.
 static loc_t
 bounce(loc_t loc, loc_t dir1, loc_t dir2, loc_t dir3)
 {
-       int new_loc;
+    int new_loc;
 
-       new_loc = loc + dir_offset[MOVE_DIR (dir1)];
-       if (map[new_loc].on_board) return dir1;
+    new_loc = loc + dir_offset[MOVE_DIR (dir1)];
+    if (map[new_loc].on_board) return dir1;
 
-       new_loc = loc + dir_offset[MOVE_DIR (dir2)];
-       if (map[new_loc].on_board) return dir2;
+    new_loc = loc + dir_offset[MOVE_DIR (dir2)];
+    if (map[new_loc].on_board) return dir2;
 
-       return dir3;
+    return dir3;
 }
 
 /* Move a satellite one square. */
@@ -379,32 +379,32 @@ bounce(loc_t loc, loc_t dir1, loc_t dir2, loc_t dir3)
 static void
 move_sat1(piece_info_t *obj)
 {
-       int dir;
-       loc_t new_loc;
-
+    int dir;
+    loc_t new_loc;
+
+    dir = MOVE_DIR(obj->func);
+    new_loc = obj->loc + dir_offset[dir];
+
+    if (!map[new_loc].on_board) {
+       switch (obj->func) {
+       case MOVE_NE:
+           obj->func = bounce (obj->loc, MOVE_NW, MOVE_SE, MOVE_SW);
+           break;
+       case MOVE_NW:
+           obj->func = bounce (obj->loc, MOVE_NE, MOVE_SW, MOVE_SE);
+           break;
+       case MOVE_SE:
+           obj->func = bounce (obj->loc, MOVE_SW, MOVE_NE, MOVE_NW);
+           break;
+       case MOVE_SW:
+           obj->func = bounce (obj->loc, MOVE_SE, MOVE_NW, MOVE_NE);
+           break;
+       default: ABORT;
+       }
        dir = MOVE_DIR(obj->func);
        new_loc = obj->loc + dir_offset[dir];
-
-       if (!map[new_loc].on_board) {
-               switch (obj->func) {
-               case MOVE_NE:
-                       obj->func = bounce (obj->loc, MOVE_NW, MOVE_SE, MOVE_SW);
-                       break;
-               case MOVE_NW:
-                       obj->func = bounce (obj->loc, MOVE_NE, MOVE_SW, MOVE_SE);
-                       break;
-               case MOVE_SE:
-                       obj->func = bounce (obj->loc, MOVE_SW, MOVE_NE, MOVE_NW);
-                       break;
-               case MOVE_SW:
-                       obj->func = bounce (obj->loc, MOVE_SE, MOVE_NW, MOVE_NE);
-                       break;
-               default: ABORT;
-               }
-               dir = MOVE_DIR(obj->func);
-               new_loc = obj->loc + dir_offset[dir];
-       }
-       move_obj (obj, new_loc);
+    }
+    move_obj (obj, new_loc);
 }
 
 /*
@@ -415,17 +415,17 @@ Satellite burns iff it's range reaches zero.
 void
 move_sat(piece_info_t *obj)
 {
-       obj->moved = 0;
+    obj->moved = 0;
        
-       while (obj->moved < obj_moves (obj)) {
-               move_sat1 (obj);
-               if (obj->range == 0) {
-                       if (obj->owner == USER)
-                               comment ("Satellite at %d crashed and burned.", loc_disp(obj->loc));
-                               ksend ("Satellite at %d crashed and burned.", loc_disp(obj->loc));
-                       kill_obj (obj, obj->loc);
-               }
+    while (obj->moved < obj_moves (obj)) {
+       move_sat1 (obj);
+       if (obj->range == 0) {
+           if (obj->owner == USER)
+               comment ("Satellite at %d crashed and burned.", loc_disp(obj->loc));
+           ksend ("Satellite at %d crashed and burned.", loc_disp(obj->loc));
+           kill_obj (obj, obj->loc);
        }
+    }
 }
 
 /*
@@ -438,66 +438,66 @@ move onto transports, and fighters may move onto cities or carriers.
 
 bool good_loc(piece_info_t *obj, loc_t loc)
 {
-       view_map_t *vmap;
-       piece_info_t *p;
+    view_map_t *vmap;
+    piece_info_t *p;
        
-       if (!map[loc].on_board) return (false);
+    if (!map[loc].on_board) return (false);
 
-       vmap = MAP (obj->owner);
+    vmap = MAP (obj->owner);
 
-       if (strchr (piece_attr[obj->type].terrain, vmap[loc].contents) != NULL)
-               return (true);
+    if (strchr (piece_attr[obj->type].terrain, vmap[loc].contents) != NULL)
+       return (true);
 
-       /* armies can move into unfull transports */
-       if (obj->type == ARMY) {
-               p = find_nfull (TRANSPORT, loc);
-               return (p != NULL && p->owner == obj->owner);
-       }
+    /* armies can move into unfull transports */
+    if (obj->type == ARMY) {
+       p = find_nfull (TRANSPORT, loc);
+       return (p != NULL && p->owner == obj->owner);
+    }
 
-       /* ships and fighters can move into cities */
-       if (map[loc].cityp && map[loc].cityp->owner == obj->owner)
-               return (true);
+    /* ships and fighters can move into cities */
+    if (map[loc].cityp && map[loc].cityp->owner == obj->owner)
+       return (true);
 
-       /* fighters can move onto unfull carriers */
-       if (obj->type == FIGHTER) {
-               p = find_nfull (CARRIER, loc);
-               return (p != NULL && p->owner == obj->owner);
-       }
+    /* fighters can move onto unfull carriers */
+    if (obj->type == FIGHTER) {
+       p = find_nfull (CARRIER, loc);
+       return (p != NULL && p->owner == obj->owner);
+    }
 
-       return (false);
+    return (false);
 }
 
 void describe_obj(piece_info_t *obj)
 {
-       char func[STRSIZE];
-       char other[STRSIZE];
+    char func[STRSIZE];
+    char other[STRSIZE];
 
-       if (obj->func >= 0) (void) sprintf (func, "%d", loc_disp(obj->func));
-       else (void) sprintf (func, func_name[FUNCI(obj->func)]);
+    if (obj->func >= 0) (void) sprintf (func, "%d", loc_disp(obj->func));
+    else (void) sprintf (func, func_name[FUNCI(obj->func)]);
        
-       other[0] = 0;
-
-       switch (obj->type) { /* set other information */
-       case FIGHTER:
-               (void) sprintf (other,"; range = %d",obj->range);
-               break;
-
-       case TRANSPORT:
-               (void) sprintf (other,"; armies = %d",obj->count);
-               break;
-
-       case CARRIER:
-               (void) sprintf (other,"; fighters = %d",obj->count);
-               break;
-       }
-
-       prompt ("%s at %d:  moves = %d; hits = %d; func = %s%s",
-               piece_attr[obj->type].name,
-               loc_disp(obj->loc),
-               obj_moves (obj) - obj->moved,
-               obj->hits,
-               func,
-               other);
+    other[0] = 0;
+
+    switch (obj->type) { /* set other information */
+    case FIGHTER:
+       (void) sprintf (other,"; range = %d",obj->range);
+       break;
+
+    case TRANSPORT:
+       (void) sprintf (other,"; armies = %d",obj->count);
+       break;
+
+    case CARRIER:
+       (void) sprintf (other,"; fighters = %d",obj->count);
+       break;
+    }
+
+    prompt ("%s at %d:  moves = %d; hits = %d; func = %s%s",
+           piece_attr[obj->type].name,
+           loc_disp(obj->loc),
+           obj_moves (obj) - obj->moved,
+           obj->hits,
+           func,
+           other);
 }
 
 /*
@@ -512,21 +512,21 @@ on top.
 void
 scan(view_map_t vmap[], loc_t loc)
 {
-       void update(), check(void);
+    void update(), check(void);
 
-       int i;
-       loc_t xloc;
+    int i;
+    loc_t xloc;
 
 #ifdef DEBUG
-       check (); /* perform a consistency check */
+    check (); /* perform a consistency check */
 #endif
-       ASSERT (map[loc].on_board); /* passed loc must be on board */
+    ASSERT (map[loc].on_board); /* passed loc must be on board */
 
-       for (i = 0; i < 8; i++) { /* for each surrounding cell */
-               xloc = loc + dir_offset[i];
-               update (vmap, xloc);
-       }
-       update (vmap, loc); /* update current location as well */
+    for (i = 0; i < 8; i++) { /* for each surrounding cell */
+       xloc = loc + dir_offset[i];
+       update (vmap, xloc);
+    }
+    update (vmap, loc); /* update current location as well */
 }
 
 /*
@@ -560,26 +560,27 @@ char city_char[] = {'*', 'O', 'X'};
 void
 update(view_map_t vmap[], loc_t loc)
 {
-       piece_info_t *p;
+    piece_info_t *p;
 
-       vmap[loc].seen = date;
+    vmap[loc].seen = date;
        
-       if (map[loc].cityp) /* is there a city here? */
-               vmap[loc].contents = city_char[map[loc].cityp->owner];
+    if (map[loc].cityp) /* is there a city here? */
+       vmap[loc].contents = city_char[map[loc].cityp->owner];
        
-       else {
-               p = find_obj_at_loc (loc);
+    else {
+       p = find_obj_at_loc (loc);
                
-               if (p == NULL) /* nothing here? */
-                       vmap[loc].contents = map[loc].contents;
-               else if (p->owner == USER)
-                       vmap[loc].contents = piece_attr[p->type].sname;
-               else vmap[loc].contents = tolower (piece_attr[p->type].sname);
-       }
-       if (vmap == comp_map)
-               display_locx (COMP, comp_map, loc);
-       else if (vmap == user_map)
-               display_locx (USER, user_map, loc);
+       if (p == NULL) /* nothing here? */
+           vmap[loc].contents = map[loc].contents;
+       else if (p->owner == USER)
+           vmap[loc].contents = piece_attr[p->type].sname;
+       else
+           vmap[loc].contents = tolower (piece_attr[p->type].sname);
+    }
+    if (vmap == comp_map)
+       display_locx (COMP, comp_map, loc);
+    else if (vmap == user_map)
+       display_locx (USER, user_map, loc);
 }
 
 /*
@@ -591,25 +592,25 @@ asking until we get a valid answer.
 void
 set_prod(city_info_t *cityp)
 {
-       int i;
+    int i;
 
-       scan (user_map, cityp->loc);
-       display_loc_u (cityp->loc);
+    scan (user_map, cityp->loc);
+    display_loc_u (cityp->loc);
 
-       for (;;) {
-               prompt ("What do you want the city at %d to produce? ",loc_disp(cityp->loc));
+    for (;;) {
+       prompt ("What do you want the city at %d to produce? ",loc_disp(cityp->loc));
 
-               i = get_piece_name ();
+       i = get_piece_name ();
                
-               if (i == NOPIECE)
-                       error ("I don't know how to build those.");
+       if (i == NOPIECE)
+           error ("I don't know how to build those.");
                        
-               else {
-                       cityp->prod = i;
-                       city->work = -(piece_attr[i].build_time / 5);
-                       return;
-               }
+       else {
+           cityp->prod = i;
+           city->work = -(piece_attr[i].build_time / 5);
+           return;
        }
+    }
 }
 
 /* Get the name of a type of object. */
@@ -617,14 +618,16 @@ set_prod(city_info_t *cityp)
 int
 get_piece_name(void)
 {
-       char c;
-       int i;
+    char c;
+    int i;
        
-       c = get_chx (); /* get the answer */
+    c = get_chx (); /* get the answer */
 
-       for (i = 0; i < NUM_OBJECTS; i++)
+    for (i = 0; i < NUM_OBJECTS; i++)
        if (piece_attr[i].sname == c) {
-               return i;
+           return i;
        }
-       return NOPIECE;
+    return NOPIECE;
 }
+
+/* end */
diff --git a/term.c b/term.c
index 7c09de6..ed70f64 100644 (file)
--- a/term.c
+++ b/term.c
@@ -49,7 +49,7 @@ we finish printing information to the screen.
 void
 topini(void)
 {
-       info (0, 0, 0);
+    info (0, 0, 0);
 }
 /*
 Write a message to one of the top lines.
@@ -58,24 +58,24 @@ Write a message to one of the top lines.
 static void vtopmsg(int line, const char *fmt, va_list varglist)
 /* assemble command in printf(3) style, print to a top line */
 {
-       char junkbuf[STRSIZE];
+    char junkbuf[STRSIZE];
        
-       if (line < 1 || line > NUMTOPS)
-           line = 1;
-       (void) move (line - 1, 0);
-       vsprintf(junkbuf, fmt, varglist);
-       (void) addstr (junkbuf);
-       (void) clrtoeol();
+    if (line < 1 || line > NUMTOPS)
+       line = 1;
+    (void) move (line - 1, 0);
+    vsprintf(junkbuf, fmt, varglist);
+    (void) addstr (junkbuf);
+    (void) clrtoeol();
 }
 
 void
 topmsg(int line, char *fmt, ...)
 {
-       va_list ap;
+    va_list ap;
 
-       va_start(ap, fmt);
-       vtopmsg(line, fmt, ap);
-       va_end(ap);
+    va_start(ap, fmt);
+    vtopmsg(line, fmt, ap);
+    va_end(ap);
 }
 
 /*
@@ -85,11 +85,11 @@ Print a prompt on the first message line.
 void
 prompt(char *fmt, ...)
 {
-       va_list ap;
+    va_list ap;
 
-       va_start(ap, fmt);
-       vtopmsg(1, fmt, ap);
-       va_end(ap);
+    va_start(ap, fmt);
+    vtopmsg(1, fmt, ap);
+    va_end(ap);
 }
 
 /*
@@ -99,11 +99,11 @@ Print an error message on the second message line.
 void
 error(char *fmt, ...)
 {
-       va_list ap;
+    va_list ap;
 
-       va_start(ap, fmt);
-       vtopmsg(2, fmt, ap);
-       va_end(ap);
+    va_start(ap, fmt);
+    vtopmsg(2, fmt, ap);
+    va_end(ap);
 }
 
 /*
@@ -113,11 +113,11 @@ Print out extra information.
 void
 extra(char *fmt, ...)
 {
-       va_list ap;
+    va_list ap;
 
-       va_start(ap, fmt);
-       vtopmsg(3, fmt, ap);
-       va_end(ap);
+    va_start(ap, fmt);
+    vtopmsg(3, fmt, ap);
+    va_end(ap);
 }
 
 
@@ -128,7 +128,7 @@ Print out a generic error message.
 void
 huh(void)
 {
-       error ("Type H for Help.");
+    error ("Type H for Help.");
 }
 
 /*
@@ -140,46 +140,47 @@ information, we set the need_delay flag.
 void
 info(char *a, char *b, char *c)
 {
-       if (need_delay) delay ();
-       topmsg (1, a);
-       topmsg (2, b);
-       topmsg (3, c);
-       need_delay = (a || b || c);
+    if (need_delay) delay ();
+    topmsg (1, a);
+    topmsg (2, b);
+    topmsg (3, c);
+    need_delay = (a || b || c);
 }
 
 void
-set_need_delay(void) {
-       need_delay = 1;
+set_need_delay(void)
+{
+    need_delay = 1;
 }
 
 void
 comment (char *fmt, ...)
 {
-       va_list ap;
-
-       va_start(ap, fmt);
-       if (need_delay) delay ();
-       topmsg (1, "");
-       topmsg (2, "");
-       vtopmsg (3, fmt, ap);
-       need_delay = (fmt != 0);
-       va_end(ap);
+    va_list ap;
+
+    va_start(ap, fmt);
+    if (need_delay) delay ();
+    topmsg (1, "");
+    topmsg (2, "");
+    vtopmsg (3, fmt, ap);
+    need_delay = (fmt != 0);
+    va_end(ap);
 }
        
 void
 pdebug(char *fmt, ...)
 {
-       va_list ap;
+    va_list ap;
 
-       if (!print_debug) return;
+    if (!print_debug) return;
 
-       va_start(ap, fmt);
-       if (need_delay) delay ();
-       topmsg (1, "");
-       topmsg (2, "");
-       vtopmsg (3, fmt, ap);
-       need_delay = (fmt != 0);
-       va_end(ap);
+    va_start(ap, fmt);
+    if (need_delay) delay ();
+    topmsg (1, "");
+    topmsg (2, "");
+    vtopmsg (3, fmt, ap);
+    need_delay = (fmt != 0);
+    va_end(ap);
 }
 
 /* kermyt begin */
@@ -187,24 +188,24 @@ pdebug(char *fmt, ...)
 void
 vksend(const char *fmt, va_list varglist)
 {
-       if(!(my_stream=fopen("info_list.txt","a")))
-       {
-               error("Cannot open info_list.txt");
-               return;
-       }
-       vfprintf(my_stream, fmt, varglist);
-       fclose(my_stream);
+    if(!(my_stream=fopen("info_list.txt","a")))
+    {
+       error("Cannot open info_list.txt");
        return;
+    }
+    vfprintf(my_stream, fmt, varglist);
+    fclose(my_stream);
+    return;
 }
 
 void
 ksend(char *fmt, ...)
 {
-       va_list ap;
+    va_list ap;
 
-       va_start(ap, fmt);
-       vksend(fmt, ap);
-       va_end(ap);
+    va_start(ap, fmt);
+    vksend(fmt, ap);
+    va_end(ap);
 }
 /* kermyt end */
 
@@ -215,9 +216,9 @@ Get a string from the user, echoing characters all the while.
 void
 get_str(char *buf, int sizep)
 {
-       (void) echo();
-       get_strq(buf, sizep);
-       (void) noecho();
+    (void) echo();
+    get_strq(buf, sizep);
+    (void) noecho();
 }
 
 /*
@@ -227,14 +228,14 @@ Get a string from the user, ignoring the current echo mode.
 void
 get_strq(char *buf, int sizep)
 {
-       sizep = sizep; /* size of buf, currently unused */
-
-       (void) nocrmode ();
-       (void) refresh ();
-       (void) getstr (buf);
-       need_delay = false;
-       info (0, 0, 0);
-       (void) crmode ();
+    sizep = sizep; /* size of buf, currently unused */
+
+    (void) nocrmode ();
+    (void) refresh ();
+    (void) getstr (buf);
+    need_delay = false;
+    info (0, 0, 0);
+    (void) crmode ();
 }
 
 /*
@@ -244,14 +245,14 @@ Get a character from the user and convert it to uppercase.
 char
 get_chx(void)
 {
-       char c;
+    char c;
 
-       c = get_cq ();
+    c = get_cq ();
 
-       if (islower(c))
-               return (toupper(c));
-       else
-               return (c);
+    if (islower(c))
+       return (toupper(c));
+    else
+       return (c);
 }
 
 /*
@@ -261,25 +262,25 @@ Input an integer from the user.
 int
 getint(char *message)
 {
-       char buf[STRSIZE];
-       char *p;
+    char buf[STRSIZE];
+    char *p;
 
-       for (;;) { /* until we get a legal number */
-               prompt (message,0,0,0,0,0,0,0,0);
-               get_str (buf, sizeof (buf));
+    for (;;) { /* until we get a legal number */
+       prompt (message,0,0,0,0,0,0,0,0);
+       get_str (buf, sizeof (buf));
                
-               for (p = buf; *p; p++) {
-                       if (*p < '0' || *p > '9') {
-                               error ("Please enter an integer.",0,0,0,0,0,0,0,0);
-                               break;
-                       }
-               }
-               if (*p == 0) { /* no error yet? */
-                       if (p - buf > 7) /* too many digits? */
-                               error ("Please enter a small integer.",0,0,0,0,0,0,0,0);
-                       else return (atoi (buf));
-               }
+       for (p = buf; *p; p++) {
+           if (*p < '0' || *p > '9') {
+               error ("Please enter an integer.",0,0,0,0,0,0,0,0);
+               break;
+           }
        }
+       if (*p == 0) { /* no error yet? */
+           if (p - buf > 7) /* too many digits? */
+               error ("Please enter a small integer.",0,0,0,0,0,0,0,0);
+           else return (atoi (buf));
+       }
+    }
 }
 
 /*
@@ -289,12 +290,12 @@ Input a character from the user with echoing.
 char
 get_c(void)
 {
-       char c; /* one char and a null */
+    char c; /* one char and a null */
 
-       (void) echo ();
-       c = get_cq ();
-       (void) noecho ();
-       return (c);
+    (void) echo ();
+    c = get_cq ();
+    (void) noecho ();
+    return (c);
 }
 
 /*
@@ -304,14 +305,14 @@ Input a character quietly.
 char
 get_cq(void)
 {
-       char c;
-
-       (void) crmode ();
-       (void) refresh ();
-       c = getch ();
-       topini (); /* clear information lines */
-       (void) nocrmode ();
-       return (c);
+    char c;
+
+    (void) crmode ();
+    (void) refresh ();
+    c = getch ();
+    topini (); /* clear information lines */
+    (void) nocrmode ();
+    return (c);
 }
 
 /*
@@ -322,17 +323,17 @@ a valid response.  We return true iff the user replies 'y'.
 bool
 getyn(char *message)
 {
-       char c;
+    char c;
 
-       for (;;) {
-               prompt (message,0,0,0,0,0,0,0,0);
-               c = get_chx ();
+    for (;;) {
+       prompt (message,0,0,0,0,0,0,0,0);
+       c = get_chx ();
 
-               if (c == 'Y') return (true);
-               if (c == 'N') return (false);
+       if (c == 'Y') return (true);
+       if (c == 'N') return (false);
 
-               error ("Please answer Y or N.",0,0,0,0,0,0,0,0);
-       }
+       error ("Please answer Y or N.",0,0,0,0,0,0,0,0);
+    }
 }
 
 /*
@@ -342,15 +343,15 @@ Input an integer in a range.
 int
 get_range(char *message, int low, int high)
 {
-       int result;
+    int result;
 
-       for (;;) {
-               result = getint (message);
+    for (;;) {
+       result = getint (message);
 
-               if (result >= low && result <= high) return (result);
+       if (result >= low && result <= high) return (result);
 
-               error ("Please enter an integer in the range %d..%d.",low, high);
-       }
+       error ("Please enter an integer in the range %d..%d.",low, high);
+    }
 }
 
 /*
@@ -360,44 +361,44 @@ Print a screen of help information.
 void
 help(char **text, int nlines)
 {
-       int i, r, c;
-       int text_lines;
+    int i, r, c;
+    int text_lines;
 
-       text_lines = (nlines + 1) / 2; /* lines of text */
+    text_lines = (nlines + 1) / 2; /* lines of text */
 
-       clear_screen ();
+    clear_screen ();
 
-       pos_str (NUMTOPS, 1, text[0]); /* mode */
-       pos_str (NUMTOPS, 41, "See empire(6) for more information.");
+    pos_str (NUMTOPS, 1, text[0]); /* mode */
+    pos_str (NUMTOPS, 41, "See empire(6) for more information.");
 
-       for (i = 1; i < nlines; i++) {
-               if (i > text_lines)
-                       pos_str (i - text_lines + NUMTOPS + 1, 41, text[i]);
-               else pos_str (i + NUMTOPS + 1, 1, text[i]);
-       }
+    for (i = 1; i < nlines; i++) {
+       if (i > text_lines)
+           pos_str (i - text_lines + NUMTOPS + 1, 41, text[i]);
+       else pos_str (i + NUMTOPS + 1, 1, text[i]);
+    }
 
-       pos_str (text_lines + NUMTOPS + 2,  1, "--Piece---Yours-Enemy-Moves-Hits-Cost");
-       pos_str (text_lines + NUMTOPS + 2, 41, "--Piece---Yours-Enemy-Moves-Hits-Cost");
-
-       for (i = 0; i < NUM_OBJECTS; i++) {
-               if (i >= (NUM_OBJECTS+1)/2) {
-                       r = i - (NUM_OBJECTS+1)/2;
-                       c = 41;
-               }
-               else {
-                       r = i;
-                       c = 1;
-               }
-               pos_str1 (r + text_lines + NUMTOPS + 3, c,"%-12s%c     %c%6d%5d%6d",
-                       piece_attr[i].nickname,
-                       piece_attr[i].sname,
-                       tolower (piece_attr[i].sname),
-                       piece_attr[i].speed,
-                       piece_attr[i].max_hits,
-                       piece_attr[i].build_time,0,0);          //FLAG
+    pos_str (text_lines + NUMTOPS + 2,  1, "--Piece---Yours-Enemy-Moves-Hits-Cost");
+    pos_str (text_lines + NUMTOPS + 2, 41, "--Piece---Yours-Enemy-Moves-Hits-Cost");
 
+    for (i = 0; i < NUM_OBJECTS; i++) {
+       if (i >= (NUM_OBJECTS+1)/2) {
+           r = i - (NUM_OBJECTS+1)/2;
+           c = 41;
+       }
+       else {
+           r = i;
+           c = 1;
        }
-       (void) refresh ();
+       pos_str1 (r + text_lines + NUMTOPS + 3, c,"%-12s%c     %c%6d%5d%6d",
+                 piece_attr[i].nickname,
+                 piece_attr[i].sname,
+                 tolower (piece_attr[i].sname),
+                 piece_attr[i].speed,
+                 piece_attr[i].max_hits,
+                 piece_attr[i].build_time,0,0);                //FLAG
+
+    }
+    (void) refresh ();
 }
 
 #define COL_DIGITS ((MAP_WIDTH <= 100) ? 2 : ((MAP_WIDTH <= 1000 ? 3 : (1 / 0))))
@@ -405,13 +406,15 @@ help(char **text, int nlines)
 int
 loc_disp(int loc)
 {
-  int row = loc / MAP_WIDTH;
-  int nrow = row;
-  int col = loc % MAP_WIDTH;
-  ASSERT (loc == (row * MAP_WIDTH) + col);
-  int i;
-  for (i = COL_DIGITS; i > 0; i--) {
-    nrow *= 10; }
-  move (LINES - 1, 0);
-  return nrow + col;
+    int row = loc / MAP_WIDTH;
+    int nrow = row;
+    int col = loc % MAP_WIDTH;
+    ASSERT (loc == (row * MAP_WIDTH) + col);
+    int i;
+    for (i = COL_DIGITS; i > 0; i--) {
+       nrow *= 10; }
+    move (LINES - 1, 0);
+    return nrow + col;
 }
+
+/* end */
index a690b66..8944368 100644 (file)
@@ -22,75 +22,76 @@ bool awake(piece_info_t *obj);
 extern int get_piece_name(void);
 
 void
-user_move(void) {
-       void piece_move();
+user_move(void)
+{
+    void piece_move();
 
-       int i, j, sec, sec_start;
-       piece_info_t *obj, *next_obj;
-       int prod;
+    int i, j, sec, sec_start;
+    piece_info_t *obj, *next_obj;
+    int prod;
 
-       /* First we loop through objects to update the user's view
-       of the world and perform any other necessary processing.
-       We would like to have the world view up to date before
-       asking the user any questions.  This means that we should
-       also scan through all cities before possibly asking the
-       user what to produce in each city. */
+    /* First we loop through objects to update the user's view
+       of the world and perform any other necessary processing.
+       We would like to have the world view up to date before
+       asking the user any questions.  This means that we should
+       also scan through all cities before possibly asking the
+       user what to produce in each city. */
 
-       for (i = 0; i < NUM_OBJECTS; i++)
+    for (i = 0; i < NUM_OBJECTS; i++)
        for (obj = user_obj[i]; obj != NULL; obj = obj->piece_link.next) {
-               obj->moved = 0; /* nothing moved yet */
-               scan (user_map, obj->loc); /* refresh user's view of world */
+           obj->moved = 0; /* nothing moved yet */
+           scan (user_map, obj->loc); /* refresh user's view of world */
        }
 
-       /* produce new hardware */
-       for (i = 0; i < NUM_CITY; i++)
-           if (city[i].owner == USER) {
-               scan (user_map, city[i].loc);
-               prod = city[i].prod;
-
-               if (prod == NOPIECE) { /* need production? */
-                       set_prod (&(city[i])); /* ask user what to produce */
-               }
-               else if (city[i].work++ >= (long)piece_attr[prod].build_time) {
-                               /* kermyt begin */
-                       ksend("%s has been completed at city %d.\n", piece_attr[prod].article,loc_disp(city[i].loc));
-                               /* kermyt end */
-                       comment ("%s has been completed at city %d.\n", piece_attr[prod].article,loc_disp(city[i].loc));
-
-                       produce (&city[i]);
-                       /* produce should set object.moved to 0 */
-               }
+    /* produce new hardware */
+    for (i = 0; i < NUM_CITY; i++)
+       if (city[i].owner == USER) {
+           scan (user_map, city[i].loc);
+           prod = city[i].prod;
+
+           if (prod == NOPIECE) { /* need production? */
+               set_prod (&(city[i])); /* ask user what to produce */
+           }
+           else if (city[i].work++ >= (long)piece_attr[prod].build_time) {
+               /* kermyt begin */
+               ksend("%s has been completed at city %d.\n", piece_attr[prod].article,loc_disp(city[i].loc));
+               /* kermyt end */
+               comment ("%s has been completed at city %d.\n", piece_attr[prod].article,loc_disp(city[i].loc));
+
+               produce (&city[i]);
+               /* produce should set object.moved to 0 */
+           }
        }
 
-       /* move all satellites */
-       for (obj = user_obj[SATELLITE]; obj != NULL; obj = next_obj) {
-               next_obj = obj->piece_link.next;
-               move_sat (obj);
-       }
+    /* move all satellites */
+    for (obj = user_obj[SATELLITE]; obj != NULL; obj = next_obj) {
+       next_obj = obj->piece_link.next;
+       move_sat (obj);
+    }
        
-       sec_start = cur_sector (); /* get currently displayed sector */
-       if (sec_start == -1) sec_start = 0;
-
-       /* loop through sectors, moving every piece in the sector */
-       for (i = sec_start; i < sec_start + NUM_SECTORS; i++) {
-               sec = i % NUM_SECTORS;
-               sector_change (); /* allow screen to be redrawn */
-
-               for (j = 0; j < NUM_OBJECTS; j++) /* loop through obj lists */
-                       for (obj = user_obj[move_order[j]]; obj != NULL;
-                               obj = next_obj) { /* loop through objs in list */
-                               next_obj = obj->piece_link.next;
-
-                               if (!obj->moved) /* object not moved yet? */
-                                       if (loc_sector (obj->loc) == sec) /* object in sector? */
-                                               piece_move (obj); /* yup; move the object */
-                       }
-               if (cur_sector () == sec) { /* is sector displayed? */
-                       print_sector_u (sec); /* make screen up-to-date */
-                       redisplay (); /* show it to the user */
-               }
+    sec_start = cur_sector (); /* get currently displayed sector */
+    if (sec_start == -1) sec_start = 0;
+
+    /* loop through sectors, moving every piece in the sector */
+    for (i = sec_start; i < sec_start + NUM_SECTORS; i++) {
+       sec = i % NUM_SECTORS;
+       sector_change (); /* allow screen to be redrawn */
+
+       for (j = 0; j < NUM_OBJECTS; j++) /* loop through obj lists */
+           for (obj = user_obj[move_order[j]]; obj != NULL;
+          &n