home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume13 / dominion / part18 / nation.c < prev    next >
C/C++ Source or Header  |  1992-02-11  |  29KB  |  1,158 lines
  1. /* nation.c -- commands needed to remember changes to a nation;
  2.                basically a lot of routines to parse the exec file
  3.  */
  4.  
  5. /*
  6.  * Copyright (C) 1990 Free Software Foundation, Inc.
  7.  * Written by the dominion project.
  8.  *
  9.  * This file is part of dominion.
  10.  *
  11.  * dominion is free software; you can redistribute it and/or
  12.  * modify it under the terms of the GNU General Public License as published
  13.  * by the Free Software Foundation; either version 1, or (at your option)
  14.  * any later version.
  15.  *
  16.  * This software is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this software; see the file COPYING.  If not, write to
  23.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  24.  */
  25.  
  26. #include "dominion.h"
  27. #include "misc.h"
  28. #include "army.h"
  29. extern Sworld world;
  30. extern int debug;
  31. #include <stdio.h>
  32. #include <ctype.h>
  33.  
  34. struct exec_cmd { char name[NAMELEN]; int (*func)(); };
  35.  
  36. int cmd_amove(), cmd_astat(), cmd_aflag_set(), cmd_aflag_clear(),
  37.   cmd_flag_set_sector(), cmd_flag_clear_sector(),
  38.   cmd_acargo(), cmd_sname(),  cmd_aname(), cmd_charity(),
  39.   cmd_taxrate(), cmd_desig_sector(), cmd_amake(),
  40.   cmd_cpeople_sector(), cmd_cowner_sector(), cmd_csoil_sector(),
  41.   cmd_cmetal_sector(), cmd_cjewels_sector(), cmd_caltitude_sector(),
  42.   cmd_cmoney(), cmd_cmetal(), cmd_cjewels(),
  43.   cmd_cur_tech_money (), cmd_cur_mag_money (), cmd_cur_mag_jewels (),
  44.   cmd_cur_tech_metal (),
  45.   cmd_cur_spy_money (),
  46.   cmd_cspell_pts(), cmd_ctech_skill(), cmd_cmag_skill(),
  47.   cmd_cfood(), cmd_tech_money(), cmd_tech_metal(),
  48.   cmd_spy_money(),
  49.   cmd_mag_money(), cmd_mag_jewels(), cmd_cmine(), cmd_cfarm(),
  50.   cmd_cspeed(), cmd_nation_name(), cmd_nation_leader(), cmd_nation_order(),
  51.   cmd_nation_mark(), cmd_set_npc(), cmd_clear_npc(), cmd_npc_param(),
  52.   cmd_ccombat(), cmd_cattack(), cmd_cdefense(), cmd_crepro(), cmd_cmortality(),
  53.   cmd_cintel(), cmd_cmag_apt(), cmd_cstrength(),
  54.   cmd_new_army_type(), cmd_aincrease(), cmd_amerge(), cmd_asplit(),
  55.   cmd_adisband(),
  56.   cmd_cabonus(), cmd_cfort_sector(), cmd_croads_sector(), cmd_cpass(),
  57.   cmd_destroy(), cmd_acastle ();
  58.  
  59. static struct exec_cmd commands[] = {
  60.   {"AMOVE", cmd_amove} , {"ASTAT", cmd_astat} , {"AMAKE", cmd_amake} ,
  61.   {"AFLAG_SET", cmd_aflag_set} , {"AFLAG_CLEAR", cmd_aflag_clear} ,
  62.   {"FLAG_SET_SECTOR", cmd_flag_set_sector} ,
  63.   {"FLAG_CLEAR_SECTOR", cmd_flag_clear_sector} ,
  64.   {"ACARGO", cmd_acargo} ,
  65.   {"SNAME", cmd_sname} , {"ANAME", cmd_aname},
  66.   {"DESIG_SECTOR", cmd_desig_sector} ,
  67.   {"CHARITY", cmd_charity} , {"TAXRATE", cmd_taxrate},
  68.   {"CMONEY", cmd_cmoney} , {"CJEWELS", cmd_cjewels}, {"CMETAL", cmd_cmetal},
  69.   {"CUR_MAGR&Dmoney", cmd_cur_mag_money},
  70.   {"CUR_TECHR&Dmoney", cmd_cur_tech_money},
  71.   {"CUR_TECHR&Dmetal", cmd_cur_tech_metal},
  72.   {"CUR_MAGR&Djewels", cmd_cur_mag_jewels},
  73.   {"CUR_SPYR&Dmoney", cmd_cur_spy_money},
  74.   {"CSPELL_PTS", cmd_cspell_pts}, {"CTECH_SKILL", cmd_ctech_skill} ,
  75.   {"CMAG_SKILL", cmd_cmag_skill} ,
  76.   {"CFOOD", cmd_cfood} , {"TECHR&Dmoney", cmd_tech_money} ,
  77.   {"TECHR&Dmetal", cmd_tech_metal} , {"SPYR&Dmoney", cmd_spy_money} ,
  78.   {"MAGR&Dmoney" , cmd_mag_money} , {"MAGR&Djewels" , cmd_mag_jewels} ,
  79.   {"CMINE" , cmd_cmine} , {"CFARM" , cmd_cfarm} , {"CSPEED", cmd_cspeed} ,
  80.   {"NATION_NAME", cmd_nation_name} , {"NATION_LEADER", cmd_nation_leader} ,
  81.   {"NATION_ORDER", cmd_nation_order} , {"NATION_MARK", cmd_nation_mark} ,
  82.   {"SET_NPC", cmd_set_npc} , {"CLEAR_NPC", cmd_clear_npc} ,
  83.   {"NPC_PARAM", cmd_npc_param} ,
  84.   {"CATTACK" , cmd_cattack} , {"CDEFENSE" , cmd_cdefense} , {"CCOMBAT" , cmd_ccombat} ,
  85.   {"CREPRO" , cmd_crepro} , {"CINTEL", cmd_cintel} ,
  86.   {"CMAG_APT", cmd_cmag_apt} , {"CSTRENGTH", cmd_cstrength} ,
  87.   {"CMORTALITY" , cmd_cmortality} , {"CPEOPLE_SECTOR" , cmd_cpeople_sector} ,
  88.   {"COWNER_SECTOR" , cmd_cowner_sector} , {"CSOIL_SECTOR", cmd_csoil_sector} ,
  89.   {"CMETAL_SECTOR", cmd_cmetal_sector} ,
  90.   {"CJEWELS_SECTOR", cmd_cjewels_sector} ,
  91.   {"CALTITUDE_SECTOR", cmd_caltitude_sector} ,
  92.   {"NEW_ARMY_TYPE", cmd_new_army_type} , {"AMERGE", cmd_amerge} ,
  93.   {"AINCREASE", cmd_aincrease},
  94.   {"ASPLIT", cmd_asplit} , {"ADISBAND", cmd_adisband} ,
  95.   {"CABONUS", cmd_cabonus} ,
  96.   {"CFORT_SECTOR", cmd_cfort_sector} , {"CROADS_SECTOR", cmd_croads_sector} ,
  97.   {"CPASS", cmd_cpass} , {"DESTROY", cmd_destroy},
  98.   {"ACASTLE", cmd_acastle}
  99. };
  100.  
  101.  
  102. /*******************************************************/
  103. /* gets nation data for nation 'id', put it into '*np' */
  104. /* takes in an integer nation id, and a pointer to a   */
  105. /* nation structure.                                   */
  106. /*******************************************************/
  107. load_nation(id, np)
  108.      int id;
  109.      Snation *np;
  110. {
  111.   FILE *exec_file;
  112.   struct argument args[N_EXEC_ARGS];
  113.   char filename[NAMELEN];
  114.   int argc, i;
  115.   extern Suser user;
  116.  
  117.   *np = world.nations[id];
  118.   user.np = np;        /* hmm.. must cleanup use of "Suser" in update */
  119.     /* remember what the initial values were, before reading the exec file */
  120.   user.init_money = user.np->money;
  121.   user.init_metal = user.np->metal;
  122.   user.init_jewels = user.np->jewels;
  123.   user.init_food = user.np->food;
  124.   user.id = np->id;
  125.   load_options(np);
  126.  
  127.   sprintf(filename, "exec/exec%d", np->id);
  128.   exec_file = fopen(filename, "r");
  129.   if (!exec_file && np->npc_flag == 0) {
  130.     fprintf(stderr, "Nation %d (%s) did not move this turn.\n", np->id, np->name); }
  131.   else {
  132.     while (argc = getexec(exec_file, args) != -1) {
  133.       run_exec_line(np, args);
  134.     }
  135.     if (exec_file != NULL) { fclose(exec_file); }
  136.   }
  137. }
  138.  
  139. /****************************************************************/
  140. /* this takes a pointer to the exec file and a pointer to an    */
  141. /* array of argument structures.  The structures are filled in  */
  142. /* with the arguments of the next line of the file.  The        */
  143. /* function returns an integer which is the number of arguments */
  144. /****************************************************************/
  145. int getexec(fp, args)
  146. FILE *fp;
  147. struct argument args[];
  148. {
  149.   char buff[EXECLEN];
  150.   if (fp == NULL) {
  151.     return (-1);
  152.   }
  153.   if (fgets(buff, EXECLEN, fp) != NULL) {
  154.     parse_exec_line(buff, args);
  155.   }
  156.   else return(-1);
  157. }
  158.  
  159.  
  160.  
  161.   /* this takes the exec line args (already parsed) and runs it */
  162. run_exec_line(np, args)
  163.      Snation *np;
  164.      struct argument args[];
  165. {
  166.   int i, found = 0;
  167.  
  168.   for (i=0; i < sizeof(commands)/sizeof(struct exec_cmd); i++) {
  169.     if (!(strcmp(commands[i].name, args[0].data.str))) {
  170.       found = 1;
  171.       (*commands[i].func)(np, args);
  172.     }
  173.   }
  174.   if (!found) {
  175.     printf("Error: exec command <%s> not implemented\n", args[0].data.str);
  176.   }
  177. }
  178.  
  179. #ifdef AMIGA
  180. #define sscanf sscanf2
  181. sscanf2(data, terminate, result)
  182.      char *data, *terminate, *result;
  183. {
  184.   int i;
  185.   
  186.   terminate += 3;
  187.   for (;;) {
  188.     for (i=0; i<strlen(terminate); i++)
  189.       if (*data == terminate[i]) return;
  190.     *result = *data;
  191.     data++;
  192.     result++;
  193.     *result = '\0';
  194.   }
  195. }
  196. #endif
  197.  
  198.  
  199.   /* this parses a single exec line */
  200. parse_exec_line(line, args)
  201.      char line[];
  202.      struct argument args[];
  203. {
  204.   char cmd_str[NAMELEN], arg_tmp[NAMELEN];
  205.   int count = 0, place;
  206.  
  207.     /* make sure there is a newline at the end of this line */
  208.   if (line[strlen(line)-1] != '\n') {
  209.     line[strlen(line)+1] = '\0'; /* extend the string */
  210.     line[strlen(line)] = '\n'; /* put the newline in */
  211.   }
  212.   sscanf(line, "%[^:]", args[0].data.str);
  213.   place = strlen(args[0].data.str)+1;
  214.   args[0].type = TXT;
  215.   do {
  216.     sscanf(&line[place], "%[^:\n]", arg_tmp);
  217.     place += strlen(arg_tmp)+1;
  218.     count++;
  219.     if (isdigit(arg_tmp[0]) || (arg_tmp[0] == '-')) {
  220.       args[count].type = NUM;
  221.       args[count].data.num = atoi(arg_tmp);
  222.     }
  223.     else {
  224.       args[count].type = TXT;
  225.       strcpy(args[count].data.str, arg_tmp);
  226.     }
  227.   } while (place+1 < strlen(line));
  228.   return(count);
  229. }
  230.  
  231.  
  232.  
  233. /******************************************************************/
  234. /* this takes the name of a nation (a pointer to an array of      */
  235. /* characters) and returns the id number of that nation.          */
  236. /******************************************************************/
  237. int get_nation_id(name)        /* finds id, given name */
  238.      char name[];
  239. {
  240.   int i;
  241.  
  242.   for (i = 0; i < world.n_nations; ++i) {
  243.     if (!strcmp(world.nations[i].name, name)) {
  244.       return i;        /* found it! */
  245.     }
  246.   }
  247.   return -1;            /* it's not there */
  248. }
  249.  
  250.   /* rename a sector */
  251. cmd_sname(np, args)
  252.      Snation *np;
  253.      struct argument args[];
  254. {
  255.   int x, y;
  256.   char name[NAMELEN];
  257.  
  258.   x = args[1].data.num;
  259.   y = args[2].data.num;
  260.   strcpy (name, args[3].data.str);
  261.   
  262.   if (debug) printf ("Naming sector %d,%d as %s.\n", x, y, name); 
  263.   strcpy(world.map[x][y].name, name);
  264. }
  265.  
  266.   /* rename an army */
  267. cmd_aname(np, args)
  268.      Snation *np;
  269.      struct argument args[];
  270. {
  271.   int id;
  272.   char *name;
  273.   Sarmy *ap, *get_army();
  274.  
  275.   id = args[1].data.num;
  276.   name = args[2].data.str;
  277.   
  278.   if (ap = get_army(np, id)) {
  279.     if (debug) printf ("Naming army %d as %s.\n", id, name);
  280.     strcpy(ap->name, name);
  281.   } else {
  282.     printf("funny:  cannot find army %d\n", id);
  283.   }
  284. }
  285.  
  286.  
  287. /* Move an army... change it's move points to the move points left, which
  288.    is given in the exec string. */
  289. cmd_amove(np, args)
  290.      Snation *np;
  291.      struct argument args[];
  292. {
  293.   Sarmy *armypt;
  294.   Ssector *sp;
  295.   int a, x, y, fm;
  296.   
  297.   a = args[1].data.num;        /* army number */
  298.   x = args[2].data.num;        /* new x coordinate */
  299.   y = args[3].data.num;        /* new y coordinate */
  300.   fm = args[4].data.num;    /* final moves */
  301.   armypt = np->armies;
  302.   while (armypt->id != a && armypt->next != NULL) armypt = armypt->next;
  303.   if (armypt->id == a) {
  304.     if (debug) {
  305.       printf ("Moving army %d from %d,%d to %d,%d\n", a, armypt->pos.x,
  306.         armypt->pos.y, x, y);
  307.     }
  308.     sp = &(world.map[armypt->pos.x][armypt->pos.y]);
  309.     delete_army_sector(sp, armypt);
  310.  
  311.     armypt->pos.x = x;
  312.     armypt->pos.y = y;
  313.     armypt->mvpts = fm;
  314.     sp = &(world.map[x][y]);
  315.     insert_army_sector(sp, armypt);
  316.   }
  317.   else printf ("Error! Could not find army!\n"); 
  318. }
  319.  
  320.  
  321. /* Change status of an army... if the army is being changed to OCCUPY mode,
  322.    and it is _already_ in occupy mode, DO NOT change it's move ratio!
  323.    Otherwise set the move ratio, change the moves left to zero, and
  324.    change the status. */
  325. cmd_astat(np, args)
  326.      Snation *np;
  327.      struct argument args[];
  328. {
  329.   int a, s;
  330.   Sarmy *armypt, *get_army();
  331.   
  332.   a = args[1].data.num;
  333.   s = args[2].data.num;
  334.   if (debug) printf ("Changing status of army %d to %d\n", a, s);
  335.   armypt = get_army(np, a);
  336.   if (armypt) {
  337.     if (s == A_OCCUPY && armypt->status != A_OCCUPY) {
  338.       armypt->mvratio =
  339.     (int)(100 * (float)(armypt->mvpts) / basic_move_rate(np) );
  340.       armypt->mvpts = 0;
  341.     }
  342.     armypt->status = s;
  343.   } else {
  344.     printf("Trying to change status on army %d which does not exist\n", a);
  345.   }
  346. }
  347.  
  348.   /* Set/clear a flag of an army, such as AF_HIDDEN, AF_FLIGHT and so on... */
  349. cmd_aflag_set(np, args)
  350.      Snation *np;
  351.      struct argument args[];
  352. {
  353.   int id, flag;
  354.   Sarmy *armypt, *get_army();
  355.   
  356.   id = args[1].data.num;
  357.   flag = args[2].data.num;
  358.   if (debug) printf ("Setting bit %x of army %d\n", flag, id);
  359.   if (armypt = get_army(np, id)) {
  360.     armypt->flags |= flag;
  361.   }
  362. }
  363.  
  364. cmd_aflag_clear(np, args)
  365.      Snation *np;
  366.      struct argument args[];
  367. {
  368.   int id, flag;
  369.   Sarmy *armypt, *get_army();
  370.   
  371.   id = args[1].data.num;
  372.   flag = args[2].data.num;
  373.   if (debug) printf ("Clearing bit %x of army %d\n", flag, id);
  374.   if (armypt = get_army(np, id)) {
  375.     armypt->flags &= ~flag;
  376.   }
  377. }
  378.  
  379.   /* Set/clear a flag of a sector, such as SF_HIDDEN, SF_BUBBLE and so on... */
  380. cmd_flag_set_sector(np, args)
  381.      Snation *np;
  382.      struct argument args[];
  383. {
  384.   int x, y, flag;
  385.   Ssector *sp;
  386.   
  387.   x = args[1].data.num;
  388.   y = args[2].data.num;
  389.   flag = args[3].data.num;
  390.   sp = &world.map[x][y];
  391.   sp->flags |= flag;
  392. }
  393.  
  394. cmd_flag_clear_sector(np, args)
  395.      Snation *np;
  396.      struct argument args[];
  397. {
  398.   int x, y, flag;
  399.   Ssector *sp;
  400.   
  401.   x = args[1].data.num;
  402.   y = args[2].data.num;
  403.   flag = args[3].data.num;
  404.   sp = &world.map[x][y];
  405.   sp->flags &= ~flag;
  406. }
  407.  
  408.   /* Change cargo of an army */
  409. cmd_acargo(np, args)
  410.      Snation *np;
  411.      struct argument args[];
  412. {
  413.   int id;
  414.   Sarmy *armypt, *get_army();
  415.   
  416.   id = args[1].data.num;
  417.  
  418.   if (debug) printf ("Changing cargo of army %d\n", id);
  419.   if ((armypt = get_army(np, id)) != NULL) {
  420.     armypt->cargo.money = args[2].data.num;
  421.     armypt->cargo.metal = args[3].data.num;
  422.     armypt->cargo.jewels = args[4].data.num;
  423.     armypt->cargo.food = args[5].data.num;
  424.     armypt->cargo.people = args[6].data.num;
  425.     armypt->cargo.army = args[7].data.num;
  426.     armypt->cargo.title.x = args[8].data.num;
  427.     armypt->cargo.title.y = args[9].data.num;
  428.   } else {
  429.     printf("[%s] Could not find army %d, nation %d\n", args[0].data.str,
  430.        id, np->id);
  431.   }
  432. }
  433.  
  434. cmd_taxrate(np, args)
  435.      struct argument args[];
  436.      Snation *np;
  437. {
  438.   int t;
  439.  
  440.   t = args[1].data.num;  
  441.   if (debug) printf ("Taxes changed from %d to %d.\n", np->taxes, t);
  442.   np->taxes = t;
  443. }
  444.  
  445.  
  446.  
  447. cmd_charity(np, args)
  448.      Snation *np;
  449.      struct argument args[];
  450. {
  451.   int c;
  452.   
  453.   c = args[1].data.num;
  454.   if (debug) printf ("Charity changed from %d to %d.\n", np->charity, c);
  455.   np->charity = c;
  456. }
  457.  
  458.  
  459. cmd_desig_sector(np, args)
  460.      Snation *np;
  461.      struct argument args[];
  462. {
  463.   int x, y, d;
  464.   Snation *owner_np;
  465.  
  466.   x = args[1].data.num;
  467.   y = args[2].data.num;
  468.   d = args[3].data.num;        /* the new designation */
  469.   owner_np = &world.nations[world.map[x][y].owner];
  470.   if (debug) printf ("Redesignating %d,%d to %d.\n", x, y, d);
  471.   world.map[x][y].designation = d;
  472.     /* special case for capital: */
  473.   if (d == D_CAPITAL) {
  474.     owner_np->capital.x = x;    /* make sure Gamemaster does not get it */
  475.     owner_np->capital.y = y;
  476.   }
  477. }
  478.  
  479.  
  480. cmd_amake(np, args)
  481.      Snation *np;
  482.      struct argument args[];
  483. {
  484.   Sarmy army, make_army();
  485.   Ssector *sp;
  486.   int a, no_sold, x, y;
  487.   char *type, *name;
  488.   
  489.   a = args[1].data.num;        /* army number */
  490.   no_sold = args[2].data.num;    /* number of soldiers drafted */
  491.   x = args[3].data.num;        /* x coordinate where army is drafted */
  492.   y = args[4].data.num;        /* y coordinate where army is drafted */
  493.   type = args[5].data.str;    /* army type */
  494.   name = args[6].data.str;    /* army name */
  495.  
  496.   sp = &(world.map[x][y]);
  497.   army = make_army(type,name,no_sold,A_DEFEND,np->id,sp->loc);
  498. /*  army.id  = free_army_id(np); */
  499.   army.id = a;
  500.   army.next = NULL;
  501.  
  502.   if (debug) printf("Permanently drafting army #%d\n",army.id);
  503.   if (np->armies == NULL) {
  504.     np->armies = (Sarmy *) malloc(sizeof(Sarmy));
  505.     *(np->armies) = army;
  506.   } else {
  507.     insert_army_nation(np, &army, a);
  508.   }
  509.   insert_army_sector(sp, &army);
  510.   ++np->n_armies;
  511. }
  512.  
  513. cmd_cmoney(np, args)
  514.      Snation *np;
  515.      struct argument args[];
  516. {
  517.   int change, nat_id;
  518.  
  519.   nat_id = args[1].data.num;
  520.   change = args[2].data.num;    /* changed money */
  521.   np = &world.nations[nat_id];
  522.      
  523.   np->money = np->money + change;
  524.   if (debug) printf("New nation money (after difference of %d) = %d\n",
  525.      change,np->money);
  526. }
  527.  
  528. cmd_cmetal(np, args)
  529.      Snation *np;
  530.      struct argument args[];
  531. {
  532.   int change, nat_id;
  533.  
  534.   nat_id = args[1].data.num;
  535.   change = args[2].data.num;   /* changed money */
  536.   np = &world.nations[nat_id];
  537.   
  538.   np->metal = np->metal + change;
  539.   if (debug) printf("New nation metal (after difference %d) = %d\n",
  540.      change,np->metal);
  541. }
  542.  
  543. cmd_cjewels(np, args)
  544.      Snation *np;
  545.      struct argument args[];
  546. {
  547.   int change, nat_id;
  548.  
  549.   nat_id = args[1].data.num;
  550.   change = args[2].data.num;   /* changed money */
  551.   np = &world.nations[nat_id];
  552.   
  553.   np->jewels = np->jewels + change;
  554.   if (debug) printf("New nation jewel (after difference %d) = %d\n",
  555.      change,np->jewels);
  556. }
  557.  
  558. cmd_cspell_pts(np, args)
  559.      Snation *np;
  560.      struct argument args[];
  561. {
  562.   int change, nat_id;
  563.  
  564.   nat_id = args[1].data.num;
  565.   change = args[2].data.num;   /* changed money */
  566.   np = &world.nations[nat_id];
  567.   
  568.   np->spell_pts = np->spell_pts + change;
  569.   if (debug) printf("New nation spell pts (after difference %d) = %d\n",
  570.             change, np->spell_pts);
  571. }
  572.  
  573. cmd_ctech_skill(np, args)
  574.      Snation *np;
  575.      struct argument args[];
  576. {
  577.   int change, nat_id;
  578.  
  579.   nat_id = args[1].data.num;
  580.   change = args[2].data.num;   /* changed money */
  581.   np = &world.nations[nat_id];
  582.   
  583.   np->tech_skill = np->tech_skill + change;
  584. }
  585.  
  586. cmd_cmag_skill(np, args)
  587.      Snation *np;
  588.      struct argument args[];
  589. {
  590.   int change, nat_id;
  591.  
  592.   nat_id = args[1].data.num;
  593.   change = args[2].data.num;   /* changed money */
  594.   np = &world.nations[nat_id];
  595.   
  596.   np->mag_skill = np->mag_skill + change;
  597. }
  598.  
  599. cmd_cfood(np, args)
  600.      Snation *np;
  601.      struct argument args[];
  602. {
  603.   int change, nat_id;
  604.  
  605.   nat_id = args[1].data.num;
  606.   change = args[2].data.num;   /* changed money */
  607.   np = &world.nations[nat_id];
  608.   
  609.   np->food = np->food + change;
  610.   if (debug) printf("New nation food (after difference %d) = %d\n",
  611.      change,np->food);
  612. }
  613.  
  614. cmd_tech_money(np,args)
  615.      Snation *np;
  616.      struct argument args[];
  617. {
  618.   np->tech_r_d = args[1].data.num;
  619.   if (debug) printf("Tech R&D money changed to %d\n",np->tech_r_d);
  620. }
  621.  
  622.  
  623. cmd_tech_metal(np,args)
  624.      Snation *np;
  625.      struct argument args[];
  626. {
  627.   np->tech_r_d_metal = args[1].data.num;
  628.   if (debug) printf("Tech R&D metal changed to %d\n",np->tech_r_d_metal);
  629. }
  630.  
  631.  
  632. cmd_spy_money(np,args)
  633.      Snation *np;
  634.      struct argument args[];
  635. {
  636.      np->spy_r_d = args[1].data.num;
  637.    }
  638.  
  639.  
  640. cmd_mag_money(np,args)
  641.      Snation *np;
  642.      struct argument args[];
  643. {
  644.   np->mag_r_d = args[1].data.num;
  645.   if (debug) printf("Magic money changed to %d\n",np->mag_r_d);
  646. }
  647.  
  648. cmd_mag_jewels(np,args)
  649.      Snation *np;
  650.      struct argument args[];
  651. {
  652.   np->mag_r_d_jewels = args[1].data.num;
  653.   if (debug) printf("Magic jewels changed to %d\n",np->mag_r_d_jewels);
  654. }
  655.  
  656. cmd_cmine(np, args)
  657.      Snation *np;
  658.      struct argument args[];
  659. {
  660.   np->mine_skill += args[1].data.num;
  661. }
  662. cmd_cfarm(np, args)
  663.      Snation *np;
  664.      struct argument args[];
  665. {
  666.   np->farm_skill += args[1].data.num;
  667. }
  668. cmd_cspeed(np, args)
  669.      Snation *np;
  670.      struct argument args[];
  671. {
  672.   np->race.speed += args[1].data.num;
  673. }
  674.  
  675. cmd_nation_name(np, args)
  676.      Snation *np;
  677.      struct argument args[];
  678. {
  679.   Snation *changed_np = &world.nations[args[1].data.num];
  680.   strcpy(changed_np->name, args[2].data.str);
  681. }
  682.  
  683. cmd_nation_leader(np, args)
  684.      Snation *np;
  685.      struct argument args[];
  686. {
  687.   Snation *changed_np = &world.nations[args[1].data.num];
  688.   strcpy(changed_np->leader, args[2].data.str);
  689. }
  690.  
  691. cmd_nation_order(np, args)    /* change magic order */
  692.      Snation *np;
  693.      struct argument args[];
  694. {
  695.   Snation *changed_np = &world.nations[args[1].data.num];
  696.   strcpy(changed_np->mag_order, args[2].data.str);
  697. }
  698.  
  699. cmd_nation_mark(np, args)    /* change a nation's mark */
  700.      Snation *np;
  701.      struct argument args[];
  702. {
  703.   Snation *changed_np = &world.nations[args[1].data.num];
  704.   changed_np->mark = args[2].data.str[0];
  705. }
  706.  
  707.   /* set and clear the npc flag on a nation */
  708. cmd_set_npc(np, args)
  709.      Snation *np;
  710.      struct argument args[];
  711. {
  712.   Snation *changed_nation = &world.nations[args[1].data.num];
  713.  
  714.   changed_nation->npc_flag = 1;
  715. }
  716.  
  717. cmd_clear_npc(np, args)
  718.      Snation *np;
  719.      struct argument args[];
  720. {
  721.   Snation *changed_nation = &world.nations[args[1].data.num];
  722.  
  723.   changed_nation->npc_flag = 0;
  724. }
  725.  
  726. cmd_npc_param(np, args)
  727.      Snation *np;
  728.      struct argument args[];
  729. {
  730.   Snation *changed_nation = &world.nations[args[1].data.num];
  731.  
  732.   changed_nation->npc_agg = args[2].data.num;
  733.   changed_nation->npc_exp = args[3].data.num;
  734.   changed_nation->npc_iso = args[4].data.num;
  735. }
  736.  
  737.   /* change in a nation's fight bonus */
  738. cmd_cattack(np, args)
  739.      Snation *np;
  740.      struct argument args[];
  741. {
  742.   np->attack += args[1].data.num;
  743. }
  744.  
  745. cmd_cdefense(np, args)
  746.      Snation *np;
  747.      struct argument args[];
  748. {
  749.   np->defense += args[1].data.num;
  750. }
  751.  
  752. cmd_ccombat(np, args)
  753.      Snation *np;
  754.      struct argument args[];
  755. {
  756.   np->attack += args[1].data.num;
  757.   np->defense += args[1].data.num;
  758. }
  759.  
  760. cmd_crepro(np, args)
  761.      Snation *np;
  762.      struct argument args[];
  763. {
  764.   np->race.repro += args[1].data.num;
  765. }
  766.  
  767. cmd_cmortality(np, args)
  768.      Snation *np;
  769.      struct argument args[];
  770. {
  771.   if ((np->race.mortality += args[1].data.num) < 1) {
  772.     np->race.mortality = 1;
  773.   }
  774. }
  775.  
  776. cmd_cintel(np, args)
  777.      Snation *np;
  778.      struct argument args[];
  779. {
  780.   if ((np->race.intel += args[1].data.num) < 1) {
  781.     np->race.intel = 1;
  782.   }
  783. }
  784.  
  785. cmd_cmag_apt(np, args)
  786.      Snation *np;
  787.      struct argument args[];
  788. {
  789.   if ((np->race.mag_apt += args[1].data.num) < 1) {
  790.     np->race.mag_apt = 1;
  791.   }
  792. }
  793.  
  794. cmd_cstrength(np, args)
  795.      Snation *np;
  796.      struct argument args[];
  797. {
  798.   if ((np->race.strength += args[1].data.num) < 1) {
  799.     np->race.strength = 1;
  800.   }
  801. }
  802.  
  803.   /* change the number of people in that sector */
  804. cmd_cpeople_sector(np, args)
  805.      Snation *np;
  806.      struct argument args[];
  807. {
  808.   Ssector *sp;
  809.   int x, y;
  810.  
  811.   x = args[1].data.num;
  812.   y = args[2].data.num;
  813.   sp = &world.map[x][y];
  814.   sp->n_people += args[3].data.num;
  815. }
  816.   /* change the owner in that sector */
  817. cmd_cowner_sector(np, args)
  818.      Snation *np;
  819.      struct argument args[];
  820. {
  821.   Ssector *sp;
  822.   int x, y;
  823.  
  824.   x = args[1].data.num;
  825.   y = args[2].data.num;
  826.   sp = &world.map[x][y];
  827.   sp->owner = args[3].data.num;
  828.   addsector(&world.nations[sp->owner], x, y);
  829.   if (debug)
  830.     printf("sector (%d,%d) owned by %s\n", x, y,
  831.        world.nations[sp->owner].name);
  832. }
  833.  
  834.   /* change the soil in that sector */
  835. cmd_csoil_sector(np, args)
  836.      Snation *np;
  837.      struct argument args[];
  838. {
  839.   Ssector *sp;
  840.   int x, y;
  841.  
  842.   x = args[1].data.num;
  843.   y = args[2].data.num;
  844.   sp = &world.map[x][y];
  845.   sp->soil += args[3].data.num;
  846. }
  847.  
  848.   /* change the metal in that sector */
  849. cmd_cmetal_sector(np, args)
  850.      Snation *np;
  851.      struct argument args[];
  852. {
  853.   Ssector *sp;
  854.   int x, y;
  855.  
  856.   x = args[1].data.num;
  857.   y = args[2].data.num;
  858.   sp = &world.map[x][y];
  859.   sp->metal += args[3].data.num;
  860. }
  861.   /* change the jewels in that sector */
  862. cmd_cjewels_sector(np, args)
  863.      Snation *np;
  864.      struct argument args[];
  865. {
  866.   Ssector *sp;
  867.   int x, y;
  868.  
  869.   x = args[1].data.num;
  870.   y = args[2].data.num;
  871.   sp = &world.map[x][y];
  872.   sp->jewels += args[3].data.num;
  873. }
  874.  
  875.   /* change the altitude in that sector */
  876. cmd_caltitude_sector(np, args)
  877.      Snation *np;
  878.      struct argument args[];
  879. {
  880.   Ssector *sp;
  881.   int x, y;
  882.  
  883.   x = args[1].data.num;
  884.   y = args[2].data.num;
  885.   sp = &world.map[x][y];
  886.   sp->altitude += args[3].data.num;
  887. }
  888.  
  889. /* adds a new type of army to the nation's list of available army types */
  890. cmd_new_army_type(np, args)
  891.      Snation *np;
  892.      struct argument args[];
  893. {
  894.   Savail_army *aa;
  895.   extern Suser user;
  896.   int falready=0;
  897.  
  898.   /* Check to see that they don't already have the army type */
  899.   aa = user.avail_armies;
  900.   if (aa != NULL) {
  901.     do {
  902.       if (!strcmp (aa->type, args[1].data.str)) {
  903.     falready = 1;
  904.     break;
  905.       }
  906.     } while (aa->next && (aa=aa->next));
  907.   }
  908.   if (aa == NULL) {
  909.     aa = (Savail_army *) malloc (sizeof(Savail_army));
  910.     strcpy (aa->type, args[1].data.str);
  911.   } else if (!falready) {
  912.     do { ; } while (aa->next && (aa = aa->next));
  913.     aa->next = (Savail_army *) malloc (sizeof (Savail_army));
  914.     aa->next->next = NULL;
  915.     strcpy(aa->next->type, args[1].data.str);
  916.   }
  917.   user.n_army_types++;
  918. }
  919.  
  920. /* allows nation to construct a new type of object, such
  921.    as increasing roads in a sector, or making land into water
  922.    or vice-versa, or ships, or caravans.
  923. */
  924. cmd_new_construct(np, args)
  925.      Snation *np;
  926.      struct argument args[];
  927. {
  928. }
  929.  
  930.   /* adds the first army to the second.  Requires the two army ids. */
  931. cmd_amerge(np, args)
  932.      Snation *np;
  933.      struct argument args[];
  934. {
  935.   Sarmy *ap, *ap2;
  936.   Ssector *sp;
  937.   ap = get_army(np, args[1].data.num);
  938.   ap2 = get_army(np, args[2].data.num);
  939.   sp = &world.map[ap->pos.x][ap->pos.y];
  940.   ap2->n_soldiers += ap->n_soldiers;
  941.   ap2->sp_bonus = min(ap->sp_bonus, ap2->sp_bonus);
  942.   ap2->mvpts = min(ap->mvpts, ap2->mvpts);
  943.   ap2->mvratio = min(ap->mvratio, ap2->mvratio);
  944.   delete_army_sector(sp, ap);
  945.   delete_army_nation(np, ap);
  946. }
  947.  
  948.   /* increases the army (of given id) by the given number of people */
  949. cmd_aincrease(np, args)
  950.      Snation *np;
  951.      struct argument args[];
  952. {
  953.   Sarmy *ap;
  954.  
  955.   ap = get_army(np, args[1].data.num);
  956.   ap->n_soldiers += args[2].data.num;
  957.   ap->mvpts = 0;
  958.   ap->mvratio = 0;
  959. }
  960.  
  961.   /* splits an army up.  requires armyid and number of men to split */
  962. cmd_asplit(np, args)
  963.      Snation *np;
  964.      struct argument args[];
  965. {
  966.   Sarmy *ap, army2, make_army(), *get_army();
  967.  
  968.   ap = get_army(np,args[1].data.num);
  969.   army2 = make_army(ap->type, "", args[2].data.num, ap->status,
  970.             ap->owner, ap->pos);
  971.   ap->n_soldiers -= args[2].data.num;
  972.   army2.mvpts = ap->mvpts;
  973.   army2.mvratio = ap->mvratio;
  974.   army2.flags = ap->flags;
  975.   army2.sp_bonus = ap->sp_bonus;
  976.   army2.money_maint = ap->money_maint;
  977.   army2.metal_maint = ap->metal_maint;
  978.   army2.jewel_maint = ap->jewel_maint;
  979.   army2.spell_pts_maint = ap->spell_pts_maint;
  980.   sprintf(army2.name, "%s", army2.type, army2.id);
  981.   np->n_armies++;
  982.   insert_army_nation(np, &army2, -1);
  983.   insert_army_sector(&world.map[army2.pos.x][army2.pos.y], &army2);
  984.     /* to give them a name, we must know their id *after* they are inserted */
  985.   ap = get_army(np, army2.id);
  986.   sprintf(ap->name, "%s", army2.type, army2.id);
  987. }
  988.  
  989. cmd_adisband(np,args)
  990.      Snation *np;
  991.      struct argument args[];
  992. {
  993.   Sarmy *ap;
  994.   Ssector *sp;
  995.   ap = get_army(np,args[1].data.num);
  996.   sp = &world.map[ap->pos.x][ap->pos.y];
  997.     /* you don't get the population back from a spirit */
  998.   if (!is_spirit(ap) && !is_in_transport(ap)) {
  999.     sp->n_people += ap->n_soldiers;
  1000.   }
  1001.   delete_army_sector(sp, ap);
  1002.   delete_army_nation(np, ap);
  1003. }
  1004.  
  1005. cmd_cabonus(np,args)        /* give an army more/less special bonus */
  1006.      Snation *np;
  1007.      struct argument args[];
  1008. {
  1009.   Sarmy *ap;
  1010.   int bonus_change;
  1011.  
  1012.   bonus_change = args[2].data.num;
  1013.   if (ap = get_army(np,args[1].data.num)) {
  1014.     ap->sp_bonus += bonus_change;
  1015.   }
  1016. }
  1017.  
  1018.   /* change fortification level of a sector */
  1019. cmd_cfort_sector(np, args)
  1020.      Snation *np;
  1021.      struct argument args[];
  1022. {
  1023.   Ssector *sp;
  1024.   int x, y;
  1025.  
  1026.   x = args[1].data.num;
  1027.   y = args[2].data.num;
  1028.   sp = &world.map[x][y];
  1029.   sp->defense += args[3].data.num;
  1030. }
  1031.  
  1032.   /* change number of roads in a sector */
  1033. cmd_croads_sector(np, args)
  1034.      Snation *np;
  1035.      struct argument args[];
  1036. {
  1037.   Ssector *sp;
  1038.   int x, y;
  1039.  
  1040.   x = args[1].data.num;
  1041.   y = args[2].data.num;
  1042.   sp = &world.map[x][y];
  1043.   sp->roads += args[3].data.num;
  1044. }
  1045.  
  1046. cmd_cpass(np, args)
  1047.      Snation *np;
  1048.      struct argument args[];
  1049. {
  1050.   Snation *dest_np;
  1051.   int id;
  1052.   char *new_pass;
  1053.  
  1054.   id = args[1].data.num;
  1055.   new_pass = args[2].data.str;
  1056.   dest_np = &world.nations[id];
  1057.   strcpy(dest_np->passwd, new_pass);
  1058. }
  1059.  
  1060. cmd_cur_mag_money (np, args)
  1061.  
  1062. Snation * np;
  1063. struct argument args [];
  1064. {
  1065.   np->cur_mag_r_d = args[1].data.num;
  1066. }
  1067.  
  1068. cmd_cur_tech_money (np, args)
  1069.  
  1070. Snation * np;
  1071. struct argument args [];
  1072. {
  1073.   np->cur_tech_r_d = args[1].data.num;
  1074. }
  1075.  
  1076. cmd_cur_mag_jewels (np, args)
  1077.  
  1078. Snation * np;
  1079. struct argument args [];
  1080. {
  1081.   np->cur_mag_r_d_jewels = args[1].data.num;
  1082. }
  1083.  
  1084. cmd_cur_tech_metal (np, args)
  1085.  
  1086. Snation * np;
  1087. struct argument args [];
  1088. {
  1089.   np->cur_tech_r_d_metal = args[1].data.num;
  1090. }
  1091.  
  1092. cmd_cur_spy_money (np, args)
  1093.  
  1094. Snation * np;
  1095. struct argument args [];
  1096. {
  1097.   np->cur_spy_r_d = args[1].data.num;
  1098. }
  1099.  
  1100. cmd_destroy(np, args)
  1101.      Snation *np;
  1102.      struct argument args[];
  1103. {
  1104.   int id;
  1105.  
  1106.   id = args[1].data.num;
  1107.   destroy_nation(id);
  1108. }
  1109.  
  1110. cmd_acastle (np, args)
  1111.      
  1112. Snation * np;
  1113. struct argument args [];
  1114. {
  1115.   int army_id;
  1116.   Ssector * sp;
  1117.   Ssector * capital = &world.map [np->capital.x][np->capital.y];
  1118.   Sarmy * ap;
  1119.  
  1120.   army_id = args[1].data.num;
  1121.   if ((ap = get_army (np, army_id)) == NULL) {
  1122.     printf ("funny, can't find army %d\n", army_id);
  1123.   }
  1124.   sp = &world.map [ap->pos.x][ap->pos.y];
  1125.  
  1126.   delete_army_sector (sp, ap);
  1127.  
  1128.   ap->pos.x = capital->loc.x;
  1129.   ap->pos.y = capital->loc.y;
  1130.   
  1131.   insert_army_sector (capital, ap);
  1132. }
  1133.  
  1134.   /* read in the exec file for the master nation; this is done by all
  1135.      users, in case the master has changed things for them.  It is not
  1136.      done by the master nation, since that happens automaticaly.
  1137.    */
  1138. load_master_execs()
  1139. {
  1140.   int argc;
  1141.   Snation *np = &world.nations[0];
  1142.   FILE *exec_file, *fopen();
  1143.   struct argument args[N_EXEC_ARGS];
  1144.   char filename[NAMELEN];
  1145.  
  1146.   sprintf(filename, "exec/exec%d", np->id);
  1147.   exec_file = fopen(filename, "r");
  1148.   if (!exec_file && np->npc_flag == 0) {
  1149.     /* printf("Nation %d (%s) did not move this turn.\n", np->id, np->name); */
  1150.   } else {
  1151.     while (argc = getexec(exec_file, args) != -1) {
  1152.       run_exec_line(np, args);
  1153.     }
  1154.     if (exec_file != NULL) { fclose(exec_file); }
  1155.   }
  1156. }
  1157.  
  1158.