
-------- TML Message #469 --------

Archive-Message-Number: 469
Date: Wed, 2 Aug 89 09:22:26 MDT
From: (Dan Williams) uunet.uu.net!zephyr.ENS.TEK.COM!salt!china!dan@tektronix.TEK.COM
Subject: Weather generation


The following is a weather generator for areas on earth like planets.  The 
parameters can be modified to suit your needs and the program could
probably be modified to fit any generally earth like world.

# This is a shell archive.  Remove anything before this line, then
# unpack it by saving it in a file and typing "sh file".  (Files
# unpacked will be owned by you and have default permissions.)
#
# This archive contains:
# 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

echo x - README
cat > "README" << '//E*O*F README//'
When playing roleplaying games (RPGs), it often adds some realism if the GM
can determine what kind of weather is occuring.  This program generates random
weather for a year that is tunable to various climates.  Several example
climates are included: north, south, and mid atlantic, gulf, and north
pacific.

In addition, several different calendars are included: Gregorian, medieval
Japanese, and the Middle Earth calendar detailed in the appendices of
Tolkien's The Lord of the Rings.

The details of these are provided so that the user can create his or her own
climate profiles or calendars.

Please send any improvements, new climate profiles, new calendars, or
better versions of the current climate profiles to one of the addresses below.

- -----------------------------------------------------------------
Brett Slocum   UUCP: ...uunet!hi-csc!slocum
               Arpa: hi-csc!slocum@uunet.uu.net
"My name is Inigo Montoya. You killed my father. Prepare to die."
- -----------------------------------------------------------------

//E*O*F README//

echo x - Makefile
cat > "Makefile" << '//E*O*F Makefile//'
# Makefile: makefile for weather.c
# 
# make <choice>
# will create a specific climate program.
#
# make
# will create 'england', an English climate program.
#
# make all
# will create all climate programs.
#
# To make addition climate programs, just add the calendar
# and climate choices as -D options.
#
# Calendar choices:
# 
# GREGORIAN - uses essentially modern calendar, without leap years.
#
# JAPAN     - uses medieval Japanese calendar.
#
# MIDDLE_EARTH - uses calendar described in appendices of Tolkien's
#                'The Lord of the Rings'.
#
# Climate choices:
#
# N_ATLANTIC   - useful for Scandinavia coastal or interior continential US
#                or Europe.
# MID_ATLANTIC - useful for England, European coastal, New England, etc.
# S_ATLANTIC   - useful for Spain, Southern coastal US
# GULF         - useful for Gulf States, Mediterranean, etc.
# N_PACIFIC    - useful for Japan, Korea, Southern Alaskan coast, etc.

england: weather.c weather.h gregorian.h mid_atlantic.h
	cc -DGREGORIAN -DMID_ATLANTIC -o england -g weather.c

minnesota: weather.c weather.h gregorian.h n_atlantic.h
	cc -DGREGORIAN -DN_ATLANTIC -o minnesota -g weather.c

japan: weather.c weather.h japan.h n_pacific.h
	cc -DJAPAN -DN_PACIFIC -o japan -g weather.c

florida: weather.c weather.h gregorian.h gulf.h
	cc -DGREGORIAN -DGULF -o florida -g weather.c

shire: weather.c weather.h middle_earth.h mid_atlantic.h
	cc -DMIDDLE_EARTH -DMID_ATLANTIC -o shire -g weather.c

georgia: weather.c weather.h gregorian.h s_atlantic.h
	cc -DGREGORIAN -DS_ATLANTIC -o georgia -g weather.c

all: england minnesota japan florida shire georgia

//E*O*F Makefile//

echo x - weather.c
cat > "weather.c" << '//E*O*F weather.c//'
/**************************************************************************
 *  Weather - generates random weather                                    *
 *                                                                        *
 *  Copyright 1988 by Brett Slocum.  All rights reserved.                 *
 *  Permission is granted to distribute or modify this program, or use    *
 *  portions of this program in other programs, as long as this notice    *
 *  remains intact.                                                       *
 *  This program or its derivatives may not be sold for profit without    *
 *  permission of the author.                                             *
 *                                                                        *
 *  Original UNIX Version: Brett Slocum UUCP: ...uunet!hi-csc!slocum      *
 *                                      ARPA: hi-csc!slocum@uunet.uu.net  *
 *                                                                        *
 **************************************************************************/

#include "weather.h"

typedef UBYTE MONTH_T;

/* Calendar choices */
#ifdef GREGORIAN
#include "gregorian.h"
#else
#ifdef JAPAN
#include "japan.h"
#else
#ifdef MIDDLE_EARTH
#include "middle_earth.h"
#endif
#endif
#endif

/* Climate choices */
#ifdef N_ATLANTIC
#include "n_atlantic.h"
#else
#ifdef MID_ATLANTIC
#include "mid_atlantic.h"
#else
#ifdef S_ATLANTIC
#include "s_atlantic.h"
#else
#ifdef GULF
#include "gulf.h"
#else
#ifdef N_PACIFIC
#include "n_pacific.h"
#endif
#endif
#endif
#endif
#endif

