home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume6 / rndweather < prev    next >
Text File  |  1989-03-25  |  39KB  |  1,341 lines
  1. Newsgroups: comp.sources.misc
  2. From: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  3. Subject: v06i080: Random Weather Generator for RPGs
  4. Reply-To: slocum@hi-csc.UUCP
  5.  
  6. Posting-number: Volume 6, Issue 80
  7. Submitted-by: slocum@hi-csc.UUCP
  8. Archive-name: rndweather
  9.  
  10. This is a random weather generator for use with roleplaying games.
  11. It is customizable, and contains several different climates and
  12. calendars.  See README file for for info.  See Makefile for
  13. instructions on making various versions.
  14.  
  15. Brett Slocum   UUCP: ...uunet!hi-csc!slocum
  16.                Arpa: hi-csc!slocum@uunet.uu.net
  17. "My name is Inigo Montoya. You killed my father. Prepare to die."
  18.  
  19. #--------------------------------CUT HERE-------------------------------------
  20.  
  21.  
  22. # This is a shell archive.  Remove anything before this line, then
  23. # unpack it by saving it in a file and typing "sh file".  (Files
  24. # unpacked will be owned by you and have default permissions.)
  25. #
  26. # This archive contains:
  27. # README Makefile weather.c gregorian.h gulf.h japan.h mid_atlantic.h middle_earth.h n_atlantic.h n_pacific.h s_atlantic.h weather.h
  28.  
  29. echo x - README
  30. cat > "README" << '//E*O*F README//'
  31. When playing roleplaying games (RPGs), it often adds some realism if the GM
  32. can determine what kind of weather is occuring.  This program generates random
  33. weather for a year that is tunable to various climates.  Several example
  34. climates are included: north, south, and mid atlantic, gulf, and north
  35. pacific.
  36.  
  37. In addition, several different calendars are included: Gregorian, medieval
  38. Japanese, and the Middle Earth calendar detailed in the appendices of
  39. Tolkien's The Lord of the Rings.
  40.  
  41. The details of these are provided so that the user can create his or her own
  42. climate profiles or calendars.
  43.  
  44. Please send any improvements, new climate profiles, new calendars, or
  45. better versions of the current climate profiles to one of the addresses below.
  46.  
  47. -----------------------------------------------------------------
  48. Brett Slocum   UUCP: ...uunet!hi-csc!slocum
  49.                Arpa: hi-csc!slocum@uunet.uu.net
  50. "My name is Inigo Montoya. You killed my father. Prepare to die."
  51. -----------------------------------------------------------------
  52.  
  53. //E*O*F README//
  54.  
  55. echo x - Makefile
  56. cat > "Makefile" << '//E*O*F Makefile//'
  57. # Makefile: makefile for weather.c
  58. # 
  59. # make <choice>
  60. # will create a specific climate program.
  61. #
  62. # make
  63. # will create 'england', an English climate program.
  64. #
  65. # make all
  66. # will create all climate programs.
  67. #
  68. # To make addition climate programs, just add the calendar
  69. # and climate choices as -D options.
  70. #
  71. # Calendar choices:
  72. # 
  73. # GREGORIAN - uses essentially modern calendar, without leap years.
  74. #
  75. # JAPAN     - uses medieval Japanese calendar.
  76. #
  77. # MIDDLE_EARTH - uses calendar described in appendices of Tolkien's
  78. #                'The Lord of the Rings'.
  79. #
  80. # Climate choices:
  81. #
  82. # N_ATLANTIC   - useful for Scandinavia coastal or interior continential US
  83. #                or Europe.
  84. # MID_ATLANTIC - useful for England, European coastal, New England, etc.
  85. # S_ATLANTIC   - useful for Spain, Southern coastal US
  86. # GULF         - useful for Gulf States, Mediterranean, etc.
  87. # N_PACIFIC    - useful for Japan, Korea, Southern Alaskan coast, etc.
  88.  
  89. england: weather.c weather.h gregorian.h mid_atlantic.h
  90.     cc -DGREGORIAN -DMID_ATLANTIC -o england -g weather.c
  91.  
  92. minnesota: weather.c weather.h gregorian.h n_atlantic.h
  93.     cc -DGREGORIAN -DN_ATLANTIC -o minnesota -g weather.c
  94.  
  95. japan: weather.c weather.h japan.h n_pacific.h
  96.     cc -DJAPAN -DN_PACIFIC -o japan -g weather.c
  97.  
  98. florida: weather.c weather.h gregorian.h gulf.h
  99.     cc -DGREGORIAN -DGULF -o florida -g weather.c
  100.  
  101. shire: weather.c weather.h middle_earth.h mid_atlantic.h
  102.     cc -DMIDDLE_EARTH -DMID_ATLANTIC -o shire -g weather.c
  103.  
  104. georgia: weather.c weather.h gregorian.h s_atlantic.h
  105.     cc -DGREGORIAN -DS_ATLANTIC -o georgia -g weather.c
  106.  
  107. all: england minnesota japan florida shire georgia
  108.  
  109. //E*O*F Makefile//
  110.  
  111. echo x - weather.c
  112. cat > "weather.c" << '//E*O*F weather.c//'
  113. /**************************************************************************
  114.  *  Weather - generates random weather                                    *
  115.  *                                                                        *
  116.  *  Copyright 1988 by Brett Slocum.  All rights reserved.                 *
  117.  *  Permission is granted to distribute or modify this program, or use    *
  118.  *  portions of this program in other programs, as long as this notice    *
  119.  *  remains intact.                                                       *
  120.  *  This program or its derivatives may not be sold for profit without    *
  121.  *  permission of the author.                                             *
  122.  *                                                                        *
  123.  *  Original UNIX Version: Brett Slocum UUCP: ...uunet!hi-csc!slocum      *
  124.  *                                      ARPA: hi-csc!slocum@uunet.uu.net  *
  125.  *                                                                        *
  126.  **************************************************************************/
  127.  
  128. #include "weather.h"
  129.  
  130. typedef UBYTE MONTH_T;
  131.  
  132. /* Calendar choices */
  133. #ifdef GREGORIAN
  134. #include "gregorian.h"
  135. #else
  136. #ifdef JAPAN
  137. #include "japan.h"
  138. #else
  139. #ifdef MIDDLE_EARTH
  140. #include "middle_earth.h"
  141. #endif
  142. #endif
  143. #endif
  144.  
  145. /* Climate choices */
  146. #ifdef N_ATLANTIC
  147. #include "n_atlantic.h"
  148. #else
  149. #ifdef MID_ATLANTIC
  150. #include "mid_atlantic.h"
  151. #else
  152. #ifdef S_ATLANTIC
  153. #include "s_atlantic.h"
  154. #else
  155. #ifdef GULF
  156. #include "gulf.h"
  157. #else
  158. #ifdef N_PACIFIC
  159. #include "n_pacific.h"
  160. #endif
  161. #endif
  162. #endif
  163. #endif
  164. #endif
  165.  
  166. UBYTE Stat_Table[N_MONTHS][N_STAT] = {
  167.     {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, 
  168.     {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}
  169. };
  170.  
  171. WIND_T     Wind = CALM;          /* today's wind conditions */
  172. TEMP_T     Temp_Class = CHILLY;  /* today's temperature class */
  173. PRECIP_T   Precip_Class = NONE;  /* today's precipitation */
  174. WEATHER_T  Weather;              /* today's weather */
  175. OVERCAST_T Sky;                  /* today's sky conditions */
  176.  
  177. UBYTE Temperature = 0,           /* today's actual temperature */
  178.       Duration = 0;              /* today's precipitation duration */
  179.  
  180. BOOL Duration_Hours = TRUE,      /* flag that indicates whether precip lasted */
  181.                                  /* hours (TRUE) or minutes (FALSE) */
  182.      Catastrophe = FALSE,        /* flag that indicates whether a catastrophe */
  183.                                  /* occurred today */
  184.      Storm = FALSE,              /* flag that indicates whether precip was a storm */
  185.      Long_Storm = FALSE,         /* flag that indicates whether precip was a */
  186.                                  /* long storm lasting more than one day */
  187.      Snow = FALSE;               /* flag that indicates whether snow fell today */
  188.  
  189. float Rainfall = 0.0,            /* yearly total rainfall */
  190.       Snowfall = 0.0,            /* yearly total snowfall */
  191.       Snow_Depth = 0.0;          /* today's snow depth, including new accumulations */
  192.                                  /* and melting */
  193.  
  194. WEATHER_T 
  195. gen_weather(month, ptr_catastrophe)
  196.     MONTH_T month;
  197.     BOOL *ptr_catastrophe;
  198.     /* This routine generates the overall weather for the day. */
  199.     /* It also determines whether a catastrophe has occurred.  */
  200.     /* A catastrophe can be localized or wide-spread, natural  */
  201.     /* or man-made. Such things as fires, earthquakes, floods, */
  202.     /* etc. are possible.                                      */
  203. {
  204.      int       roll;
  205.      WEATHER_T i, 
  206.                return_val;
  207.  
  208.      /* get die-roll.  if catastrophe, set flag and roll again. */
  209.      do {  
  210.          roll = DIE(100);
  211.          if (roll == 100)
  212.              *ptr_catastrophe = TRUE;
  213.      }
  214.      while (roll == 100);
  215.  
  216.      /* if it rained more than a sprinkle yesterday, it more likely */
  217.      /* to be at least overcast, if not rainy today. */
  218.      if (Precip_Class > SPRINKLE) {
  219.          roll = roll - 10;
  220.          if (roll < 1)
  221.              roll = 1;
  222.      }
  223.  
  224.      /* find the type of weather from the die-roll */
  225.      return_val = CLEAR;
  226.      for (i = CLEAR; i >= PRECIPITATION; i--)
  227.          if (roll <= Weather_Table[month][i])
  228.              return_val = i;
  229.      return(return_val);
  230. }
  231.  
  232. TEMP_T 
  233. gen_temp(month)
  234.     MONTH_T month;
  235.     /* generates the day's temperature and set the temp type */
  236. {
  237.      int roll, data, i;
  238.      TEMP_T return_val;
  239.  
  240.      /* determine temperature variation from monthly average */
  241.      /*   +/- 20 degrees */
  242.      roll = DIE(100);
  243.      data = 8;
  244.      for (i = 8; i >= 0; i--)
  245.          if (roll <= Temp_Variation[i])
  246.              data = i;
  247.      Temperature = Ave_Temp[month] + ((data-4) * 5);
  248.  
  249.      /* classify the temperature class */
  250.      if (Temperature < 25) 
  251.          return_val = COLD;
  252.      else
  253.      if ((Temperature >= 25) AND (Temperature < 40)) 
  254.          return_val = CHILLY;
  255.      else
  256.      if ((Temperature >= 40) AND (Temperature < 65)) 
  257.          return_val = FAIR;
  258.      else
  259.      if ((Temperature >= 65) AND (Temperature < 80)) 
  260.          return_val = WARM;
  261.      else
  262.      if (Temperature >= 80) 
  263.          return_val = HOT;
  264.  
  265.      /* accumulate monthly statistics */
  266.      Stat_Table[month][HIGH] = MAX(Temperature, Stat_Table[month][HIGH]);
  267.      Stat_Table[month][LOW] = MIN(Temperature, Stat_Table[month][LOW]);
  268.      return(return_val);
  269. }
  270.  
  271. WIND_T
  272. gen_wind(month)
  273.     MONTH_T month;
  274.     /* generate the wind class */
  275. {
  276.      int roll;
  277.      WIND_T return_val, i;
  278.  
  279.      /* modify the roll for current weather.  Clear weather is less likely */
  280.      /* to be windy, and rainy weather is more likely. */
  281.      roll = DIE(100);
  282.      switch (Weather) {
  283.      case CLEAR : 
  284.          roll -= 20;
  285.          break;
  286.      case PRECIPITATION:
  287.          roll += 20;
  288.          break;
  289.      } /* switch */
  290.  
  291.      /* if yesterday was very windy, today will be windier */
  292.      if (Wind >= BLUSTERY) 
  293.          roll += 20;
  294.  
  295.      /* limit to boundaries 1-100 */
  296.      if (roll < 1) 
  297.          roll = 1;
  298.      if (roll > 100) 
  299.          roll = 100;
  300.  
  301.      /* find wind type */
  302.      return_val = GALE;
  303.      for (i = GALE; i >= CALM; i--)
  304.          if (roll <= Wind_Table[month][i]) 
  305.              return_val = i;
  306.      if (Weather == TAIFUN) 
  307.          return_val = GALE;
  308.      return(return_val);
  309.  }
  310.  
  311. PRECIP_T
  312. gen_precip(month)
  313.     MONTH_T month;
  314.     /* generate today's precipitation */
  315. {
  316.      int roll;
  317.      PRECIP_T return_val, i;
  318.  
  319.      return_val = NONE;
  320.      if (Weather == PRECIPITATION)
  321.      {
  322.          roll = DIE(100);
  323.          return_val = STEADY;
  324.          for (i = STEADY; i >= SPRINKLE; i--)
  325.              if (roll <= Precip_Table[month][i])
  326.                  return_val = i;
  327.      }
  328.  
  329.      /* if yesterday had steady precipitation, there is a 1/3 chance */ 
  330.      /* on the second day and 1/6 chance on succeeding days that today */
  331.      /* also has steady precipitation */
  332.      if ((Precip_Class == STEADY) AND (DIE(6) <= 2 - Long_Storm))
  333.      {
  334.          Weather = PRECIPITATION;
  335.          return_val = STEADY;
  336.      }
  337.  
  338.      return(return_val);
  339. }
  340.  
  341. void
  342. precip_statistics()
  343.      /* determines various flags including Snow, Storm and Long_Storm. */
  344.      /* Also determines precipitation duration and amount, updates */
  345.      /* yearly Rainfall and Snowfall statistics, daily Snow_Depth, */
  346.      /* and snow melting */
  347. {
  348.      float amount;
  349.  
  350.      if (Weather == PRECIPITATION)
  351.      {
  352.          /* set flags */
  353.          if (Precip_Class != STEADY) 
  354.              Long_Storm = FALSE;
  355.          if (Temperature < 35)
  356.              Snow = TRUE;
  357.          else
  358.              Snow = FALSE;
  359.          if ((Temp_Class >= WARM) AND ((Precip_Class == SHOWER) OR (Precip_Class == HEAVY)))
  360.              Storm = TRUE;
  361.          else
  362.              Storm = FALSE;
  363.          if (Snow AND (Precip_Class >= HEAVY) AND (Wind >= BLUSTERY))
  364.              Storm = TRUE;
  365.  
  366.          /* determine duration and amount of precipitation */
  367.          switch (Precip_Class) {
  368.          case SPRINKLE :
  369.              Duration = 5 * DIE(6);
  370.              Duration_Hours = FALSE;
  371.              amount = 0.1;
  372.              break;
  373.          case SHOWER :
  374.              Duration = 10 * (DIE(6) + DIE(6));
  375.              Duration_Hours = FALSE;
  376.              amount = Duration / 100;
  377.              break;
  378.          case HEAVY : 
  379.              Duration = 1 + DIE(6);
  380.              Duration_Hours = TRUE;
  381.              amount = (DIE(4) + (Storm * Duration));
  382.              break;
  383.          case STEADY :
  384.              Duration = 24;
  385.              Duration_Hours = TRUE;
  386.              amount = (DIE(6) + DIE(6)) + (Storm * (DIE(6) + DIE(6))); 
  387.              break;
  388.          }
  389.          if (Storm)
  390.              amount *= 2.0;
  391.  
  392.          /* update yearly and daily statistics */
  393.          Rainfall += (amount / 10);
  394.          if (Snow)
  395.              {
  396.                  Snow_Depth += amount;
  397.                  Snowfall += amount;
  398.              }
  399.          else
  400.              switch (Precip_Class) {
  401.              case SHOWER : 
  402.                  Snow_Depth -= Duration / 60;
  403.                  break;
  404.              case HEAVY : 
  405.                  Snow_Depth -= Duration;
  406.                  break;
  407.              case STEADY :
  408.                  Snow_Depth -= 12;
  409.                  break;
  410.              }
  411.      }
  412.  
  413.      /* melt snow in weather above freezing */
  414.      switch (Temp_Class) {
  415.      case CHILLY :
  416.          if (Temperature > 32) 
  417.              Snow_Depth -= 1.0;
  418.          break;
  419.      case FAIR :
  420.          Snow_Depth -= Temperature / 8;
  421.          break;
  422.      case WARM :
  423.          Snow_Depth -= Temperature - 40;
  424.          break;
  425.      case HOT : 
  426.          Snow_Depth -= Temperature - 20;
  427.          break;
  428.      }
  429.      if (Snow_Depth < 0.1)
  430.          Snow_Depth = 0.0;
  431. }
  432.  
  433. OVERCAST_T
  434. gen_overcast(weather)
  435.     WEATHER_T weather;
  436.     /* generate today's level of cloudiness */
  437. {
  438.      int roll;
  439.      OVERCAST_T return_val, i;
  440.  
  441.      return_val = CLOUDY;
  442.      switch (weather) {
  443.      case PRECIPITATION:
  444.      case OVERCAST :
  445.           roll = DIE(100);
  446.           return_val = CLOUDY;
  447.           for (i = CLOUDY; i >= HEAVY_FOG; i--)
  448.               if (roll <= Overcast_Table[i])
  449.                   return_val = i;
  450.           break;
  451.      case TAIFUN : return_val = CLOUDY;
  452.      }
  453.      return(return_val);
  454. }
  455.  
  456. void
  457. print_notes(day, month)
  458.     UBYTE day;
  459.     MONTH_T month;
  460.     /* print snow depth, precipitation type and duration, */
  461.     /* catastrophe, and holidays */
  462. {
  463.      char *precip,
  464.           *dur;
  465.  
  466.      if (Precip_Class != NONE) 
  467.      {
  468.          if (Snow) 
  469.              precip = (Storm ? "Blizzard" : "Snow");
  470.          else
  471.              precip = (Storm ? "Storm" : "Rain");
  472.          dur = (Duration_Hours ? "hours" : "minutes");
  473.          printf(" %s - %2d %s,", precip, Duration, dur);
  474.      }
  475.      if (Catastrophe)
  476.          printf(" Catastrophe,");
  477.      print_holiday(day, month);
  478. }
  479.  
  480. void
  481. print_weather(day, month)
  482.     UBYTE day;
  483.     MONTH_T month;
  484.     /* print today's weather */
  485. {
  486.      printf("%4d  %13s", day, Weather_Name[Weather]);
  487.      printf("%11s", ((Weather==CLEAR) ? "Clear" : Overcast_Name[Sky]));
  488.      printf("%8s (%3d)  %8s  %8s", Temp_Name[Temp_Class], Temperature, Precip_Name[Precip_Class], Wind_Name[Wind]);
  489.      if (Snow_Depth > 0.0) 
  490.          printf(" %5.1f\" ", Snow_Depth);
  491.      else
  492.          printf("%8c", ' ');
  493.      print_notes(day, month);
  494.      printf("\n");
  495.  }
  496.  
  497. void
  498. init_winter()
  499.      /* initialize last year's winter */
  500. {
  501.      UBYTE day;
  502.      MONTH_T month;
  503.  
  504.      /* calculate snow depth for Oct. thru Dec. */
  505.      for (month = LAST_MONTH-2; month <= LAST_MONTH; month++)
  506.          for (day = 1; day <= Day_Table[month]; day++)
  507.          {
  508.              Catastrophe = FALSE;
  509.              if (DIE(100) > 50) 
  510.                  Weather = gen_weather(month, &Catastrophe);
  511.              Wind = gen_wind(month);
  512.              Temp_Class = gen_temp(month);
  513.              Precip_Class = gen_precip(month);
  514.              precip_statistics();
  515.              Sky = gen_overcast(Weather);
  516.          }
  517. }
  518.  
  519. init_stat()
  520. {
  521.     MONTH_T month;
  522.     STAT_T stat;
  523.  
  524.     for (month = FIRST_MONTH; month <= LAST_MONTH; month++)
  525.     {
  526.         Stat_Table[month][LOW] = 200;
  527.         for (stat = AVERAGE; stat <= HIGH; stat++)
  528.             Stat_Table[month][stat] = 0;
  529.     }
  530. }
  531.  
  532. main(argc, argv)  
  533. int argc;
  534. char *argv[];
  535. {
  536.      int cum_temp;               /* cumulative temp used for calculating average temp */
  537.      unsigned int sunshine = 0;  /* number of days of sunshine */
  538.      MONTH_T month;              /* month counter */
  539.      UBYTE day,                  /* day counter */
  540.            year,                 /* year counter */
  541.            n_years = 1;          /* number of years */
  542.  
  543.      srandom((int)time(0));
  544.      if (argc > 1)
  545.          n_years = atoi(argv[1]);
  546.      init_winter();
  547.      for (year = 1; year <= n_years; year++)
  548.      {
  549.          Rainfall = 0.0;
  550.          Snowfall = 0.0;
  551.          sunshine = 0;
  552.          init_stat();
  553.          printf("%64c%6s\n", ' ',"Snow");
  554.          printf("Year %3d%11s%11s%14s%10s%10s%7s%7s\n", year, "Weather", "Sky", "Temperature", "Precip", "Wind", "Depth", "Notes");
  555.          for (month = FIRST_MONTH; month <= LAST_MONTH; month++)
  556.          {
  557.              cum_temp = 0;
  558.              printf("%-9s\n", Month_Name[month]);
  559.              for (day = 1; day <= Day_Table[month]; day++)
  560.              {
  561.                  Catastrophe = FALSE;
  562.     
  563.                  /* half the time, Weather is the same as yesterday */
  564.                  if (DIE(100) > 50) 
  565.                      Weather = gen_weather(month, &Catastrophe);
  566.                  Wind = gen_wind(month);
  567.                  Temp_Class = gen_temp(month);
  568.                  cum_temp += Temperature;
  569.                  Precip_Class = gen_precip(month);
  570.                  precip_statistics();
  571.                  Sky = gen_overcast(Weather);
  572.     
  573.                  /* count sunny days */
  574.                  if (Weather == CLEAR) 
  575.                      sunshine++;
  576.                  print_weather(day, month);
  577.              }
  578.              Stat_Table[month][AVERAGE] = (cum_temp / Day_Table[month]);
  579.              printf("High Temp = %3d, Low Temp = %3d, Average Temp = %3d\n\n", Stat_Table[month][HIGH], Stat_Table[month][LOW], Stat_Table[month][AVERAGE]);
  580.          }
  581.          /* print yearly statistics */
  582.          printf("Sunshine = %3d days\n", sunshine);
  583.          printf("Rainfall = %4.1f\"\n", Rainfall);
  584.          printf("Snowfall = %4.1f\"\n\n", Snowfall);
  585.      }
  586. }
  587.  
  588. //E*O*F weather.c//
  589.  
  590. echo x - gregorian.h
  591. cat > "gregorian.h" << '//E*O*F gregorian.h//'
  592. /* Copyright 1988 by Brett D. Slocum - 12/12/88 */
  593. /* All rights reserved */
  594. /* This is the calendar include file is for weather generation */
  595. /* It includes calendar and holiday information */
  596.  
  597. /* To create a new calendar file, 
  598.        1) define month names for use by MONTH_T type,
  599.        2) define FIRST_MONTH and LAST_MONTH,
  600.        3) define string array Month_Name with printable version of month,
  601.        4) define number of days per month array Day_Table,
  602.        5) add printf statements in print_holidays for holidays
  603. */
  604.  
  605. /* Month types */
  606. #define JANUARY   0
  607. #define FEBRUARY  1
  608. #define MARCH     2
  609. #define APRIL     3
  610. #define MAY       4
  611. #define JUNE      5
  612. #define JULY      6
  613. #define AUGUST    7
  614. #define SEPTEMBER 8
  615. #define OCTOBER   9
  616. #define NOVEMBER  10
  617. #define DECEMBER  11
  618.  
  619. #define FIRST_MONTH JANUARY
  620. #define LAST_MONTH  DECEMBER
  621.  
  622. #define N_MONTHS (LAST_MONTH - FIRST_MONTH) + 1
  623.  
  624. char *Month_Name[N_MONTHS] = {
  625.     "January", 
  626.     "February",
  627.     "March",
  628.     "April",
  629.     "May",
  630.     "June",
  631.     "July",
  632.     "August",
  633.     "September",
  634.     "October",
  635.     "November",
  636.     "December"
  637. };
  638.  
  639. UBYTE Day_Table[N_MONTHS] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  640.  
  641. void
  642. print_holiday(day, month)
  643.     UBYTE day;
  644.     MONTH_T month;
  645. {
  646.      switch (month) {
  647.      case JANUARY : 
  648.          if (day == 1) 
  649.              printf(" New Years (s)");
  650.          if (day == 6) 
  651.              printf(" Twelfth Night");
  652.          break;
  653.      case FEBRUARY : 
  654.          if (day == 2) 
  655.              printf(" Candlemas");
  656.          if (day == 14) 
  657.              printf(" St. Valentine's Day");
  658.          break;
  659.      case MARCH : 
  660.          if (day == 21) 
  661.              printf(" Spring Equinox");
  662.          break;
  663.      case APRIL : 
  664.          break;
  665.      case MAY : 
  666.          if (day == 1) 
  667.              printf(" May Day");
  668.          break;
  669.      case JUNE : 
  670.          if (day == 21) 
  671.              printf(" Midsummer Day");
  672.          break;
  673.      case JULY : 
  674.          break;
  675.      case AUGUST : 
  676.          if (day == 2) 
  677.              printf(" Lammas");
  678.          break;
  679.      case SEPTEMBER : 
  680.          if (day == 21) 
  681.              printf(" Fall Equinox");
  682.          break;
  683.      case OCTOBER : 
  684.          if (day == 31) 
  685.              printf(" Halloween");
  686.          break;
  687.      case NOVEMBER : 
  688.          break;
  689.      case DECEMBER : 
  690.          if (day == 21) 
  691.              printf(" Winter Solstice");
  692.          if (day == 25) 
  693.              printf(" Christmas");
  694.          break;
  695.      }
  696. }
  697.  
  698. //E*O*F gregorian.h//
  699.  
  700. echo x - gulf.h
  701. cat > "gulf.h" << '//E*O*F gulf.h//'
  702. /* Most of the info provided in this file could be found in an almanac. */
  703.  
  704. /* Ave_Temp       - the average temperature for each month */
  705. /* Weather_Table  - each entry in the table is the weather profile for each month */
  706. /*                  for a random 1-100 die roll. */
  707. /*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
  708. /*        example - {30,35,0,100} means that in this month a roll of : */
  709. /*                  1-30  = precipitation        */
  710. /*                 31-35  = overcast             */
  711. /*                 no chance of taifun/hurricane */
  712. /*                 36-100 = clear                */
  713.  
  714. /* Wind_Table     - is structured like the Weather_Table. */
  715. /*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */
  716.  
  717. /* Precip_Table   - as above */
  718. /*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */
  719.  
  720. /* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */
  721.  
  722. UBYTE Ave_Temp[N_MONTHS] = {65, 70, 75, 80, 85, 95, 95, 90, 85, 75, 70, 65};
  723.  
  724. UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
  725.     {30,35,0,100}, {25,35,0,100}, {20,30,0,100}, {35,50,0,100}, {25,40,0,100}, {15,25,0,100}, 
  726.     {10,15,0,100}, {10,15,0,100}, {15,25,0,100}, {25,35,0,100}, {25,40,0,100}, {30,45,0,100}
  727. };
  728.  
  729. UBYTE Wind_Table[N_MONTHS][N_WIND] = {
  730.     {60,80,90,100,0}, {50,70,85,100,0}, {40,60,75,99,100}, {60,85,95,100,0}, {70,90,100,0,0}, {80,90,100,0,0}, 
  731.     {80,100,0,0,0}, {80,100,0,0,0}, {60,80,95,100,0}, {40,65,85,97,100}, {40,60,80,95,100}, {60,80,90,100,0}
  732. };
  733.  
  734. UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
  735.     {0,40,70,80,100},
  736.     {0,50,80,95,100},
  737.     {0,60,80,100,0},
  738.     {0,40,70,90,100},
  739.     {0,50,80,100,0},
  740.     {0,60,90,100,0},
  741.     {0,80,95,100,0},
  742.     {0,80,95,100,0},
  743.     {0,60,80,90,100},
  744.     {0,50,80,90,100},
  745.     {0,40,70,85,100},
  746.     {0,40,70,80,100}
  747. };
  748.  
  749. UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};
  750.  
  751.  
  752. //E*O*F gulf.h//
  753.  
  754. echo x - japan.h
  755. cat > "japan.h" << '//E*O*F japan.h//'
  756. /* Copyright 1988 by Brett D. Slocum - 12/12/88 */
  757. /* All rights reserved */
  758. /* This is the calendar include file is for weather generation */
  759. /* It includes calendar and holiday information */
  760.  
  761. /* To create a new calendar file, 
  762.        1) define month names for use by MONTH_T type,
  763.        2) define FIRST_MONTH and LAST_MONTH,
  764.        3) define string array Month_Name with printable version of month,
  765.        4) define number of days per month array Day_Table,
  766.        5) add printf statements in print_holidays for holidays
  767. */
  768.  
  769. /* Month types */
  770. #define RAT    0
  771. #define BULL   1
  772. #define TIGER  2
  773. #define HARE   3
  774. #define DRAGON 4
  775. #define SNAKE  5
  776. #define HORSE  6
  777. #define SHEEP  7
  778. #define MONKEY 8
  779. #define BIRD   9
  780. #define DOG    10
  781. #define BOAR   11
  782.  
  783. #define FIRST_MONTH RAT
  784. #define LAST_MONTH  BOAR
  785.  
  786. #define N_MONTHS (LAST_MONTH - FIRST_MONTH) + 1
  787.  
  788. /* text version of month names */
  789. char *Month_Name[N_MONTHS] = {
  790.     "Rat",
  791.     "Bull",
  792.     "Tiger",
  793.     "Hare",
  794.     "Dragon",
  795.     "Snake",
  796.     "Horse",
  797.     "Sheep",
  798.     "Monkey",
  799.     "Bird",
  800.     "Dog",
  801.     "Boar"
  802. };
  803.  
  804. /* table of days per month */
  805. UBYTE Day_Table[N_MONTHS] = {29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30};
  806.  
  807. void
  808. print_holiday(day,month)
  809.     UBYTE day;
  810.     MONTH_T month;
  811.     /* prints holidays that fall on a given day */
  812. {
  813.      if (day == 15)
  814.          printf(" Full Moon,");
  815.      if (day == Day_Table[month])
  816.          printf(" New Moon,");
  817.      switch (day) { 
  818.      case 1:
  819.      case 15 : printf(" Shinto,");
  820.           break;
  821.      case 8:
  822.      case 18 : printf(" Buddhist,");
  823.           break;
  824.      case 28 : printf(" Buddhist, Shinto,");
  825.           break;
  826.      }
  827.      switch (month) {
  828.      case RAT : 
  829.          if ((day >= 1) AND (day <= 6))
  830.              printf(" New Years (s)");
  831.          break;
  832.      case BULL :
  833.          switch (day) { 
  834.          case 1: case 2: case 4: case 5: case 6: case 7:
  835.              printf(" Equinox (b)");
  836.              break;
  837.          case 3: 
  838.              printf(" Setsuban (1st Day of Spring) (s)");
  839.              break;
  840.          }
  841.          break;
  842.      case TIGER :
  843.          if (day == 3) 
  844.              printf(" Doll Festival (c)");
  845.          break;
  846.      case HARE :
  847.          if (day == 8)
  848.              printf(" Buddha's Birthday (b)");
  849.          break;
  850.      case DRAGON :
  851.          if (day == 5) 
  852.              printf(" Boy's Day (c)");
  853.          break;
  854.      case SNAKE :
  855.          switch (day) {
  856.          case 1: case 2: case 3: case 4: case 5: case 6: case 7: 
  857.              printf(" Rice Planting Festival (p)");
  858.              break;
  859.          case 30 : 
  860.              printf(" All debts paid (p)");
  861.          }
  862.          break;
  863.      case HORSE :
  864.          switch (day) {
  865.          case 1 : 
  866.              printf(" Midyear (p)");
  867.              break;
  868.          case 7 : 
  869.              printf(" Tanabata (Star Festival) (c)");
  870.              break;
  871.          case 13: case 14: case 15: 
  872.              printf(" Bon Festival (for the dead) (b)");
  873.          }
  874.          break;
  875.      case SHEEP :
  876.          if ((day >= 1) AND (day <= 7)) 
  877.              printf(" Equinox (b)");
  878.          break;
  879.      case BIRD :
  880.          switch (day) { 
  881.          case 15 : 
  882.               printf(" Rice Harvest Festival (p)");
  883.               break;
  884.          case 20 : 
  885.               printf(" Festival of Ebishu (s)");
  886.          } 
  887.          break;
  888.      case DOG :
  889.          if (day == 8) 
  890.              printf(" Feast of the Bellows (s)");
  891.          break;
  892.      case BOAR :
  893.          if (day == 30) 
  894.              printf(" All debts paid (p)");
  895.      }
  896. }
  897.  
  898. //E*O*F japan.h//
  899.  
  900. echo x - mid_atlantic.h
  901. cat > "mid_atlantic.h" << '//E*O*F mid_atlantic.h//'
  902. /* Most of the info provided in this file could be found in an almanac. */
  903.  
  904. /* Ave_Temp       - the average temperature for each month */
  905. /* Weather_Table  - each entry in the table is the weather profile for each month */
  906. /*                  for a random 1-100 die roll. */
  907. /*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
  908. /*        example - {30,35,0,100} means that in this month a roll of : */
  909. /*                  1-30  = precipitation        */
  910. /*                 31-35  = overcast             */
  911. /*                 no chance of taifun/hurricane */
  912. /*                 36-100 = clear                */
  913.  
  914. /* Wind_Table     - is structured like the Weather_Table. */
  915. /*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */
  916.  
  917. /* Precip_Table   - as above */
  918. /*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */
  919.  
  920. /* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */
  921.  
  922. UBYTE Ave_Temp[N_MONTHS] = {20, 35, 45, 55, 65, 75, 85, 80, 65, 50, 35, 25};
  923.  
  924. UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
  925.     {30,35,0,100}, {25,35,0,100}, {20,30,0,100}, {35,50,0,100}, {25,40,0,100}, {15,25,0,100}, 
  926.     {10,15,0,100}, {10,15,0,100}, {15,25,0,100}, {25,35,0,100}, {25,40,0,100}, {30,45,0,100}
  927. };
  928.  
  929. UBYTE Wind_Table[N_MONTHS][N_WIND] = {
  930.     {60,80,90,100,0}, {50,70,85,100,0}, {40,60,75,95,100}, {60,85,95,100,0}, {70,90,100,0,0}, {80,90,100,0,0}, 
  931.     {80,100,0,0,0}, {80,100,0,0,0}, {60,80,95,100,0}, {40,65,85,95,100}, {40,60,80,90,100}, {60,80,90,95,100}
  932. };
  933.  
  934. UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
  935.     {0,40,70,80,100},
  936.     {0,50,80,95,100},
  937.     {0,60,80,100,0},
  938.     {0,40,70,90,100},
  939.     {0,50,80,100,0},
  940.     {0,60,90,100,0},
  941.     {0,80,95,100,0},
  942.     {0,80,95,100,0},
  943.     {0,60,80,90,100},
  944.     {0,50,80,90,100},
  945.     {0,40,70,85,100},
  946.     {0,40,70,80,100}
  947. };
  948.  
  949. UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};
  950.  
  951.  
  952. //E*O*F mid_atlantic.h//
  953.  
  954. echo x - middle_earth.h
  955. cat > "middle_earth.h" << '//E*O*F middle_earth.h//'
  956. /* Copyright 1988 by Brett D. Slocum - 12/12/88 */
  957. /* All rights reserved */
  958. /* This is the calendar include file is for weather generation */
  959. /* It includes calendar and holiday information */
  960.  
  961. /* To create a new calendar file, 
  962.        1) define month names for use by MONTH_T type,
  963.        2) define FIRST_MONTH and LAST_MONTH,
  964.        3) define string array Month_Name with printable version of month,
  965.        4) define number of days per month array Day_Table,
  966.        5) add printf statements in print_holidays for holidays
  967. */
  968.  
  969. /* Month types */
  970. #define AFTERYULE   0
  971. #define SOLMATH     1
  972. #define RETHE       2
  973. #define ASTRON      3
  974. #define THRIMIDGE   4
  975. #define FORELITHE   5
  976. #define AFTERLITHE  6
  977. #define WEDMATH     7
  978. #define HALIMATH    8
  979. #define WINTERFILTH 9
  980. #define BLOTMATH    10
  981. #define FOREYULE    11
  982.  
  983. #define FIRST_MONTH AFTERYULE
  984. #define LAST_MONTH  FOREYULE
  985.  
  986. #define N_MONTHS (LAST_MONTH - FIRST_MONTH) + 1
  987.  
  988. char *Month_Name[N_MONTHS] = {
  989.     "Afteryule",
  990.     "Solmath",
  991.     "Rethe",
  992.     "Astron",
  993.     "Thrimidge",
  994.     "Forelithe",
  995.     "Afterlithe",
  996.     "Wedmath",
  997.     "Halimath",
  998.     "Winterfilth",
  999.     "Blotmath",
  1000.     "Foreyule",
  1001. };
  1002.  
  1003. UBYTE Day_Table[N_MONTHS] = {30, 30, 30, 30, 30, 31, 30, 30, 30, 30, 30, 34};
  1004.  
  1005. void
  1006. print_holiday(day, month)
  1007.     UBYTE day;
  1008.     MONTH_T month;
  1009. {
  1010.      switch (month) {
  1011.      case AFTERYULE:
  1012.          break;
  1013.      case SOLMATH:
  1014.          break;
  1015.      case RETHE:
  1016.          break;
  1017.      case ASTRON:
  1018.          break;
  1019.      case THRIMIDGE:
  1020.          break;
  1021.      case FORELITHE:
  1022.          if (day == 31) 
  1023.              printf(" Midsummer Day");
  1024.          break;
  1025.      case AFTERLITHE:
  1026.          break;
  1027.      case WEDMATH:
  1028.          break;
  1029.      case HALIMATH:
  1030.          break;
  1031.      case WINTERFILTH:
  1032.          break;
  1033.      case BLOTMATH:
  1034.          break;
  1035.      case FOREYULE:
  1036.          if ((day >= 31) AND (day <= 34))
  1037.              printf(" Yule");
  1038.          break;
  1039.      }
  1040. }
  1041.  
  1042. //E*O*F middle_earth.h//
  1043.  
  1044. echo x - n_atlantic.h
  1045. cat > "n_atlantic.h" << '//E*O*F n_atlantic.h//'
  1046. /* Most of the info provided in this file could be found in an almanac. */
  1047.  
  1048. /* Ave_Temp       - the average temperature for each month */
  1049. /* Weather_Table  - each entry in the table is the weather profile for each month */
  1050. /*                  for a random 1-100 die roll. */
  1051. /*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
  1052. /*        example - {30,35,0,100} means that in this month a roll of : */
  1053. /*                  1-30  = precipitation        */
  1054. /*                 31-35  = overcast             */
  1055. /*                 no chance of taifun/hurricane */
  1056. /*                 36-100 = clear                */
  1057.  
  1058. /* Wind_Table     - is structured like the Weather_Table. */
  1059. /*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */
  1060.  
  1061. /* Precip_Table   - as above */
  1062. /*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */
  1063.  
  1064. /* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */
  1065.  
  1066. UBYTE Ave_Temp[N_MONTHS] = {10, 15, 25, 40, 55, 70, 85, 80, 60, 35, 20, 15};
  1067.  
  1068. UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
  1069.     {30,40,0,100}, /* January or the first month in non-Gregorian calendar */
  1070.     {25,35,0,100}, /* February */
  1071.     {20,30,0,100}, /* March */
  1072.     {35,50,0,100}, /* April */
  1073.     {25,40,0,100}, /* May */
  1074.     {15,25,0,100}, /* June */
  1075.     {10,15,0,100}, /* July */
  1076.     {10,15,0,100}, /* August */
  1077.     {15,30,0,100}, /* September */
  1078.     {25,40,0,100}, /* October */
  1079.     {25,40,0,100}, /* November */
  1080.     {30,45,0,100}  /* December */
  1081. };
  1082.  
  1083. UBYTE Wind_Table[N_MONTHS][N_WIND] = {
  1084.     {60,80,90,100,0},    /* January */
  1085.     {50,70,85,100,0},    /* February */  
  1086.     {40,60,75,95,100},   /* March */     
  1087.     {60,85,95,100,0},    /* April */     
  1088.     {70,90,100,0,0},     /* May */       
  1089.     {80,90,100,0,0},     /* June */      
  1090.     {80,100,0,0,0},      /* July */      
  1091.     {80,100,0,0,0},      /* August */    
  1092.     {60,80,95,100,0},    /* September */ 
  1093.     {40,65,85,95,100},   /* October */   
  1094.     {40,60,80,90,100},   /* November */  
  1095.     {60,80,90,95,100}    /* December */  
  1096. };
  1097.  
  1098. UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
  1099.     {0,40,70,80,100},   /* January */  
  1100.     {0,50,80,95,100},   /* February */ 
  1101.     {0,60,80,100,0},    /* March */    
  1102.     {0,40,70,90,100},   /* April */    
  1103.     {0,50,80,100,0},    /* May */      
  1104.     {0,60,90,100,0},    /* June */     
  1105.     {0,80,95,100,0},    /* July */     
  1106.     {0,80,95,100,0},    /* August */   
  1107.     {0,60,80,90,100},   /* September */
  1108.     {0,50,80,90,100},   /* October */  
  1109.     {0,40,70,85,100},   /* November */ 
  1110.     {0,40,70,80,100}    /* December */ 
  1111. };
  1112.  
  1113. UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};
  1114.  
  1115.  
  1116. //E*O*F n_atlantic.h//
  1117.  
  1118. echo x - n_pacific.h
  1119. cat > "n_pacific.h" << '//E*O*F n_pacific.h//'
  1120. /* Most of the info provided in this file could be found in an almanac. */
  1121.  
  1122. /* Ave_Temp       - the average temperature for each month */
  1123. /* Weather_Table  - each entry in the table is the weather profile for each month */
  1124. /*                  for a random 1-100 die roll. */
  1125. /*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
  1126. /*        example - {30,35,0,100} means that in this month a roll of : */
  1127. /*                  1-30  = precipitation        */
  1128. /*                 31-35  = overcast             */
  1129. /*                 no chance of taifun/hurricane */
  1130. /*                 36-100 = clear                */
  1131.  
  1132. /* Wind_Table     - is structured like the Weather_Table. */
  1133. /*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */
  1134.  
  1135. /* Precip_Table   - as above */
  1136. /*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */
  1137.  
  1138. /* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */
  1139.  
  1140. UBYTE Ave_Temp[N_MONTHS] = {40, 50, 60, 65, 70, 80, 85, 75, 65, 50, 40, 35};
  1141.  
  1142. UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
  1143.     {10,15,0,100}, {35,45,0,100}, {50,70,0,100}, {50,70,0,100}, {50,60,0,100}, {50,60,0,100}, 
  1144.     {35,40,0,100}, {40,45,55,100}, {40,45,55,100}, {10,15,17,100}, {10,15,0,100}, {10,15,0,100}
  1145. };
  1146.  
  1147. UBYTE Wind_Table[N_MONTHS][N_WIND] = {
  1148.     {40,70,90,100,0}, {40,70,90,100,0}, {40,70,90,100,0}, {40,70,90,100,0}, {40,70,90,100,0}, {40,70,90,100,0}, 
  1149.     {40,70,90,100,0}, {40,70,90,100,0}, {40,70,90,100,0}, {40,70,90,100,0}, {40,70,90,100,0}, {40,70,90,100,0}
  1150. };
  1151.  
  1152. UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
  1153.     {0,40,70,80,100},
  1154.     {0,50,80,95,100},
  1155.     {0,60,80,100,0},
  1156.     {0,40,70,90,100},
  1157.     {0,50,80,100,0},
  1158.     {0,60,90,100,0},
  1159.     {0,80,95,100,0},
  1160.     {0,80,95,100,0},
  1161.     {0,60,80,90,100},
  1162.     {0,50,80,90,100},
  1163.     {0,40,70,85,100},
  1164.     {0,40,70,80,100}
  1165. };
  1166.  
  1167. UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};
  1168.  
  1169.  
  1170. //E*O*F n_pacific.h//
  1171.  
  1172. echo x - s_atlantic.h
  1173. cat > "s_atlantic.h" << '//E*O*F s_atlantic.h//'
  1174. /* Most of the info provided in this file could be found in an almanac. */
  1175.  
  1176. /* Ave_Temp       - the average temperature for each month */
  1177. /* Weather_Table  - each entry in the table is the weather profile for each month */
  1178. /*                  for a random 1-100 die roll. */
  1179. /*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
  1180. /*        example - {30,35,0,100} means that in this month a roll of : */
  1181. /*                  1-30  = precipitation        */
  1182. /*                 31-35  = overcast             */
  1183. /*                 no chance of taifun/hurricane */
  1184. /*                 36-100 = clear                */
  1185.  
  1186. /* Wind_Table     - is structured like the Weather_Table. */
  1187. /*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */
  1188.  
  1189. /* Precip_Table   - as above */
  1190. /*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */
  1191.  
  1192. /* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */
  1193.  
  1194. UBYTE Ave_Temp[N_MONTHS] = {50, 60, 65, 70, 75, 80, 85, 80, 75, 65, 55, 50};
  1195.  
  1196. UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
  1197.     {30,35,0,100}, {25,35,0,100}, {20,30,0,100}, {35,50,0,100}, {25,40,0,100}, {15,25,0,100}, 
  1198.     {10,15,0,100}, {10,15,0,100}, {15,25,0,100}, {25,35,0,100}, {25,40,0,100}, {30,45,0,100}
  1199. };
  1200.  
  1201. UBYTE Wind_Table[N_MONTHS][N_WIND] = {
  1202.     {60,80,90,100,0}, {50,70,85,100,0}, {40,60,75,99,100}, {60,85,95,100,0}, {70,90,100,0,0}, {80,90,100,0,0}, 
  1203.     {80,100,0,0,0}, {80,100,0,0,0}, {60,80,95,100,0}, {40,65,85,97,100}, {40,60,80,95,100}, {60,80,90,100,0}
  1204. };
  1205.  
  1206. UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
  1207.     {0,40,70,80,100},
  1208.     {0,50,80,95,100},
  1209.     {0,60,80,100,0},
  1210.     {0,40,70,90,100},
  1211.     {0,50,80,100,0},
  1212.     {0,60,90,100,0},
  1213.     {0,80,95,100,0},
  1214.     {0,80,95,100,0},
  1215.     {0,60,80,90,100},
  1216.     {0,50,80,90,100},
  1217.     {0,40,70,85,100},
  1218.     {0,40,70,80,100}
  1219. };
  1220.  
  1221. UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};
  1222.  
  1223.  
  1224. //E*O*F s_atlantic.h//
  1225.  
  1226. echo x - weather.h
  1227. cat > "weather.h" << '//E*O*F weather.h//'
  1228. #ifdef SYSV
  1229. #define srandom srand48
  1230. #define random lrand48
  1231. #endif
  1232.  
  1233. #define DIE(n) ((int)(random() % (unsigned)n)+1)
  1234. #define MIN(a,b) ((a<b) ? a : b)
  1235. #define MAX(a,b) ((a>b) ? a : b)
  1236.  
  1237. #define AND &&
  1238. #define OR  ||
  1239.  
  1240. typedef unsigned char UBYTE;
  1241. typedef UBYTE BOOL;
  1242.  
  1243. typedef short STAT_T;
  1244. typedef short WEATHER_T;
  1245. typedef short OVERCAST_T;
  1246. typedef short WIND_T;
  1247. typedef short TEMP_T;
  1248. typedef short PRECIP_T;
  1249.  
  1250. /* Boolean types */
  1251. #define FALSE 0
  1252. #define TRUE  1
  1253.  
  1254. /* Statistics types */
  1255. #define N_STAT  3
  1256. #define LOW     0
  1257. #define AVERAGE 1
  1258. #define HIGH    2
  1259.  
  1260. /* Weather types */
  1261. #define N_WEATHER     4
  1262. #define PRECIPITATION 0
  1263. #define OVERCAST      1
  1264. #define TAIFUN        2
  1265. #define CLEAR         3
  1266.  
  1267. char *Weather_Name[N_WEATHER] = {
  1268.     "Precipitation",
  1269.     "Overcast",
  1270.     "Typhoon",
  1271.     "Clear"
  1272. };
  1273.  
  1274. /* Overcast types */
  1275. #define N_OVERCAST 4
  1276. #define HEAVY_FOG  0
  1277. #define LIGHT_FOG  1
  1278. #define MIST       2
  1279. #define CLOUDY     3
  1280.  
  1281. char *Overcast_Name[N_OVERCAST] = {
  1282.     "Heavy Fog",
  1283.     "Light Fog",
  1284.     "Mist",
  1285.     "Cloudy",
  1286. };
  1287.  
  1288. /* Wind types */
  1289. #define N_WIND   5
  1290. #define CALM     0
  1291. #define LIGHT    1
  1292. #define BRISK    2
  1293. #define BLUSTERY 3
  1294. #define GALE     4
  1295.  
  1296. char *Wind_Name[N_WIND] = {
  1297.     "Calm",
  1298.     "Light",
  1299.     "Brisk",
  1300.     "Blustery",
  1301.     "Gale",
  1302. };
  1303.  
  1304. /* Temperature types */
  1305. #define N_TEMP 5
  1306. #define COLD   0
  1307. #define CHILLY 1
  1308. #define FAIR   2
  1309. #define WARM   3
  1310. #define HOT    4
  1311.  
  1312. char *Temp_Name[N_TEMP] = {
  1313.     "Cold",
  1314.     "Chilly",
  1315.     "Fair",
  1316.     "Warm",
  1317.     "Hot",
  1318. };
  1319.  
  1320. /* Precipitation types */
  1321. #define N_PRECIP 5
  1322. #define NONE     0
  1323. #define SPRINKLE 1
  1324. #define SHOWER   2
  1325. #define HEAVY    3
  1326. #define STEADY   4
  1327.  
  1328. char *Precip_Name[N_PRECIP] = {
  1329.     "None",
  1330.     "Sprinkle",
  1331.     "Shower",
  1332.     "Heavy",
  1333.     "Steady",
  1334. };
  1335.  
  1336. UBYTE Temp_Variation[9] = {1, 5, 13, 25, 75, 87, 95, 99, 100};
  1337. //E*O*F weather.h//
  1338.  
  1339. exit 0
  1340.  
  1341.