home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume13 / dominion / part21 / economy.c < prev    next >
C/C++ Source or Header  |  1992-02-11  |  19KB  |  807 lines
  1. /* economy.c -- routines which deal with the economy, revenue and
  2.                expenses of all types.
  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. /* calc_revenue(np) - find the amount of tax revenue for a nation  */
  27. /* calc_metal(np) - find the amount of metal produced by nation    */
  28. /* calc_jewels(np) - find the amount of jewels produced by nation  */
  29. /* calc_food(np) - find the amount of food produced by nation      */
  30. /* calc_expend(np) - calculate a nation's expenditures             */
  31. /* calc_expend_metal(np) - calculate metal expenditures for nation */
  32. /* calc_expend_jewels(np) - calculate jewel expenditures for nation*/
  33. /* calc_expend_food(np) - calculate food expenditures for a nation */
  34. /* sector_metal(sp) - calculate metal produced in a single sector  */
  35. /* sector_jewels(sp) - calculate jewels produced in single sector  */
  36. /* sector_food(sp) - calculate food produced in a single sector    */
  37. /* military_maint(np) - returns total amount of money spent for armies */
  38. /* military_maint_metal(np) - total amount of metal spent for armies   */
  39. /* military_maint_jewels(np) - total amount of jewels spent for armies */
  40. /* army_maint_money(ap) - amount of money needed to maintain given army*/
  41. /* construct_cost(type) - cost to construct object                 */
  42. /* construct_cost_metal(type) - metal cost to construct object     */
  43. /* get_employed(np) - how many employed in that nation             */
  44. /* get_emp_met(np) - how many employed metal miners                */
  45. /* get_emp_jws(np) - how many employed jewel miners                */
  46. /* get_emp_farm(np) - how many employed farmers                    */
  47. /* (same for unemployed)                                           */
  48. /* get_avg_money(wp) - average money in the world                  */
  49. /* emp_desire(np,x,y) - gives the employment desireability in x,y  */
  50. /* n_workers(sp) - number of people employed in that sect.         */
  51. /* prod_level(np) - Relative level of production of a nation       */
  52.  
  53. #include "dominion.h"
  54. #include "misc.h"
  55. #include "army.h"
  56. #include "costs.h"
  57. #include "cur_stuff.h"
  58. #include <stdio.h>
  59. #include <ctype.h>
  60. #include <signal.h>
  61. #include <math.h>
  62.  
  63. extern Sworld world;
  64. extern struct s_desig_map desig_map[];
  65. extern struct s_altitude_map altitude_map[];
  66. extern struct item_map terrains[];
  67. extern struct item_map climates[];
  68. extern Suser user;
  69. extern int debug;
  70. extern int (*wrapx)(), (*wrapy)();
  71.  
  72. #define PROD_POWER (7.0/6.0)
  73.  
  74. double prod_level(np)
  75.      Snation *np;
  76. {
  77.   return (1.0 - pow((double)(np->taxes)/100.0,PROD_POWER));
  78. }
  79.  
  80.   /* calculate the amount of tax revenue for a given nation */
  81. calc_revenue(np)
  82.      Snation *np;
  83. {
  84.   Ssector *sp;
  85.   struct pt_list *points;
  86.   int income = 0, taxes = np->taxes, pop;
  87.     /* first thing: run through the list of that nation's sectors
  88.        and see what income might come from the various sectors
  89.      */
  90.   if ((points = np->ptlist) == NULL) {
  91.     return 0;            /* nation has no sectors!! */
  92.   }
  93.   do {
  94.     sp = &(world.map[points->pt.x][points->pt.y]);
  95.     pop = n_workers(sp);
  96.     income+=(taxes*prod_level(np)*pop*desig_map[sp->designation].revenue)/100;
  97.   } while ((points = points->next) != NULL);
  98.   return income;
  99. }
  100.  
  101.  
  102. /* int calc_metal (Snation *) -- calculates metal owned by all sectors owned.
  103.    - Cycles through all sectors owned, and computes metal production for
  104.      that sector.
  105.    - Sums them up, and returns the total.
  106. */ 
  107.  
  108. int calc_metal (np)
  109.      Snation *np;
  110. {
  111.   Ssector *sp;
  112.   struct pt_list *points;
  113.   int metal_total = 0;
  114.   
  115.   if ((points = np->ptlist) == NULL) {
  116.     return 0;            /* nation has no sectors!! */
  117.   }
  118.   do {
  119.     sp = &(world.map [points->pt.x][points->pt.y]);
  120.     switch (sp->designation) {
  121.     case D_METAL_MINE:
  122.       metal_total += sector_metal(sp);
  123.       break;
  124.     default:
  125.       break;
  126.     }
  127.   } while ((points = points->next) != NULL);
  128.   
  129.   return (metal_total);
  130. }
  131.  
  132.  
  133. /* int calc_jewels (Snation *) -- calculates jewels owned by all sectors owned.
  134.  *  - Cycles through all sectors owned.
  135.  *  - If sector is a jewel mine, computes the jewels by:
  136.  *        jewels_per_civilian * number_of_people
  137.  *  - returns summation.
  138.  */
  139.  
  140. int calc_jewels (np)
  141. Snation *np;
  142. {
  143.   Ssector *sp;
  144.   struct pt_list *points;
  145.   int jewels_total = 0;
  146.  
  147.   if ((points = np->ptlist) == NULL) {
  148.     return 0;            /* nation has no sectors!! */
  149.   }
  150.   do {
  151.     sp = &(world.map[points->pt.x][points->pt.y]);
  152.     
  153.     switch (sp->designation) {
  154.     case D_JEWEL_MINE:
  155.       jewels_total += sector_jewels(sp);
  156.       break;
  157.     default:
  158.       break;
  159.     }
  160.   } while ((points = points->next) != NULL);
  161.  
  162.   return (jewels_total);
  163. }
  164.  
  165.   /* how much food is produced in the nation */
  166. calc_food(np)
  167.      Snation *np;
  168. {
  169.   Ssector *sp;
  170.   struct pt_list *points;
  171.   int food_total = 0;
  172.  
  173.   if ((points = np->ptlist) == NULL) {
  174.     return 0;            /* nation has no sectors!! */
  175.   }
  176.   do {
  177.     sp = &(world.map[points->pt.x][points->pt.y]);
  178.     switch (sp->designation) {
  179.     case D_FARM:
  180.       food_total += sector_food(sp);
  181.       break;
  182.     default:
  183.       break;
  184.     }
  185.   } while ((points = points->next) != NULL);
  186.   
  187.   return food_total;
  188. }
  189.  
  190.   /* calculate a nation's expenditures */
  191. calc_expend(np)
  192.      Snation *np;
  193. {
  194.   int percent;
  195.  
  196.   percent = np->charity + np->tech_r_d + np->mag_r_d + np->spy_r_d;
  197.  
  198.   return (percent*calc_revenue(np)) / 100 + military_maint(np)
  199.     + non_profit_maint(np);;
  200. }
  201.  
  202. calc_expend_metal(np)
  203.      Snation *np;
  204. {
  205.   int percent;
  206.  
  207.   percent = np->tech_r_d_metal;
  208.  
  209.   return (percent*calc_metal(np)) / 100 + military_maint_metal(np);
  210. }
  211.  
  212. calc_expend_jewels(np)
  213.      Snation *np;
  214. {
  215.   int percent;
  216.  
  217.   percent = np->mag_r_d_jewels;
  218.  
  219.   return (percent*calc_jewels(np)) / 100 + military_maint_jewels(np);
  220. }
  221.  
  222. calc_expend_food(np)
  223.      Snation *np;
  224. {
  225.   int food_eaten;
  226.  
  227.   food_eaten = (int) (get_n_civil(np) * EAT
  228.               + SOLD_EAT_FACTOR * get_n_soldiers(np) * EAT);
  229.  
  230.   return food_eaten;
  231. }
  232.  
  233.   /* now come a couple of routines that calculate
  234.      the amount of a resource (metal, jewels, food)
  235.      for a SINGLE sector
  236.    */
  237. sector_metal(sp)
  238.      Ssector *sp;
  239. {
  240.   int i, j, n_refineries = 0;
  241.   float metal;
  242.   Snation *np = &world.nations[sp->owner];
  243.  
  244.     /* see how many active refineries are close by.
  245.        a refinery is active if there are the minimum number
  246.        of people emplyed in it.
  247.      */
  248.   for (i = sp->loc.x-1; i <= sp->loc.x+1; ++i) {
  249.     for (j = sp->loc.y-1; j <= sp->loc.y+1; ++j) {
  250.       if ((world.map[(*wrapx)(i,j)][(*wrapy)(i,j)].designation == D_REFINERY)
  251.       &&
  252.       (world.map[(*wrapx)(i,j)][(*wrapy)(i,j)].n_people
  253.        >= desig_map[D_REFINERY].min_employed)) {
  254.     ++n_refineries;
  255.       }
  256.     }
  257.   }
  258.     /* add to metal production depending on the
  259.        number of refineries and the mining skill
  260.      */
  261.   metal = n_workers(sp) * (1.0 + np->mine_skill/100.0) * sp->metal;
  262.   metal *= (1.0 + REFINERY_FACT*n_refineries);
  263.   
  264.   return (int)(metal * prod_level(np));
  265. }
  266.  
  267. sector_jewels(sp)
  268.      Ssector *sp;
  269. {
  270.   Snation *np = &world.nations[sp->owner];
  271.   float jewels;
  272.   
  273.   jewels = n_workers(sp) * (1.0 + np->mine_skill/100.0) * sp->jewels;
  274.  
  275.   return (int) (jewels * prod_level(np));
  276. }
  277.  
  278. sector_food(sp)
  279.      Ssector *sp;
  280. {
  281.   Snation *np = &world.nations[sp->owner];
  282.   float food;
  283.  
  284.   food = (1.0 + np->farm_skill/100.0) * ((sp->soil+1)/6.0)
  285.     * n_workers(sp) * FOOD_PROD;
  286.  
  287.   return (int) (food * prod_level(np));
  288. }
  289.  
  290.   /* this returns the TOTAL amount of money spent
  291.      to maintain the nation's military forces
  292.    */
  293. military_maint(np)
  294.      Snation *np;
  295. {
  296.   Sarmy *ap;
  297.   int total = 0;
  298.  
  299.   for (ap = np->armies; ap != NULL; ap = ap->next) {
  300.     total += army_maint_money(ap);
  301.   }
  302.  
  303.   return total;
  304. }
  305.   /* this returns the TOTAL amount of metal spent
  306.      to maintain the nation's military forces
  307.    */
  308. military_maint_metal(np)
  309.      Snation *np;
  310. {
  311.   Sarmy *ap;
  312.   int total = 0;
  313.  
  314.   for (ap = np->armies; ap != NULL; ap = ap->next) {
  315.     total += ap->n_soldiers * ap->metal_maint;
  316.   }
  317.  
  318.   return total;
  319. }
  320.   /* this returns the TOTAL amount of jewels spent
  321.      to maintain the nation's military forces
  322.    */
  323. military_maint_jewels(np)
  324.      Snation *np;
  325. {
  326.   Sarmy *ap;
  327.   int total = 0;
  328.  
  329.   for (ap = np->armies; ap != NULL; ap = ap->next) {
  330.     total += ap->n_soldiers * ap->jewel_maint;
  331.   }
  332.   return total;
  333. }
  334.   /* this returns the TOTAL amount of jewels spent
  335.      to maintain the nation's military forces
  336.    */
  337. military_maint_spell_pts(np)
  338.      Snation *np;
  339. {
  340.   Sarmy *ap;
  341.   int total = 0;
  342.   struct spirit_type *stype, *get_spirit_type();
  343.  
  344.   for (ap = np->armies; ap != NULL; ap = ap->next) {
  345. /*    if (is_spirit(ap)) {
  346.       if ((stype = get_spirit_type(&user, ap->type)) == NULL) {
  347.     printf(
  348.     "\r\nBAD BUG: is_spirit(), but can't get which spirit from type %s\r\n",
  349.            ap->type);
  350.       } else {
  351.     total += (ap->n_soldiers * ap->spell_pts_maint) / stype->size;
  352.       }
  353.     }
  354. */
  355.     if (ap->spell_pts_maint != 0)  {
  356.       total += get_spell_pts_maint(ap);
  357.     }
  358.   }
  359.   return total;
  360. }
  361.  
  362.   /* this gives the money needed to maintain a given army */
  363. army_maint_money(ap)
  364.      Sarmy *ap;
  365. {
  366.   int money_maint = 0, index;
  367.   extern struct army_type *army_types;
  368.  
  369.   if (is_army(ap)) {
  370.     index = army_type_index(ap);
  371.     money_maint = army_types[index].money_maint * ap->n_soldiers;
  372.   }
  373.     /* in other cases, money maint is zero */
  374.  
  375.   return  money_maint + ARMY_OVERHEAD;
  376. }
  377.  
  378.   /* this returns the TOTAL amount of money spent to
  379.      maintain the nation's non-profit centers (hospitals  ...)
  380.    */
  381. non_profit_maint(np)
  382.      Snation *np;
  383. {
  384.   struct pt_list *ptlist = np->ptlist; /* nation's list of owned sectors */
  385.   Ssector *sp;
  386.   int total = 0;
  387.  
  388.   for ( ; ptlist != NULL; ptlist = ptlist->next) {
  389.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  390.     switch (sp->designation) {
  391.     case D_UNIVERSITY:
  392.       total += UNIV_MAINT_COST;
  393.       break;
  394.     case D_HOSPITAL:
  395.       total += HOSPITAL_MAINT_COST;
  396.       break;
  397.     default:
  398.       break;
  399.     }
  400.   }
  401.   return total;
  402. }
  403.  
  404. get_n_students(np)
  405.      Snation *np;
  406. {
  407.   Ssector *sp;
  408.   struct pt_list *ptlist = np->ptlist;
  409.   int n = 0;
  410.  
  411.   while (ptlist != NULL) {
  412.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  413.     if (sp->designation == D_UNIVERSITY) {
  414.       n += n_workers(sp);
  415.     }
  416.     ptlist = ptlist->next;
  417.   }
  418.   return n;
  419. }
  420.  
  421. get_n_priests (np)
  422.      Snation *np;
  423. {
  424.   Ssector *sp;
  425.   struct pt_list *ptlist = np->ptlist;
  426.   int n = 0;
  427.  
  428.   while (ptlist != NULL) {
  429.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  430.     if (sp->designation == D_TEMPLE) {
  431.       n += n_workers(sp);
  432.     }
  433.     ptlist = ptlist->next;
  434.   }
  435.   return n;
  436. }
  437.  
  438. get_employed(np)
  439.      Snation *np;
  440. {
  441.   Ssector *sp;
  442.   struct pt_list *ptlist = np->ptlist;
  443.   int n = 0;
  444.  
  445.   while (ptlist != NULL) {
  446.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  447.         /* only people who are employed */
  448.     n += n_workers(sp);
  449.     ptlist = ptlist->next;
  450.   }
  451.   return n;
  452. }
  453.  
  454. get_unemployed(np)
  455.      Snation *np;
  456. {
  457.   Ssector *sp;
  458.   struct pt_list *ptlist = np->ptlist;
  459.   int n = 0;
  460.  
  461.   while (ptlist != NULL) {
  462.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  463.         /* only people who are un-employed */
  464.     n += max(0, sp->n_people - n_workers(sp));
  465.     ptlist = ptlist->next;
  466.   }
  467.   return n;
  468. }
  469.  
  470. get_emp_met(np)
  471.      Snation *np;
  472. {
  473.   Ssector *sp;
  474.   struct pt_list *ptlist = np->ptlist;
  475.   int n = 0;
  476.  
  477.   while (ptlist != NULL) {
  478.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  479.         /* only people who are employed */
  480.     if (sp->designation == D_METAL_MINE) {
  481.       n += n_workers(sp);
  482.     }
  483.     ptlist = ptlist->next;
  484.   }
  485.   return n;
  486. }
  487.  
  488. get_unemp_met(np)
  489.      Snation *np;
  490. {
  491.   Ssector *sp;
  492.   struct pt_list *ptlist = np->ptlist;
  493.   int n = 0;
  494.  
  495.   while (ptlist != NULL) {
  496.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  497.     if (sp->designation == D_METAL_MINE) {
  498.         /* only people who are un-employed */
  499.       n += max(0, sp->n_people - n_workers(sp));
  500.     }
  501.     ptlist = ptlist->next;
  502.   }
  503.   return n;
  504. }
  505.  
  506. get_emp_jwl(np)
  507.      Snation *np;
  508. {
  509.   Ssector *sp;
  510.   struct pt_list *ptlist = np->ptlist;
  511.   int n = 0;
  512.  
  513.   while (ptlist != NULL) {
  514.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  515.         /* only people who are employed */
  516.     if (sp->designation == D_JEWEL_MINE) {
  517.       n += n_workers(sp);
  518.     }
  519.     ptlist = ptlist->next;
  520.   }
  521.   return n;
  522. }
  523.  
  524. get_unemp_jwl(np)
  525.      Snation *np;
  526. {
  527.   Ssector *sp;
  528.   struct pt_list *ptlist = np->ptlist;
  529.   int n = 0;
  530.  
  531.   while (ptlist != NULL) {
  532.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  533.     if (sp->designation == D_JEWEL_MINE) {
  534.         /* only people who are un-employed */
  535.       n += max(0, sp->n_people - n_workers(sp));
  536.     }
  537.     ptlist = ptlist->next;
  538.   }
  539.   return n;
  540. }
  541.  
  542. get_emp_farm(np)
  543.      Snation *np;
  544. {
  545.   Ssector *sp;
  546.   struct pt_list *ptlist = np->ptlist;
  547.   int n = 0;
  548.  
  549.   while (ptlist != NULL) {
  550.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  551.         /* only people who are employed */
  552.     if (sp->designation == D_FARM) {
  553.       n += n_workers(sp);
  554.     }
  555.     ptlist = ptlist->next;
  556.   }
  557.   return n;
  558. }
  559.  
  560. get_unemp_farm(np)
  561.      Snation *np;
  562. {
  563.   Ssector *sp;
  564.   struct pt_list *ptlist = np->ptlist;
  565.   int n = 0;
  566.  
  567.   while (ptlist != NULL) {
  568.     sp = &world.map[ptlist->pt.x][ptlist->pt.y];
  569.     if (sp->designation == D_FARM) {
  570.         /* only people who are un-employed */
  571.       n += max(0, sp->n_people - n_workers(sp));
  572.     }
  573.     ptlist = ptlist->next;
  574.   }
  575.   return n;
  576. }
  577.  
  578.   /* the service sector!! */
  579. get_emp_serv(np)
  580.      Snation *np;
  581. {
  582.   return get_employed(np)-get_emp_met(np)-get_emp_jwl(np)-get_emp_farm(np);
  583. }
  584.  
  585. get_unemp_serv(np)
  586.      Snation *np;
  587. {
  588.   return get_unemployed(np)
  589.     - get_unemp_met(np) - get_unemp_jwl(np) - get_unemp_farm(np);
  590. }
  591.  
  592.   /* tax revenue from the service sector */
  593. calc_serv_revenue(np)
  594.      Snation *np;
  595. {
  596.   Ssector *sp;
  597.   struct pt_list *points;
  598.   int income = 0;
  599.   int taxes = np->taxes;
  600.     /* first thing: run through the list of that nation's sectors
  601.        and see what income might come from the various sectors
  602.      */
  603.   if ((points = np->ptlist) == NULL) {
  604.     return 0;            /* nation has no sectors!! */
  605.   }
  606.   do {
  607.     sp = &(world.map[points->pt.x][points->pt.y]);
  608.     switch (sp->designation) {
  609.     case D_METAL_MINE:
  610.     case D_JEWEL_MINE:
  611.     case D_FARM:
  612.       break;
  613.     default:            /* other things (service sector) */
  614.       income += (taxes * prod_level(np)*n_workers(sp)*
  615.                             desig_map[sp->designation].revenue)/100;
  616.       break;
  617.     }
  618.   } while ((points = points->next) != NULL);
  619.   return income;
  620. }
  621.  
  622.   /* average quantities of all nations in the world */
  623. get_avg_money(wp)
  624.       Sworld *wp;
  625. {
  626.   Snation *np;
  627.   int i, n_nations = 0, total = 0;
  628.  
  629.   for (i = 1; i < wp->n_nations; ++i) {
  630.     np = &wp->nations[i];
  631.     if (is_active_ntn(np)) {
  632.       ++n_nations;
  633.       total += np->money;
  634.     }
  635.   }
  636.   return n_nations ? total/n_nations : 0;
  637. }
  638.  
  639. get_avg_metal(wp)
  640.       Sworld *wp;
  641. {
  642.   Snation *np;
  643.   int i, n_nations = 0, total = 0;
  644.  
  645.   for (i = 1; i < wp->n_nations; ++i) {
  646.     np = &wp->nations[i];
  647.     if (is_active_ntn(np)) {
  648.       ++n_nations;
  649.       total += np->metal;
  650.     }
  651.   }
  652.   return n_nations ? total/n_nations : 0;
  653. }
  654.  
  655. get_avg_jewels(wp)
  656.       Sworld *wp;
  657. {
  658.   Snation *np;
  659.   int i, n_nations = 0, total = 0;
  660.  
  661.   for (i = 1; i < wp->n_nations; ++i) {
  662.     np = &wp->nations[i];
  663.     if (is_active_ntn(np)) {
  664.       ++n_nations;
  665.       total += np->jewels;
  666.     }
  667.   }
  668.   return n_nations ? total/n_nations : 0;
  669. }
  670.  
  671. get_avg_food(wp)
  672.       Sworld *wp;
  673. {
  674.   Snation *np;
  675.   int i, n_nations = 0, total = 0;
  676.  
  677.   for (i = 1; i < wp->n_nations; ++i) {
  678.     np = &wp->nations[i];
  679.     if (is_active_ntn(np)) {
  680.       ++n_nations;
  681.       total += np->food;
  682.     }
  683.   }
  684.   return n_nations ? total/n_nations : 0;
  685. }
  686.  
  687. get_avg_civil(wp)
  688.       Sworld *wp;
  689. {
  690.   Snation *np;
  691.   int i, n_nations = 0, total = 0;
  692.  
  693.   for (i = 1; i < wp->n_nations; ++i) {
  694.     np = &wp->nations[i];
  695.     if (is_active_ntn(np)) {
  696.       ++n_nations;
  697.       total += get_n_civil(np);
  698.     }
  699.   }
  700.   return n_nations ? total/n_nations : 0;
  701. }
  702.  
  703. get_avg_soldiers(wp)
  704.       Sworld *wp;
  705. {
  706.   Snation *np;
  707.   int i, n_nations = 0, total = 0;
  708.  
  709.   for (i = 1; i < wp->n_nations; ++i) {
  710.     np = &wp->nations[i];
  711.     if (is_active_ntn(np)) {
  712.       ++n_nations;
  713.       total += get_n_soldiers(np);
  714.     }
  715.   }
  716.   return n_nations ? total/n_nations : 0;
  717. }
  718.  
  719.  
  720. get_avg_sectors(wp)
  721.      Sworld *wp;
  722. {
  723.   Snation *np;
  724.   int i, n_nations = 0, total = 0;
  725.  
  726.   for (i=1; i < wp->n_nations; i++) {
  727.     np = &wp->nations[i];
  728.     if (is_active_ntn(np)) {
  729.       ++n_nations;
  730.       total += np->n_sects;
  731.     }
  732.   }
  733.   return n_nations ? total/n_nations : 0;
  734. }
  735.  
  736.  
  737. get_per_occu_land(wp)
  738.      Sworld *wp;
  739. {
  740.   int x, y, land = 0, n_occu = 0;
  741.  
  742.   for (y = 0; y < wp->ymax; y++)
  743.     for (x = 0; x < wp->xmax; x++)
  744.       if (wp->map[x][y].altitude >= SEA_LEVEL) {
  745.     land++;
  746.     if (wp->map[x][y].owner != 0)
  747.       n_occu++;
  748.       }
  749.   return (n_occu*100)/land;
  750. }
  751.  
  752. get_per_occu_water(wp)
  753.      Sworld *wp;
  754. {
  755.   int x, y, water = 0, n_occu = 0;
  756.  
  757.   for (y = 0; y < wp->ymax; y++)
  758.     for (x = 0; x < wp->xmax; x++)
  759.       if (wp->map[x][y].altitude < SEA_LEVEL) {
  760.     water++;
  761.     if (wp->map[x][y].owner != 0)
  762.       n_occu++;
  763.       }
  764.   if (water != 0) {
  765.     return (n_occu*100)/water;
  766.   } else {
  767.     return 0;
  768.   }
  769. }
  770.  
  771.  
  772.   /* return the number of active nations (including game master) */
  773. get_n_act_ntn(wp)
  774.      Sworld *wp;
  775. {
  776.   int i, total = 0;
  777.  
  778.   for (i = 0; i < wp->n_nations; ++i) {
  779.     if (is_active_ntn(&wp->nations[i])) {
  780.       ++total;
  781.     }
  782.   }
  783.   return total;
  784. }
  785.  
  786. n_workers(sp)
  787.      Ssector *sp;
  788. {
  789.   double race_factor;
  790.  
  791.   race_factor = sqrt(world.nations[sp->owner].race.repro/10.0);
  792.  return min(sp->n_people,
  793.         (int) (desig_map[sp->designation].max_employed*race_factor));
  794. }
  795.  
  796. int emp_desire(np, x, y)    /* desireability for employment */
  797.      Snation *np;
  798.      int x, y;
  799. {
  800.   int unemployed;
  801.   Ssector *sp = &world.map[x][y];
  802.  
  803. /*  unemployed = min(0, n_workers(sp) - sp->n_people); */
  804.     /* what we return is the percentage of people employed */
  805.   return sp->n_people ? (100*n_workers(sp))/sp->n_people : 100;
  806. }
  807.