UBYTE Stat_Table[N_MONTHS][N_STAT] = {
    {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, 
    {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}, {200,0,0}
};

WIND_T     Wind = CALM;          /* today's wind conditions */
TEMP_T     Temp_Class = CHILLY;  /* today's temperature class */
PRECIP_T   Precip_Class = NONE;  /* today's precipitation */
WEATHER_T  Weather;              /* today's weather */
OVERCAST_T Sky;                  /* today's sky conditions */

UBYTE Temperature = 0,           /* today's actual temperature */
      Duration = 0;              /* today's precipitation duration */

BOOL Duration_Hours = TRUE,      /* flag that indicates whether precip lasted */
                                 /* hours (TRUE) or minutes (FALSE) */
     Catastrophe = FALSE,        /* flag that indicates whether a catastrophe */
                                 /* occurred today */
     Storm = FALSE,              /* flag that indicates whether precip was a storm */
     Long_Storm = FALSE,         /* flag that indicates whether precip was a */
                                 /* long storm lasting more than one day */
     Snow = FALSE;               /* flag that indicates whether snow fell today */

float Rainfall = 0.0,            /* yearly total rainfall */
      Snowfall = 0.0,            /* yearly total snowfall */
      Snow_Depth = 0.0;          /* today's snow depth, including new accumulations */
                                 /* and melting */

WEATHER_T 
gen_weather(month, ptr_catastrophe)
    MONTH_T month;
    BOOL *ptr_catastrophe;
    /* This routine generates the overall weather for the day. */
    /* It also determines whether a catastrophe has occurred.  */
    /* A catastrophe can be localized or wide-spread, natural  */
    /* or man-made. Such things as fires, earthquakes, floods, */
    /* etc. are possible.                                      */
{
     int       roll;
     WEATHER_T i, 
               return_val;

     /* get die-roll.  if catastrophe, set flag and roll again. */
     do {  
         roll = DIE(100);
         if (roll == 100)
             *ptr_catastrophe = TRUE;
     }
     while (roll == 100);
 
     /* if it rained more than a sprinkle yesterday, it more likely */
     /* to be at least overcast, if not rainy today. */
     if (Precip_Class > SPRINKLE) {
         roll = roll - 10;
         if (roll < 1)
             roll = 1;
     }

     /* find the type of weather from the die-roll */
     return_val = CLEAR;
     for (i = CLEAR; i >= PRECIPITATION; i--)
         if (roll <= Weather_Table[month][i])
             return_val = i;
     return(return_val);
}

TEMP_T 
gen_temp(month)
    MONTH_T month;
    /* generates the day's temperature and set the temp type */
{
     int roll, data, i;
     TEMP_T return_val;

     /* determine temperature variation from monthly average */
     /*   +/- 20 degrees */
     roll = DIE(100);
     data = 8;
     for (i = 8; i >= 0; i--)
         if (roll <= Temp_Variation[i])
             data = i;
     Temperature = Ave_Temp[month] + ((data-4) * 5);

     /* classify the temperature class */
     if (Temperature < 25) 
         return_val = COLD;
     else
     if ((Temperature >= 25) AND (Temperature < 40)) 
         return_val = CHILLY;
     else
     if ((Temperature >= 40) AND (Temperature < 65)) 
         return_val = FAIR;
     else
     if ((Temperature >= 65) AND (Temperature < 80)) 
         return_val = WARM;
     else
     if (Temperature >= 80) 
         return_val = HOT;

     /* accumulate monthly statistics */
     Stat_Table[month][HIGH] = MAX(Temperature, Stat_Table[month][HIGH]);
     Stat_Table[month][LOW] = MIN(Temperature, Stat_Table[month][LOW]);
     return(return_val);
}

WIND_T
gen_wind(month)
    MONTH_T month;
    /* generate the wind class */
{
     int roll;
     WIND_T return_val, i;

     /* modify the roll for current weather.  Clear weather is less likely */
     /* to be windy, and rainy weather is more likely. */
     roll = DIE(100);
     switch (Weather) {
     case CLEAR : 
         roll -= 20;
         break;
     case PRECIPITATION:
         roll += 20;
         break;
     } /* switch */

     /* if yesterday was very windy, today will be windier */
     if (Wind >= BLUSTERY) 
         roll += 20;

     /* limit to boundaries 1-100 */
     if (roll < 1) 
         roll = 1;
     if (roll > 100) 
         roll = 100;

     /* find wind type */
     return_val = GALE;
     for (i = GALE; i >= CALM; i--)
         if (roll <= Wind_Table[month][i]) 
             return_val = i;
     if (Weather == TAIFUN) 
         return_val = GALE;
     return(return_val);
 }

PRECIP_T
gen_precip(month)
    MONTH_T month;
    /* generate today's precipitation */
{
     int roll;
     PRECIP_T return_val, i;

     return_val = NONE;
     if (Weather == PRECIPITATION)
     {
         roll = DIE(100);
         return_val = STEADY;
         for (i = STEADY; i >= SPRINKLE; i--)
             if (roll <= Precip_Table[month][i])
                 return_val = i;
     }

     /* if yesterday had steady precipitation, there is a 1/3 chance */ 
     /* on the second day and 1/6 chance on succeeding days that today */
     /* also has steady precipitation */
     if ((Precip_Class == STEADY) AND (DIE(6) <= 2 - Long_Storm))
     {
         Weather = PRECIPITATION;
         return_val = STEADY;
     }

     return(return_val);
}

void
precip_statistics()
     /* determines various flags including Snow, Storm and Long_Storm. */
     /* Also determines precipitation duration and amount, updates */
     /* yearly Rainfall and Snowfall statistics, daily Snow_Depth, */
     /* and snow melting */
{
     float amount;

     if (Weather == PRECIPITATION)
     {
         /* set flags */
         if (Precip_Class != STEADY) 
             Long_Storm = FALSE;
         if (Temperature < 35)
             Snow = TRUE;
         else
             Snow = FALSE;
         if ((Temp_Class >= WARM) AND ((Precip_Class == SHOWER) OR (Precip_Class == HEAVY)))
             Storm = TRUE;
         else
             Storm = FALSE;
         if (Snow AND (Precip_Class >= HEAVY) AND (Wind >= BLUSTERY))
             Storm = TRUE;

         /* determine duration and amount of precipitation */
         switch (Precip_Class) {
         case SPRINKLE :
             Duration = 5 * DIE(6);
             Duration_Hours = FALSE;
             amount = 0.1;
             break;
         case SHOWER :
             Duration = 10 * (DIE(6) + DIE(6));
             Duration_Hours = FALSE;
             amount = Duration / 100;
             break;
         case HEAVY : 
             Duration = 1 + DIE(6);
             Duration_Hours = TRUE;
             amount = (DIE(4) + (Storm * Duration));
             break;
         case STEADY :
             Duration = 24;
             Duration_Hours = TRUE;
             amount = (DIE(6) + DIE(6)) + (Storm * (DIE(6) + DIE(6))); 
             break;
         }
         if (Storm)
             amount *= 2.0;

         /* update yearly and daily statistics */
         Rainfall += (amount / 10);
         if (Snow)
             {
                 Snow_Depth += amount;
                 Snowfall += amount;
             }
         else
             switch (Precip_Class) {
             case SHOWER : 
                 Snow_Depth -= Duration / 60;
                 break;
             case HEAVY : 
                 Snow_Depth -= Duration;
                 break;
             case STEADY :
                 Snow_Depth -= 12;
                 break;
             }
     }

     /* melt snow in weather above freezing */
     switch (Temp_Class) {
     case CHILLY :
         if (Temperature > 32) 
             Snow_Depth -= 1.0;
         break;
     case FAIR :
         Snow_Depth -= Temperature / 8;
         break;
     case WARM :
         Snow_Depth -= Temperature - 40;
         break;
     case HOT : 
         Snow_Depth -= Temperature - 20;
         break;
     }
     if (Snow_Depth < 0.1)
         Snow_Depth = 0.0;
}

OVERCAST_T
gen_overcast(weather)
    WEATHER_T weather;
    /* generate today's level of cloudiness */
{
     int roll;
     OVERCAST_T return_val, i;

     return_val = CLOUDY;
     switch (weather) {
     case PRECIPITATION:
     case OVERCAST :
          roll = DIE(100);
          return_val = CLOUDY;
          for (i = CLOUDY; i >= HEAVY_FOG; i--)
              if (roll <= Overcast_Table[i])
                  return_val = i;
          break;
     case TAIFUN : return_val = CLOUDY;
     }
     return(return_val);
}

void
print_notes(day, month)
    UBYTE day;
    MONTH_T month;
    /* print snow depth, precipitation type and duration, */
    /* catastrophe, and holidays */
{
     char *precip,
          *dur;

     if (Precip_Class != NONE) 
     {
         if (Snow) 
             precip = (Storm ? "Blizzard" : "Snow");
         else
             precip = (Storm ? "Storm" : "Rain");
         dur = (Duration_Hours ? "hours" : "minutes");
         printf(" %s - %2d %s,", precip, Duration, dur);
     }
     if (Catastrophe)
         printf(" Catastrophe,");
     print_holiday(day, month);
}

void
print_weather(day, month)
    UBYTE day;
    MONTH_T month;
    /* print today's weather */
{
     printf("%4d  %13s", day, Weather_Name[Weather]);
     printf("%11s", ((Weather==CLEAR) ? "Clear" : Overcast_Name[Sky]));
     printf("%8s (%3d)  %8s  %8s", Temp_Name[Temp_Class], Temperature, Precip_Name[Precip_Class], Wind_Name[Wind]);
     if (Snow_Depth > 0.0) 
         printf(" %5.1f\" ", Snow_Depth);
     else
         printf("%8c", ' ');
     print_notes(day, month);
     printf("\n");
 }

void
init_winter()
     /* initialize last year's winter */
{
     UBYTE day;
     MONTH_T month;

     /* calculate snow depth for Oct. thru Dec. */
     for (month = LAST_MONTH-2; month <= LAST_MONTH; month++)
         for (day = 1; day <= Day_Table[month]; day++)
         {
             Catastrophe = FALSE;
             if (DIE(100) > 50) 
                 Weather = gen_weather(month, &Catastrophe);
             Wind = gen_wind(month);
             Temp_Class = gen_temp(month);
             Precip_Class = gen_precip(month);
             precip_statistics();
             Sky = gen_overcast(Weather);
         }
}

init_stat()
{
    MONTH_T month;
    STAT_T stat;

    for (month = FIRST_MONTH; month <= LAST_MONTH; month++)
    {
        Stat_Table[month][LOW] = 200;
        for (stat = AVERAGE; stat <= HIGH; stat++)
            Stat_Table[month][stat] = 0;
    }
}

main(argc, argv)  
int argc;
char *argv[];
{
     int cum_temp;               /* cumulative temp used for calculating average temp */
     unsigned int sunshine = 0;  /* number of days of sunshine */
     MONTH_T month;              /* month counter */
     UBYTE day,                  /* day counter */
           year,                 /* year counter */
           n_years = 1;          /* number of years */

     srandom((int)time(0));
     if (argc > 1)
         n_years = atoi(argv[1]);
     init_winter();
     for (year = 1; year <= n_years; year++)
     {
         Rainfall = 0.0;
         Snowfall = 0.0;
         sunshine = 0;
         init_stat();
         printf("%64c%6s\n", ' ',"Snow");
         printf("Year %3d%11s%11s%14s%10s%10s%7s%7s\n", year, "Weather", "Sky", "Temperature", "Precip", "Wind", "Depth", "Notes");
         for (month = FIRST_MONTH; month <= LAST_MONTH; month++)
         {
             cum_temp = 0;
             printf("%-9s\n", Month_Name[month]);
             for (day = 1; day <= Day_Table[month]; day++)
             {
                 Catastrophe = FALSE;
    
                 /* half the time, Weather is the same as yesterday */
                 if (DIE(100) > 50) 
                     Weather = gen_weather(month, &Catastrophe);
                 Wind = gen_wind(month);
                 Temp_Class = gen_temp(month);
                 cum_temp += Temperature;
                 Precip_Class = gen_precip(month);
                 precip_statistics();
                 Sky = gen_overcast(Weather);
    
                 /* count sunny days */
                 if (Weather == CLEAR) 
                     sunshine++;
                 print_weather(day, month);
             }
             Stat_Table[month][AVERAGE] = (cum_temp / Day_Table[month]);
             printf("High Temp = %3d, Low Temp = %3d, Average Temp = %3d\n\n", Stat_Table[month][HIGH], Stat_Table[month][LOW], Stat_Table[month][AVERAGE]);
         }
         /* print yearly statistics */
         printf("Sunshine = %3d days\n", sunshine);
         printf("Rainfall = %4.1f\"\n", Rainfall);
         printf("Snowfall = %4.1f\"\n\n", Snowfall);
     }
}

//E*O*F weather.c//

echo x - gregorian.h
cat > "gregorian.h" << '//E*O*F gregorian.h//'
/* Copyright 1988 by Brett D. Slocum - 12/12/88 */
/* All rights reserved */
/* This is the calendar include file is for weather generation */
/* It includes calendar and holiday information */

/* To create a new calendar file, 
       1) define month names for use by MONTH_T type,
       2) define FIRST_MONTH and LAST_MONTH,
       3) define string array Month_Name with printable version of month,
       4) define number of days per month array Day_Table,
       5) add printf statements in print_holidays for holidays
*/

/* Month types */
#define JANUARY   0
#define FEBRUARY  1
#define MARCH     2
#define APRIL     3
#define MAY       4
#define JUNE      5
#define JULY      6
#define AUGUST    7
#define SEPTEMBER 8
#define OCTOBER   9
#define NOVEMBER  10
#define DECEMBER  11

#define FIRST_MONTH JANUARY
#define LAST_MONTH  DECEMBER

#define N_MONTHS (LAST_MONTH - FIRST_MONTH) + 1

char *Month_Name[N_MONTHS] = {
    "January", 
    "February",
    "March",
    "April",
    "May",
    "June",
    "July",
    "August",
    "September",
    "October",
    "November",
    "December"
};

UBYTE Day_Table[N_MONTHS] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

void
print_holiday(day, month)
    UBYTE day;
    MONTH_T month;
{
     switch (month) {
     case JANUARY : 
         if (day == 1) 
             printf(" New Years (s)");
         if (day == 6) 
             printf(" Twelfth Night");
         break;
     case FEBRUARY : 
         if (day == 2) 
             printf(" Candlemas");
         if (day == 14) 
             printf(" St. Valentine's Day");
         break;
     case MARCH : 
         if (day == 21) 
             printf(" Spring Equinox");
         break;
     case APRIL : 
         break;
     case MAY : 
         if (day == 1) 
             printf(" May Day");
         break;
     case JUNE : 
         if (day == 21) 
             printf(" Midsummer Day");
         break;
     case JULY : 
         break;
     case AUGUST : 
         if (day == 2) 
             printf(" Lammas");
         break;
     case SEPTEMBER : 
         if (day == 21) 
             printf(" Fall Equinox");
         break;
     case OCTOBER : 
         if (day == 31) 
             printf(" Halloween");
         break;
     case NOVEMBER : 
         break;
     case DECEMBER : 
         if (day == 21) 
             printf(" Winter Solstice");
         if (day == 25) 
             printf(" Christmas");
         break;
     }
}

//E*O*F gregorian.h//

echo x - gulf.h
cat > "gulf.h" << '//E*O*F gulf.h//'
/* Most of the info provided in this file could be found in an almanac. */

/* Ave_Temp       - the average temperature for each month */
/* Weather_Table  - each entry in the table is the weather profile for each month */
/*                  for a random 1-100 die roll. */
/*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
/*        example - {30,35,0,100} means that in this month a roll of : */
/*                  1-30  = precipitation        */
/*                 31-35  = overcast             */
/*                 no chance of taifun/hurricane */
/*                 36-100 = clear                */

/* Wind_Table     - is structured like the Weather_Table. */
/*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */

/* Precip_Table   - as above */
/*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */

/* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */

UBYTE Ave_Temp[N_MONTHS] = {65, 70, 75, 80, 85, 95, 95, 90, 85, 75, 70, 65};

UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
    {30,35,0,100}, {25,35,0,100}, {20,30,0,100}, {35,50,0,100}, {25,40,0,100}, {15,25,0,100}, 
    {10,15,0,100}, {10,15,0,100}, {15,25,0,100}, {25,35,0,100}, {25,40,0,100}, {30,45,0,100}
};

