home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume13 / dominion / part17 / armylib.c next >
C/C++ Source or Header  |  1992-02-11  |  21KB  |  842 lines
  1.   /* army.c -- generic, non-visual army stuff;  see also army.c */
  2.  
  3. /*
  4.  * Copyright (C) 1990 Free Software Foundation, Inc.
  5.  * Written by the dominion project.
  6.  *
  7.  * This file is part of dominion.
  8.  *
  9.  * dominion is free software; you can redistribute it and/or
  10.  * modify it under the terms of the GNU General Public License as published
  11.  * by the Free Software Foundation; either version 1, or (at your option)
  12.  * any later version.
  13.  *
  14.  * This software is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this software; see the file COPYING.  If not, write to
  21.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  */
  23.  
  24. #include "dominion.h"
  25. #include "misc.h"
  26. #include "army.h"
  27.  
  28. #include <stdio.h>
  29.  
  30.   /* army and spirit types */
  31. extern struct army_type *army_types;
  32. extern struct spirit_type *spirit_types;
  33.  
  34. extern Sworld world;
  35. extern Suser user;
  36. extern int debug;
  37. extern struct army_flags army_flags[];
  38.  
  39. Sarmy *get_army();
  40.  
  41.   /* this gets a string with the army status written
  42.      out, and flags if the army is in a magical mode
  43.    */
  44. get_army_status(ap, s)
  45.      Sarmy *ap;
  46.      char s[];
  47. {
  48.   int has_slash = 0, max_len, len ,offset, i;
  49.   char *pos, *pos2;
  50.  
  51.  
  52.   switch (ap->status) {
  53.   case A_ATTACK:
  54.     strcpy(s, "ATTACK");
  55.     break;
  56.   case A_DEFEND:
  57.     strcpy(s, "DEFEND");
  58.     break;
  59.   case A_OCCUPY:
  60.     strcpy(s, "OCCUPY");
  61.     break;
  62.   case A_PATROL:
  63.     strcpy(s, "PATROL");
  64.     break;
  65.   case A_INTERCEPT:
  66.     strcpy(s, "INTERCEPT");
  67.     break;
  68.   case A_GARRISON:
  69.     strcpy(s, "GARRISON");
  70.     break;
  71.   case A_AMBUSH:
  72.     strcpy(s, "AMBUSH");
  73.     break;
  74.   case A_TRADED:
  75.     strcpy(s, "TRADED");
  76.     break;
  77.   default:
  78.     strcpy(s, "UNKNOWN");
  79.     break;
  80.   }
  81.   for (i = 0; i < 32; i++)
  82.   {
  83.     has_slash = add_flag(s,ap->flags,i,has_slash);
  84.   }
  85.   max_len = 11;
  86.   if (ap->id < 100) max_len++;
  87.   if (ap->id < 10) max_len++;
  88.   if (ap->mvpts < 10) max_len++;
  89.  
  90.   if ((len = strlen(s)) > max_len) { 
  91.     pos = (char *)strchr(s,'/');
  92.     pos2 = s + (max_len - (len - (pos - s)));
  93.     if (pos2 <= s) pos2 = s + 1;
  94.     offset = (pos - pos2);
  95.     while (pos2 + offset <= s + len) {
  96.       *pos2 = *(pos2 + offset);
  97.       pos2++;
  98.     }
  99.   }
  100. }
  101.  
  102. add_flag(s,flags,i,has_slash)
  103. /*
  104.    This routine adds to a status line s the flag associated with
  105.    the i'th bit position in the flags, adding a slash if one has not
  106.    already been added.  The flags corresponding to the bit positions
  107.    are in ext.c in a global array.
  108. */
  109. char *s;
  110. int flags, i, has_slash;
  111. {
  112.   char s2 [2];
  113.   
  114.   if (flags & (0x1 << i)) {
  115.     if (has_slash == 0) {
  116.       strcat(s,"/");
  117.       has_slash = 1;
  118.     }
  119.     sprintf (s2, "%c", army_flags [i].flag);
  120.     strcat (s, s2);
  121.   }
  122.   return has_slash;
  123. }
  124.  
  125.   /* given a nation and an army id, find the army (or NULL
  126.      if there is no army with that id)
  127.    */
  128. Sarmy *get_army(np, id)
  129.      Snation *np;
  130.      int id;
  131. {
  132.   Sarmy *ap = np->armies;
  133.   char s[100];
  134.  
  135.   if (id == -1) {
  136.     return NULL;
  137.   }
  138.   while ((ap != NULL) && (ap->id != id)) {
  139. /*    sprintf(s, "(while) ap->id=%d,id=%d", ap->id, id);
  140.     printf("%s", s);
  141. /*     statline2(s, "get_army debug"); */
  142. /*    getch(); */
  143.  
  144.  
  145.     ap = ap->next;
  146.   }
  147. /*  sprintf(s, "(out of while) ap->id=%d,id=%d", ap ? ap->id : -1, id);
  148.   printf("%s", s);
  149. /*  statline2(s, "get_army debug"); */
  150. /*  getch(); */
  151.  
  152.   return ap;            /* should be NULL if none is found */
  153. }
  154.  
  155.   /* calculate the cost to draft an army */
  156. army_cost(ap)
  157.      Sarmy *ap;
  158. {
  159.   int index = army_type_index(ap->type);
  160.  
  161.   if (is_army(ap)) {
  162.     return ap->n_soldiers*army_types[index].money_draft;
  163.   } else {
  164.     return 0;
  165.   }
  166. }
  167.  
  168. army_cost_metal(ap)
  169.      Sarmy *ap;
  170. {
  171.   int index = army_type_index(ap->type);
  172.   if (is_army(ap)) {
  173.     return ap->n_soldiers*army_types[index].metal_draft;
  174.   } else {
  175.     return 0;
  176.   }
  177. }
  178.  
  179.   /* insert the army into the nation's army list.
  180.      if the id parameter is -1, then this function
  181.      decides where to insert it.
  182.    */
  183. insert_army_nation(np, ap, chosen_id)
  184.      Snation *np;
  185.      Sarmy *ap;
  186.      int chosen_id;
  187. {
  188.   Sarmy *alist = np->armies, *tmp = np->armies, *prev = np->armies;
  189.  
  190.   if (alist == NULL) {
  191.     return -1;
  192.   }
  193.     /* if the army id given is good, and not taken, then use it */
  194.   if (chosen_id < 0 || get_army(np, chosen_id) != NULL) {
  195.     ap->id = free_army_id(np);
  196.     if (is_in_transport(ap)) {    /* trouble!! */
  197.       printf("bad: this army is in transport, and I had to change its id\n");
  198.     }
  199.   } else {
  200.     ap->id = chosen_id;
  201.   }
  202. #ifdef WAIT_A_WHILE
  203.   /* a little touch-up to the flags to account for ships
  204.      and other things with the inverse altitude flag
  205.    */
  206.   if (ap->flags & AF_INVERSE_ALT) {
  207.     if (np->race.pref_alt >= SEA_LEVEL) {
  208.       ap->flags &= ~AF_LAND;    /* remove the land flag */
  209.       ap->flags |= AF_WATER;    /* give it water flag */
  210.     } else {
  211.       ap->flags &= ~AF_WATER;    /* remove the water flag */
  212.       ap->flags |= AF_LAND;    /* give it the land flag */
  213.     }
  214.   }
  215. #endif /* WAIT_A_WHILE */
  216.   if (alist->id > ap->id) {        /* we must insert at the start */
  217.     ap->next = alist;
  218.     np->armies = (Sarmy *) malloc(sizeof(Sarmy));
  219.     *np->armies = *ap;
  220.     return 1;
  221.   }
  222.   while ((tmp != NULL) && (tmp->id < ap->id)) {
  223.     prev = tmp;            /* keep the previous one */
  224.     tmp = tmp->next;
  225.   }
  226.   ap->next = tmp;
  227.   prev->next = (Sarmy *) malloc(sizeof(Sarmy));
  228.   *prev->next = *ap;        /* copy it on */
  229.   return 1;
  230. }
  231.  
  232.   /* remove an army from a nation list of armies (if it IS in the list!) */
  233. delete_army_nation(np, ap)
  234.      Snation *np;
  235.      Sarmy *ap;
  236. {
  237.   Sarmy *tmp = np->armies, *prev = np->armies, *alist = np->armies;
  238.  
  239.   if (tmp == NULL) {        /* special case for emtpy list */
  240.     np->n_armies = 0;
  241.     return;            /* blah, nothing to delete */
  242.   }
  243.     /* see if the army to be deleted is the head of the list */
  244.   if ((alist->owner == ap->owner) && (alist->id == ap->id)) {
  245.       /* in this special case, copy the second army to
  246.      the first, then free up the second.
  247.        */
  248.     tmp = alist->next;        /* the next one must be saved for freeing */
  249.     if (alist->next != NULL) {
  250.       *alist = *(alist->next);
  251.       free(tmp);
  252.     } else {
  253.       np->armies = NULL;
  254.       free(alist);
  255.     }
  256.     np->n_armies--;
  257.     return;
  258.   }
  259.     /* get hold of the army id we are looking for */
  260.   while ( (tmp != NULL) &&
  261.      !( (tmp->owner == ap->owner) && (tmp->id == ap->id) ) ) {
  262.     prev = tmp;            /* remember the previous element */
  263.     tmp = tmp->next;
  264.   }
  265.     /* now we have the same army, so we can remove it */
  266.   if (tmp == NULL) {
  267.     return;            /* blah, we didn't find it */
  268.   }
  269.   prev->next = tmp->next;    /* this is the crucial step:  tmp is removed */
  270.   free(tmp);            /* don't need the space */
  271.   np->n_armies--;
  272. }
  273.  
  274.   /* remove an army from a list of armies (if it IS in the list!) */
  275. delete_army_sector(sp, ap)
  276.      Ssector *sp;
  277.      Sarmy *ap;
  278. {
  279.   struct armyid *tmp = sp->alist, *prev = sp->alist;
  280.  
  281.   if (!sp->alist) {        /* if we have no armies here at all */
  282.     return;
  283.   }
  284.   /* special case it if is the first army;
  285.      also works if it is the ONLY army
  286.    */
  287.   if ((tmp->owner == ap->owner) && (tmp->id == ap->id)) {
  288.     sp->alist = sp->alist->next;
  289.     free(tmp);
  290.     return;            /* done!! */
  291.   }
  292.  
  293.   while (tmp != NULL) {
  294.     if ((tmp->owner == ap->owner) && (tmp->id == ap->id)) { /* found it! */
  295.       prev->next = tmp->next;
  296.       free(tmp);        /* free the space */
  297.       return;            /* done!! */
  298.     }
  299.     prev = tmp;
  300.     tmp = tmp->next;
  301.   }
  302. }
  303.  
  304.   /* take a sector and an army, and put the army in the sector's
  305.      army list
  306.    */
  307. insert_army_sector(sp, ap)
  308.      Ssector *sp;
  309.      Sarmy *ap;
  310. {
  311.   struct armyid *tmp;
  312.  
  313.   /* first make sure that the army is not yet in this secotr!! */
  314.   if (army_is_in_sector(sp, ap->owner, ap->id)) {
  315.     return 0;
  316.   }
  317.   if (ap->pos.x != sp->loc.x || ap->pos.y != sp->loc.y) {
  318.     printf("major error:  ap->pos != sp->loc in insert_army_sector\r\n");
  319.     refresh();
  320.   }
  321.   ap->pos = sp->loc;        /* make sure army's position is right */
  322.   if (sp->alist == NULL) {    /* special case: empty list */
  323.     sp->alist = (struct armyid *) malloc(sizeof(struct armyid));
  324.     sp->alist->owner = ap->owner;
  325.     sp->alist->id = ap->id;
  326.     sp->alist->next = NULL;
  327.     return 1;
  328.   }
  329.     /* insert at the beginning */
  330.   tmp = (struct armyid *) malloc(sizeof(struct armyid));
  331.   tmp->owner = ap->owner;
  332.   tmp->id = ap->id;
  333.   tmp->next = sp->alist;
  334.   sp->alist = tmp;        /* this is the new beginning */
  335.   return 1;
  336. }
  337.  
  338.   /* generate an army, in given sector, of
  339.      given type, with given status.  return the army.
  340.      do not add it to the nation's linked list at this point.
  341.    */
  342. Sarmy make_army(type, name, n_soldiers, status, owner, loc)
  343.      char type[], name[];
  344.      int n_soldiers, status, owner;
  345.      Pt loc;
  346. {
  347.   Sarmy new_army;
  348.   Snation *np = &world.nations[owner];
  349.   int aindex, sindex;        /* index in army/spirit type list */
  350.   struct army_type this_atype;
  351.   struct spirit_type this_stype;
  352.   Sspirit *spiritp = user.spirit_list; /* in case it is a spirit */
  353.  
  354.   aindex = army_type_index(type);
  355.   sindex = spirit_type_index(type);
  356.   if (aindex >= 0) {        /* it is an army!! */
  357.     this_atype = army_types[aindex];
  358.   } else if (sindex >= 0) {    /* it is a spirit */
  359.     this_stype = spirit_types[sindex];
  360.     while (spiritp && (strcmp(type, spiritp->type) != 0)) {
  361.       spiritp = spiritp->next;
  362.     }
  363.     if (spiritp == NULL)  {
  364.       fprintf(stderr,"Error: spirit type %s not available\n",type);
  365.     }
  366.   }
  367.  
  368.   strcpy(new_army.type, type);
  369.   strcpy(new_army.name, name);
  370.   new_army.n_soldiers = n_soldiers;
  371.   new_army.status = status;
  372.   new_army.owner = owner;
  373.   new_army.mvratio = 100;    /* 100% to start with */
  374.   new_army.pos = loc;
  375.   new_army.id = 0;       /* this is set when army is inserted into list */
  376.   new_army.flags = 0x00L;
  377.     /* when drafted, new armies have only 1/4 of full move points */
  378.   new_army.mvpts = army_move_rate(np, &new_army)/4;
  379.   if (is_army(&new_army)) {    /* case army */
  380.     new_army.sp_bonus = this_atype.bonus;
  381.     new_army.money_maint = this_atype.money_maint;
  382.     new_army.metal_maint = this_atype.metal_maint;
  383.     new_army.jewel_maint = this_atype.jewel_maint;
  384.     new_army.spell_pts_maint = this_atype.spell_pts_maint;
  385.     new_army.flags = this_atype.flags;
  386.   } else if (is_mage(&new_army)) { /* case mage */
  387.     new_army.sp_bonus = 0;
  388.     new_army.money_maint = 0;
  389.     new_army.metal_maint = 0;
  390.     new_army.jewel_maint = MAGE_JEWELS_MAINT;
  391.     new_army.spell_pts_maint = 0;
  392.   } else {            /* if not, it is a spirit */
  393.     new_army.sp_bonus = this_stype.bonus;
  394.     new_army.money_maint = 0;
  395.     new_army.metal_maint = 0;
  396.     new_army.jewel_maint = 0;
  397. /*    new_army.spell_pts_maint = this_stype.spell_pts_draft/4; */
  398.     new_army.spell_pts_maint = (spiritp->cost * 1000000)/(4* this_stype.size );
  399.     new_army.flags |= this_stype.flags;
  400.   }
  401.     /* special handling of the INVERSE_ALT flag:  if they
  402.        are a land race, it becomes a WATER flag;  if they
  403.        are a water race, it becomes a LAND flag.
  404.      */
  405.   if (new_army.flags & AF_INVERSE_ALT) {
  406.     if (np->race.pref_alt >= SEA_LEVEL) {
  407.       new_army.flags |= AF_WATER;
  408.     } else {
  409.       new_army.flags |= AF_LAND;
  410.     }
  411.   }
  412.   new_army.next = NULL;
  413.   memset(&new_army.cargo, '\0', sizeof(Scargo));
  414.   new_army.cargo.army = -1;
  415.   new_army.cargo.title.x = -1;
  416.   new_army.cargo.title.y = -1;
  417.  
  418.   return new_army;
  419. }
  420.  
  421.   /* this function tells you the basic army move rate for a nation */
  422. basic_move_rate(np)
  423.      Snation *np;
  424. {
  425.   return 4 + np->race.speed/8;    /* should not be less than 4 */
  426. }
  427.  
  428.   /* return 1 if given army can go into occupy mode, 0 otherwise */
  429. can_occupy(ap)
  430.      Sarmy *ap;
  431. {
  432.   if (ap->n_soldiers >= OCCUPYING_SOLDIERS && !is_in_transport(ap)) {
  433.     return 1;
  434.   } else {
  435.     return 0;
  436.   }
  437. }
  438.  
  439. can_patrol(ap)
  440.      Sarmy *ap;
  441. {
  442.   if (ap->n_soldiers >= OCCUPYING_SOLDIERS/2) {
  443.     return 1;
  444.   } else {
  445.     return 0;
  446.   }
  447. }
  448.  
  449. can_intercept(ap)
  450.      Sarmy *ap;
  451. {
  452.   if (ap->n_soldiers >= OCCUPYING_SOLDIERS/2) {
  453.     return 1;
  454.   } else {
  455.     return 0;
  456.   }
  457. }
  458.  
  459. can_garrison(ap)
  460.      Sarmy *ap;
  461. {
  462.   return 1;
  463. }
  464.  
  465.   /* loads army types from the army types file */
  466. load_army_types()
  467. {
  468.   FILE *fp, *fopen();
  469.   char line[210];
  470.   int i;
  471.  
  472.   if ((fp = fopen(ARMY_TYPES_FILE, "r")) == NULL) {
  473.     printf("cannot open army types file.  quitting.\n");
  474.     clean_exit();
  475.     exit(1);
  476.   }
  477.  
  478.   do {
  479.     fgets(line, 200, fp);
  480.   } while (line[0] == '#');
  481.     /* we should have the line with the number of army types in file */
  482.   sscanf(line, "%d", &user.n_army_types);
  483.  
  484.   army_types =
  485.     (struct army_type *)malloc(user.n_army_types*sizeof(struct army_type));
  486.  
  487.   for (i = 0; i < user.n_army_types; ) {
  488.     fgets(line, 100, fp);
  489.     line[strlen(line)-1] = '\0';
  490.     if (line[0] != '#') {        /* ignore comments */
  491.       sscanf(line,
  492.           "%s : %1s : %f : %d : %d : %d : %d : %d : %d : %d : %d : %s",
  493.          army_types[i].type, &army_types[i].type_char,
  494.          &army_types[i].move_factor,
  495.          &army_types[i].bonus, &army_types[i].money_draft,
  496.          &army_types[i].metal_draft, &army_types[i].jewel_draft,
  497.          &army_types[i].money_maint,
  498.          &army_types[i].metal_maint, &army_types[i].jewel_maint,
  499.          &army_types[i].flags,
  500.          army_types[i].draft_places);
  501.       army_types [i].spell_pts_maint = 0; /* Kludge, but ALWAYS so... */
  502.       ++i;
  503.     }
  504.   }
  505.  
  506.   fclose(fp);
  507. }
  508.  
  509.   /* returns true if this nation can draft that type of army */
  510. is_avail_army_type(up, type)
  511.      Suser *up;
  512.      char type[];
  513. {
  514.   int i;
  515.   Savail_army *aa;
  516.  
  517.     /* run through the list of available armies */
  518.   for (aa = up->avail_armies; aa != NULL; aa = aa->next) {
  519.     if (strncmp(aa->type, type, NAMELEN) == 0) {
  520.       return 1;            /* got it!!! */
  521.     }
  522.   }
  523.   return 0;            /* we did not find that army type */
  524. }
  525.  
  526.   /* returns the index in army_types, corresponding to
  527.      an army type, or -1 on error (if it is not an army
  528.      but, say, a caravan or spirit or mage).
  529.    */
  530. army_type_index(type)
  531.      char type[];
  532. {
  533.   int i;
  534.   for (i = 0; i < user.n_army_types; ++i) {
  535.     if (strncmp(army_types[i].type, type, NAMELEN) == 0) {
  536.       return i;            /* got it!! */
  537.     }
  538.   }
  539.   return -1;            /* didn't find it */
  540. }
  541.  
  542.   /* returns the index in spirit_types, corresponding to
  543.      an army type, or -1 on error (if it is not an army
  544.      but, say, a caravan or army or mage).
  545.    */
  546. spirit_type_index(type)
  547.      char type[];
  548. {
  549.   int i;
  550.   for (i = 0; i < user.n_spirit_types; ++i) {
  551.     if (strncmp(spirit_types[i].type, type, NAMELEN) == 0) {
  552.       return i;            /* got it!! */
  553.     }
  554.   }
  555.   return -1;            /* did not get it */
  556. }
  557.  
  558.   /* returns 1 if it is an army (not a navy), 0 otherwise */
  559. is_army(ap)
  560.      Sarmy *ap;
  561. {
  562.   if (army_type_index(ap->type) >= 0) {
  563.     return 1;
  564.   }
  565.   return 0;
  566. }
  567.  
  568.   /* returns 1 if it is a ship, 0 otherwise */
  569. is_navy(ap)
  570.      Sarmy *ap;
  571. {
  572.     /* any army type beginning with "Ships" or "S_" is a navy */
  573.   if (ap && strncmp(ap->type, "S_", strlen("S_")) == 0) {
  574.     return 1;
  575.   }
  576.   if (ap && strncmp(ap->type, "Ships", strlen("Ships")) == 0) {
  577.     return 1;
  578.   }
  579.   return 0;
  580. }
  581.  
  582.   /* returns 1 if it is an mage, 0 otherwise */
  583. is_mage(ap)
  584.      Sarmy *ap;
  585. {
  586.   if (ap && (strcmp(ap->type, "Mage") == 0 || is_wizard(ap))) {
  587.     return 1;
  588.   }
  589.   return 0;
  590. }
  591.  
  592.   /* returns 1 if it is an spirit, 0 otherwise */
  593. is_spirit(ap)
  594.      Sarmy *ap;
  595. {
  596.   if (spirit_type_index(ap->type) >= 0) {
  597.     return 1;
  598.   }
  599.   return 0;
  600. }
  601.  
  602.   /* returns the army move rate for a specific army */
  603. army_move_rate(np, ap)
  604.      Snation *np;
  605.      Sarmy *ap;
  606. {
  607.   int mvpts, i;
  608.  
  609.   if (is_army(ap)) {
  610.     i = army_type_index(ap->type);
  611.     mvpts = basic_move_rate(np)*army_types[i].move_factor;
  612.   } else if (is_mage(ap)) {
  613.     mvpts = basic_move_rate(np)*MAGE_MOVE_FACTOR;
  614.   } else {            /* must be a spirit */
  615.     if ((i = spirit_type_index(ap->type)) < 0) {
  616.       printf(
  617.     "army_move_rate:  bad error, can't find army type <%s> for army %d.\n",
  618.          ap->type, ap->id);
  619.       printf("setting move rate to basic.\n");
  620.       mvpts = basic_move_rate(np);
  621.     } else {
  622.       mvpts = basic_move_rate(np)*spirit_types[i].move_factor;
  623.     }
  624.   }
  625.   return mvpts;
  626. }
  627.  
  628.   /* check if a army "id" belonging to owner "owner" is in "sp: */
  629. army_is_in_sector(sp, owner, id)
  630.      Ssector *sp;
  631.      int owner, id;        /* owner and id of army we are testing */
  632. {
  633.   struct armyid *alist = sp->alist;
  634.  
  635.   while (alist != NULL) {
  636.     if (alist->id == id && alist->owner == owner) {
  637.       return 1;
  638.     }
  639.     alist = alist->next;
  640.   }
  641.   return 0;
  642. }
  643.  
  644.   /* reads in the NEW_ARMY_TYPE lines from the techno_levels
  645.      file, and adds them to the user's list of available army
  646.      types if the user has enough techno skill to deserve them.
  647.      Some of the available army types also come from the "races"
  648.      file, since they are race-specific.
  649.    */
  650. get_avail_armies(up, skill)
  651.      Suser *up;
  652.      int skill;
  653. {
  654.   FILE *fp, *fopen();
  655.   int level;
  656.   char type[NAMELEN], name[NAMELEN], line[EXECLEN];
  657.   char magfn [EXECLEN];
  658.   int done = 0;
  659.  
  660.   if ((fp = fopen(TECHNO_FILE, "r")) == NULL) {
  661.     printf("could not open technology file %s\n", TECHNO_FILE);
  662.     return -1;
  663.   }
  664.  
  665.   while (!done) {
  666.     if (fgets(line, EXECLEN, fp) == NULL) {
  667.       done = 1;
  668.       break;
  669.     }
  670.     if (line[0] != '#') {
  671.       sscanf(line, "%s%d", name, &level); /* a new tech entry */
  672.       if (level <= skill) {
  673.     do {
  674.       fgets(line, EXECLEN, fp);
  675.       if (strncmp(line+2,"NEW_ARMY_TYPE:",strlen("NEW_ARMY_TYPE:")) == 0) {
  676.         add_army_type(up, line+2+strlen("NEW_ARMY_TYPE:"));
  677.       }
  678.     } while (strncmp(line, "end", strlen("end")) != 0);
  679.       } else {            /* else, we are beyond our skill */
  680.     done = 1;
  681.     break;
  682.       }
  683.     }
  684.   }
  685.   fclose(fp);
  686.  
  687.   /* Get the magic orders special armies in there too */
  688.  
  689.   sprintf (magfn, "magic/mag_%s", up->np->mag_order);
  690.   if ((fp = fopen (magfn, "r")) == NULL) {
  691.     printf ("could not open magic file %s\n", magfn);
  692.     return -1;
  693.   }
  694.  
  695.   done = 0;
  696.   while (!done) {
  697.     if (fgets (line, EXECLEN, fp) == NULL) {
  698.       done = 1;
  699.       break;
  700.     }
  701.     if (strncmp(line,"EXEC:NEW_ARMY_TYPE:",strlen("NEW_ARMY_TYPE:")) == 0) {
  702.       add_army_type(up, line+strlen("EXEC:NEW_ARMY_TYPE:"));
  703.     }
  704.   }
  705.  
  706.     /* get race-specific army types. for now there is
  707.        only one army type for each race.
  708.      */
  709.   if ((fp = fopen(RACES_FILE, "r")) == NULL) {
  710.     printf("could not open races file %s\n", RACES_FILE);
  711.     return -1;
  712.   }
  713.   done = 0;
  714.   while (!done) {
  715.     if (fgets(line, EXECLEN, fp) == NULL) {
  716.       done = 1;
  717.       break;
  718.     }
  719.     if (strncmp(line, up->np->race.name, strlen(up->np->race.name)) == 0
  720.     && strncmp(line+strlen(up->np->race.name), "_armies:",
  721.            strlen("_armies:")) == 0) {
  722.       /* got one!!  in the next line we assume there
  723.      is just one army type for each race.
  724.        */
  725.       add_army_type(up, strchr(line, ':')+1);
  726.     }
  727.   }
  728.   fclose(fp);
  729. }
  730.  
  731.   /* add an army type to the user's list */
  732. add_army_type(up, type)
  733.      Suser *up;
  734.      char type[];
  735. {
  736.   Savail_army *aa = up->avail_armies, *prev_aa = up->avail_armies;
  737.   int falready = 0;
  738.   if (type[strlen(type)-1] == '\n') {
  739.     type[strlen(type)-1] = '\0';
  740.   }
  741.   if (debug) {
  742.     printf("adding army type: <%s>; type return\n", type);
  743.     fflush(stdout);
  744.     getchar();
  745.   }
  746.   if (aa == NULL) {        /* if list is empty... */
  747.     up->avail_armies = (Savail_army *)malloc(sizeof(Savail_army));
  748.     aa = up->avail_armies;
  749.     strcpy(aa->type, type);
  750.     aa->next = NULL;
  751.     return;
  752.   }
  753.   while (aa != NULL) {        /* else, find end of list */
  754.     if (!strcmp (aa->type, type)) { /* If army type already in there... */
  755.       falready = 1;
  756.       break;
  757.     }
  758.     prev_aa = aa;
  759.     aa = aa->next;
  760.   }
  761.   if (!falready) {
  762.     prev_aa->next = (Savail_army *)malloc(sizeof(Savail_army));
  763.     strcpy(prev_aa->next->type, type);
  764.     prev_aa->next->next = NULL;
  765.   }
  766. }
  767.  
  768. sect_n_armies(sp)
  769.      Ssector *sp;
  770. {
  771.   int n = 0;
  772.   struct armyid *alist = sp->alist;
  773.  
  774.   while (alist != NULL) {
  775.     ++n;
  776.     alist = alist->next;
  777.   }
  778.   return n;
  779. }
  780.  
  781.   /* returns a pointer to the first mage found in a nation */
  782. Sarmy *get_first_mage(np)
  783.      Snation *np;
  784. {
  785.   Sarmy *tmp_ap = np->armies;
  786.  
  787.   while (tmp_ap) {
  788.     if (is_mage(tmp_ap)) {
  789.       return tmp_ap;
  790.     }
  791.     tmp_ap = tmp_ap->next;
  792.   }
  793.   return tmp_ap;
  794. }
  795.  
  796.   /* returns the id of the first mage belonging
  797.      to a given nation, found in a given sector.
  798.      returns -1 if there is no mage there.
  799.    */
  800. first_sect_mage_id(np, sp)
  801.      Snation *np;
  802.      Ssector *sp;
  803. {
  804.   struct armyid *alist = sp->alist;
  805.   Sarmy *ap;
  806.  
  807.   while (alist) {
  808.     ap = get_army(np, alist->id);
  809.     if (is_mage(ap)) {
  810.       return alist->id;
  811.     }
  812.     alist = alist->next;
  813.   }
  814.   return -1;
  815. }
  816.  
  817.   /* returns the apparent army type for a disguised army */
  818. get_apparent_type(ap, type)
  819.      Sarmy *ap;
  820.      char type[];
  821. {
  822.   char *pos;
  823.  
  824.   if (is_disguised(ap)) {
  825.     pos = (char *)strrchr(ap->name, '/');
  826.     if (pos == NULL) {
  827.       strcpy(type, ap->type);
  828.     } else {
  829.       strcpy(type, pos+1);    /* disguised type is stored in ap->name */
  830.     }
  831.   } else {
  832.     strcpy(type, ap->type);    /* no disguise: army is itself */
  833.   }
  834. }
  835.  
  836. get_spell_pts_maint(ap)
  837.   Sarmy *ap;
  838. {
  839.  
  840.   return (int)(((double)(ap->spell_pts_maint* ap->n_soldiers)/1000000.0)+0.49);
  841. }
  842.