UBYTE Wind_Table[N_MONTHS][N_WIND] = {
    {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}, 
    {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}
};

UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
    {0,40,70,80,100},
    {0,50,80,95,100},
    {0,60,80,100,0},
    {0,40,70,90,100},
    {0,50,80,100,0},
    {0,60,90,100,0},
    {0,80,95,100,0},
    {0,80,95,100,0},
    {0,60,80,90,100},
    {0,50,80,90,100},
    {0,40,70,85,100},
    {0,40,70,80,100}
};

UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};


//E*O*F gulf.h//

echo x - japan.h
cat > "japan.h" << '//E*O*F japan.h//'
/* Copyright 1988 by Brett D. Slocum - 12/12/88 */
/* All rights reserved */
/* This is the calendar include file is for weather generation */
/* It includes calendar and holiday information */

/* To create a new calendar file, 
       1) define month names for use by MONTH_T type,
       2) define FIRST_MONTH and LAST_MONTH,
       3) define string array Month_Name with printable version of month,
       4) define number of days per month array Day_Table,
       5) add printf statements in print_holidays for holidays
*/

/* Month types */
#define RAT    0
#define BULL   1
#define TIGER  2
#define HARE   3
#define DRAGON 4
#define SNAKE  5
#define HORSE  6
#define SHEEP  7
#define MONKEY 8
#define BIRD   9
#define DOG    10
#define BOAR   11

#define FIRST_MONTH RAT
#define LAST_MONTH  BOAR

#define N_MONTHS (LAST_MONTH - FIRST_MONTH) + 1

/* text version of month names */
char *Month_Name[N_MONTHS] = {
    "Rat",
    "Bull",
    "Tiger",
    "Hare",
    "Dragon",
    "Snake",
    "Horse",
    "Sheep",
    "Monkey",
    "Bird",
    "Dog",
    "Boar"
};

/* table of days per month */
UBYTE Day_Table[N_MONTHS] = {29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30};

void
print_holiday(day,month)
    UBYTE day;
    MONTH_T month;
    /* prints holidays that fall on a given day */
{
     if (day == 15)
         printf(" Full Moon,");
     if (day == Day_Table[month])
         printf(" New Moon,");
     switch (day) { 
     case 1:
     case 15 : printf(" Shinto,");
          break;
     case 8:
     case 18 : printf(" Buddhist,");
          break;
     case 28 : printf(" Buddhist, Shinto,");
          break;
     }
     switch (month) {
     case RAT : 
         if ((day >= 1) AND (day <= 6))
             printf(" New Years (s)");
         break;
     case BULL :
         switch (day) { 
         case 1: case 2: case 4: case 5: case 6: case 7:
             printf(" Equinox (b)");
             break;
         case 3: 
             printf(" Setsuban (1st Day of Spring) (s)");
             break;
         }
         break;
     case TIGER :
         if (day == 3) 
             printf(" Doll Festival (c)");
         break;
     case HARE :
         if (day == 8)
             printf(" Buddha's Birthday (b)");
         break;
     case DRAGON :
         if (day == 5) 
             printf(" Boy's Day (c)");
         break;
     case SNAKE :
         switch (day) {
         case 1: case 2: case 3: case 4: case 5: case 6: case 7: 
             printf(" Rice Planting Festival (p)");
             break;
         case 30 : 
             printf(" All debts paid (p)");
         }
         break;
     case HORSE :
         switch (day) {
         case 1 : 
             printf(" Midyear (p)");
             break;
         case 7 : 
             printf(" Tanabata (Star Festival) (c)");
             break;
         case 13: case 14: case 15: 
             printf(" Bon Festival (for the dead) (b)");
         }
         break;
     case SHEEP :
         if ((day >= 1) AND (day <= 7)) 
             printf(" Equinox (b)");
         break;
     case BIRD :
         switch (day) { 
         case 15 : 
              printf(" Rice Harvest Festival (p)");
              break;
         case 20 : 
              printf(" Festival of Ebishu (s)");
         } 
         break;
     case DOG :
         if (day == 8) 
             printf(" Feast of the Bellows (s)");
         break;
     case BOAR :
         if (day == 30) 
             printf(" All debts paid (p)");
     }
}

//E*O*F japan.h//

echo x - mid_atlantic.h
cat > "mid_atlantic.h" << '//E*O*F mid_atlantic.h//'
/* Most of the info provided in this file could be found in an almanac. */

/* Ave_Temp       - the average temperature for each month */
/* Weather_Table  - each entry in the table is the weather profile for each month */
/*                  for a random 1-100 die roll. */
/*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
/*        example - {30,35,0,100} means that in this month a roll of : */
/*                  1-30  = precipitation        */
/*                 31-35  = overcast             */
/*                 no chance of taifun/hurricane */
/*                 36-100 = clear                */

/* Wind_Table     - is structured like the Weather_Table. */
/*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */

/* Precip_Table   - as above */
/*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */

/* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */

UBYTE Ave_Temp[N_MONTHS] = {20, 35, 45, 55, 65, 75, 85, 80, 65, 50, 35, 25};

UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
    {30,35,0,100}, {25,35,0,100}, {20,30,0,100}, {35,50,0,100}, {25,40,0,100}, {15,25,0,100}, 
    {10,15,0,100}, {10,15,0,100}, {15,25,0,100}, {25,35,0,100}, {25,40,0,100}, {30,45,0,100}
};

UBYTE Wind_Table[N_MONTHS][N_WIND] = {
    {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}, 
    {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}
};

UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
    {0,40,70,80,100},
    {0,50,80,95,100},
    {0,60,80,100,0},
    {0,40,70,90,100},
    {0,50,80,100,0},
    {0,60,90,100,0},
    {0,80,95,100,0},
    {0,80,95,100,0},
    {0,60,80,90,100},
    {0,50,80,90,100},
    {0,40,70,85,100},
    {0,40,70,80,100}
};

UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};


//E*O*F mid_atlantic.h//

echo x - middle_earth.h
cat > "middle_earth.h" << '//E*O*F middle_earth.h//'
/* Copyright 1988 by Brett D. Slocum - 12/12/88 */
/* All rights reserved */
/* This is the calendar include file is for weather generation */
/* It includes calendar and holiday information */

/* To create a new calendar file, 
       1) define month names for use by MONTH_T type,
       2) define FIRST_MONTH and LAST_MONTH,
       3) define string array Month_Name with printable version of month,
       4) define number of days per month array Day_Table,
       5) add printf statements in print_holidays for holidays
*/

/* Month types */
#define AFTERYULE   0
#define SOLMATH     1
#define RETHE       2
#define ASTRON      3
#define THRIMIDGE   4
#define FORELITHE   5
#define AFTERLITHE  6
#define WEDMATH     7
#define HALIMATH    8
#define WINTERFILTH 9
#define BLOTMATH    10
#define FOREYULE    11

#define FIRST_MONTH AFTERYULE
#define LAST_MONTH  FOREYULE

#define N_MONTHS (LAST_MONTH - FIRST_MONTH) + 1

char *Month_Name[N_MONTHS] = {
    "Afteryule",
    "Solmath",
    "Rethe",
    "Astron",
    "Thrimidge",
    "Forelithe",
    "Afterlithe",
    "Wedmath",
    "Halimath",
    "Winterfilth",
    "Blotmath",
    "Foreyule",
};

UBYTE Day_Table[N_MONTHS] = {30, 30, 30, 30, 30, 31, 30, 30, 30, 30, 30, 34};

void
print_holiday(day, month)
    UBYTE day;
    MONTH_T month;
{
     switch (month) {
     case AFTERYULE:
         break;
     case SOLMATH:
         break;
     case RETHE:
         break;
     case ASTRON:
         break;
     case THRIMIDGE:
         break;
     case FORELITHE:
         if (day == 31) 
             printf(" Midsummer Day");
         break;
     case AFTERLITHE:
         break;
     case WEDMATH:
         break;
     case HALIMATH:
         break;
     case WINTERFILTH:
         break;
     case BLOTMATH:
         break;
     case FOREYULE:
         if ((day >= 31) AND (day <= 34))
             printf(" Yule");
         break;
     }
}

//E*O*F middle_earth.h//

echo x - n_atlantic.h
cat > "n_atlantic.h" << '//E*O*F n_atlantic.h//'
/* Most of the info provided in this file could be found in an almanac. */

/* Ave_Temp       - the average temperature for each month */
/* Weather_Table  - each entry in the table is the weather profile for each month */
/*                  for a random 1-100 die roll. */
/*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
/*        example - {30,35,0,100} means that in this month a roll of : */
/*                  1-30  = precipitation        */
/*                 31-35  = overcast             */
/*                 no chance of taifun/hurricane */
/*                 36-100 = clear                */

/* Wind_Table     - is structured like the Weather_Table. */
/*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */

/* Precip_Table   - as above */
/*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */

/* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */

UBYTE Ave_Temp[N_MONTHS] = {10, 15, 25, 40, 55, 70, 85, 80, 60, 35, 20, 15};

UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
    {30,40,0,100}, /* January or the first month in non-Gregorian calendar */
    {25,35,0,100}, /* February */
    {20,30,0,100}, /* March */
    {35,50,0,100}, /* April */
    {25,40,0,100}, /* May */
    {15,25,0,100}, /* June */
    {10,15,0,100}, /* July */
    {10,15,0,100}, /* August */
    {15,30,0,100}, /* September */
    {25,40,0,100}, /* October */
    {25,40,0,100}, /* November */
    {30,45,0,100}  /* December */
};

UBYTE Wind_Table[N_MONTHS][N_WIND] = {
    {60,80,90,100,0},    /* January */
    {50,70,85,100,0},    /* February */  
    {40,60,75,95,100},   /* March */     
    {60,85,95,100,0},    /* April */     
    {70,90,100,0,0},     /* May */       
    {80,90,100,0,0},     /* June */      
    {80,100,0,0,0},      /* July */      
    {80,100,0,0,0},      /* August */    
    {60,80,95,100,0},    /* September */ 
    {40,65,85,95,100},   /* October */   
    {40,60,80,90,100},   /* November */  
    {60,80,90,95,100}    /* December */  
};

UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
    {0,40,70,80,100},   /* January */  
    {0,50,80,95,100},   /* February */ 
    {0,60,80,100,0},    /* March */    
    {0,40,70,90,100},   /* April */    
    {0,50,80,100,0},    /* May */      
    {0,60,90,100,0},    /* June */     
    {0,80,95,100,0},    /* July */     
    {0,80,95,100,0},    /* August */   
    {0,60,80,90,100},   /* September */
    {0,50,80,90,100},   /* October */  
    {0,40,70,85,100},   /* November */ 
    {0,40,70,80,100}    /* December */ 
};

UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};


//E*O*F n_atlantic.h//

echo x - n_pacific.h
cat > "n_pacific.h" << '//E*O*F n_pacific.h//'
/* Most of the info provided in this file could be found in an almanac. */

/* Ave_Temp       - the average temperature for each month */
/* Weather_Table  - each entry in the table is the weather profile for each month */
/*                  for a random 1-100 die roll. */
/*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
/*        example - {30,35,0,100} means that in this month a roll of : */
/*                  1-30  = precipitation        */
/*                 31-35  = overcast             */
/*                 no chance of taifun/hurricane */
/*                 36-100 = clear                */

/* Wind_Table     - is structured like the Weather_Table. */
/*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */

/* Precip_Table   - as above */
/*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */

/* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */

UBYTE Ave_Temp[N_MONTHS] = {40, 50, 60, 65, 70, 80, 85, 75, 65, 50, 40, 35};

UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
    {10,15,0,100}, {35,45,0,100}, {50,70,0,100}, {50,70,0,100}, {50,60,0,100}, {50,60,0,100}, 
    {35,40,0,100}, {40,45,55,100}, {40,45,55,100}, {10,15,17,100}, {10,15,0,100}, {10,15,0,100}
};

UBYTE Wind_Table[N_MONTHS][N_WIND] = {
    {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}, 
    {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}
};

UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
    {0,40,70,80,100},
    {0,50,80,95,100},
    {0,60,80,100,0},
    {0,40,70,90,100},
    {0,50,80,100,0},
    {0,60,90,100,0},
    {0,80,95,100,0},
    {0,80,95,100,0},
    {0,60,80,90,100},
    {0,50,80,90,100},
    {0,40,70,85,100},
    {0,40,70,80,100}
};

UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};


//E*O*F n_pacific.h//

echo x - s_atlantic.h
cat > "s_atlantic.h" << '//E*O*F s_atlantic.h//'
/* Most of the info provided in this file could be found in an almanac. */

/* Ave_Temp       - the average temperature for each month */
/* Weather_Table  - each entry in the table is the weather profile for each month */
/*                  for a random 1-100 die roll. */
/*  month profile - {precipitation, overcast, taifun/hurricane, clear} */        
/*        example - {30,35,0,100} means that in this month a roll of : */
/*                  1-30  = precipitation        */
/*                 31-35  = overcast             */
/*                 no chance of taifun/hurricane */
/*                 36-100 = clear                */

/* Wind_Table     - is structured like the Weather_Table. */
/*  month profile - {Calm, Light, Brisk, Blustery, Gale}  */

/* Precip_Table   - as above */
/*  month profile - {None, Sprinkle, Shower, Heavy, Steady} */

/* Overcast_Table - {Heavy Fog, Light Fog, Mist, Cloudy} */

UBYTE Ave_Temp[N_MONTHS] = {50, 60, 65, 70, 75, 80, 85, 80, 75, 65, 55, 50};

UBYTE Weather_Table[N_MONTHS][N_WEATHER] = {
    {30,35,0,100}, {25,35,0,100}, {20,30,0,100}, {35,50,0,100}, {25,40,0,100}, {15,25,0,100}, 
    {10,15,0,100}, {10,15,0,100}, {15,25,0,100}, {25,35,0,100}, {25,40,0,100}, {30,45,0,100}
};

UBYTE Wind_Table[N_MONTHS][N_WIND] = {
    {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}, 
    {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}
};

UBYTE Precip_Table[N_MONTHS][N_PRECIP] = {
    {0,40,70,80,100},
    {0,50,80,95,100},
    {0,60,80,100,0},
    {0,40,70,90,100},
    {0,50,80,100,0},
    {0,60,90,100,0},
    {0,80,95,100,0},
    {0,80,95,100,0},
    {0,60,80,90,100},
    {0,50,80,90,100},
    {0,40,70,85,100},
    {0,40,70,80,100}
};

UBYTE Overcast_Table[N_OVERCAST] = {10,20,70,100};


//E*O*F s_atlantic.h//

echo x - weather.h
cat > "weather.h" << '//E*O*F weather.h//'
#ifdef SYSV
#define srandom srand48
#define random lrand48
#endif

#define DIE(n) ((int)(random() % (unsigned)n)+1)
#define MIN(a,b) ((a<b) ? a : b)
#define MAX(a,b) ((a>b) ? a : b)

#define AND &&
#define OR  ||

typedef unsigned char UBYTE;
typedef UBYTE BOOL;

typedef short STAT_T;
typedef short WEATHER_T;
typedef short OVERCAST_T;
typedef short WIND_T;
typedef short TEMP_T;
typedef short PRECIP_T;

/* Boolean types */
#define FALSE 0
#define TRUE  1

/* Statistics types */
#define N_STAT  3
#define LOW     0
#define AVERAGE 1
#define HIGH    2

/* Weather types */
#define N_WEATHER     4
#define PRECIPITATION 0
#define OVERCAST      1
#define TAIFUN        2
#define CLEAR         3

char *Weather_Name[N_WEATHER] = {
    "Precipitation",
    "Overcast",
    "Typhoon",
    "Clear"
};

/* Overcast types */
#define N_OVERCAST 4
#define HEAVY_FOG  0
#define LIGHT_FOG  1
#define MIST       2
#define CLOUDY     3

char *Overcast_Name[N_OVERCAST] = {
    "Heavy Fog",
    "Light Fog",
    "Mist",
    "Cloudy",
};

/* Wind types */
#define N_WIND   5
#define CALM     0
#define LIGHT    1
#define BRISK    2
#define BLUSTERY 3
#define GALE     4

char *Wind_Name[N_WIND] = {
    "Calm",
    "Light",
    "Brisk",
    "Blustery",
    "Gale",
};

/* Temperature types */
#define N_TEMP 5
#define COLD   0
#define CHILLY 1
#define FAIR   2
#define WARM   3
#define HOT    4

char *Temp_Name[N_TEMP] = {
    "Cold",
    "Chilly",
    "Fair",
    "Warm",
    "Hot",
};

/* Precipitation types */
#define N_PRECIP 5
#define NONE     0
#define SPRINKLE 1
#define SHOWER   2
#define HEAVY    3
#define STEADY   4

char *Precip_Name[N_PRECIP] = {
    "None",
    "Sprinkle",
    "Shower",
    "Heavy",
    "Steady",
};

UBYTE Temp_Variation[9] = {1, 5, 13, 25, 75, 87, 95, 99, 100};
//E*O*F weather.h//

exit 0


| Dan Williams (uunet!china!dan) | FRP: It's not just a game,        |
|       MCDONNELL DOUGLAS        |            it's an adventure!     |
|           Denver CO            | "Of course thats just my opinion" |

The Traveller Mailing List is a courtesy of James Perkins and Tektronix, Inc.
All opinions and material above is the responsibility of the originator.
Send Submissions To: @RELAY.CS.NET:traveller@dadla.LA.TEK.COM,
	uunet!dadla.la.tek.com!traveller, or traveller@dadla.la.tek.com
List Administrator: traveller-request@dadla.la.tek.com

-------- TML Message #470 --------

Archive-Message-Number: 470
Date: Wed, 2 Aug 89 13:00:06 -0500
From: uxc.cso.uiuc.edu!zephyr.ENS.TEK.COM!gslisa!gsliss!jcunning@tektronix.TEK.COM
Subject: Gencon



I will be at Gencon Saturday, and possibly on Friday. On Saturday
I'll be wearing my old Huscarles T-shirt from way back. I now wear
it only once a year lest it fall apart. Say hello. Hope to see you there.


				Jim Cunningham
Traveller Relic



The Traveller Mailing List is a courtesy of James Perkins and Tektronix, Inc.
All opinions and material above is the responsibility of the originator.
Send Submissions To: @RELAY.CS.NET:traveller@dadla.LA.TEK.COM,
	uunet!dadla.la.tek.com!traveller, or traveller@dadla.la.tek.com
List Administrator: traveller-request@dadla.la.tek.com

-------- TML Message #471 --------

Archive-Message-Number: 471
From: (Steven J Owens) scratch@unix.cis.pittsburgh.edu
Date: Thu, 3 Aug 89 1:12:52 EDT
Subject: Vehicular Rules?




The Traveller Mailing List is a courtesy of James Perkins and Tektronix, Inc.
All opinions and material above is the responsibility of the originator.
Send Submissions To: @RELAY.CS.NET:traveller@dadla.LA.TEK.COM,
	uunet!dadla.la.tek.com!traveller, or traveller@dadla.la.tek.com
List Administrator: traveller-request@dadla.la.tek.com

-------- TML Message #472 --------

Archive-Message-Number: 472
From: scratch@unix.cis.pittsburgh.edu (Steven J Owens)
Date: Thu, 3 Aug 89 18:41:04 EDT
Subject: Vehicular Rules


[Let's try this again -- James]

A few messages back somebody was discussing vehicles... I didn't have
much to contribute to that conversation, but it got me thinking (always
a dangerous condition :-) about something I was interested in awhile
back when I played Traveller more actively.  Namely, vehicle design
rules and vehicular combat.  Now, I know that striker has rules for
both design and combat, altthough they are more oriented towards tanks
and such than civilian vehicles.  There was an article in one of the
TASJs about designing civilian vehicles with Striker rules.
 
	What I'm interested in is rules to handle designing normal
civilian vehicles and even armored and/or heavily armed civilian
vehicles, plus rules for combat with them, with only a few vehicles
instead of many.  Of course a system that could handle both ends of the
scale, military and civilian, many and few, would be just as fine.  So
the question is, does such a system exist?  I'm totally unfamiliar with
the new rules, so I don't know if they have anything useful.  I'm not a
Striker aficianado, so if there's one out there, can that system be
tweaked sufficiently to handle what I'm talking about? 
 
	I used to play car wars a bit, and we even cobbled up a
simplistic conversion for car wars style combat in a traveller universe
(the GM liked CW also, and much of our gaming took place on a world
suited to the genre).  I'd like a good set of rules to handle this
stuff, and am open to suggestions.  While I'm at it, a good car battle
game to replace car wars would be nice too... (something very
high-techish, but flexible enough to use with other systems would be
PERFECT!) 
 
Steven J. Owens  		| "Twist ye, twine ye!  Even so,
Scratch@Pittvms  		|  Mingled shades of joy and woe,
Scratch@unix.cis.pitt.edu	|  Hope and fear, and peace, and strife,
				|  In the thread of human life."

The Traveller Mailing List is a courtesy of James Perkins and Tektronix, Inc.
All opinions and material above is the responsibility of the originator.
Send Submissions To: @RELAY.CS.NET:traveller@dadla.LA.TEK.COM,
	uunet!dadla.la.tek.com!traveller, or traveller@dadla.la.tek.com
List Administrator: traveller-request@dadla.la.tek.com

-------- TML Message #473 --------

Archive-Message-Number: 473
Date: Fri, 4 Aug 89 21:43:58 EDT
From: (wilson m liaw) macgyver@cis.ohio-state.edu
Subject: Vehicle



	The new rules does cover creating vehicles of any kind. And new combat
system also handles vehicle combats well. 

			Mac

The Traveller Mailing List is a courtesy of James Perkins and Tektronix, Inc.
All opinions and material above is the responsibility of the originator.
Send Submissions To: @RELAY.CS.NET:traveller@dadla.LA.TEK.COM,
	uunet!dadla.la.tek.com!traveller, or traveller@dadla.la.tek.com
List Administrator: traveller-request@dadla.la.tek.com

-------- End of TML Messages --------

