--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/struct.h	Sat Dec 06 04:37:05 1997 +0000
@@ -0,0 +1,1174 @@
+/*--------------------------------------------------------------------------
+NETREK II -- Paradise
+
+Permission to use, copy, modify, and distribute this software and its
+documentation, or any derivative works thereof, for any NON-COMMERCIAL
+purpose and without fee is hereby granted, provided that this copyright
+notice appear in all copies.  No representations are made about the
+suitability of this software for any purpose.  This software is provided
+"as is" without express or implied warranty.
+
+    Xtrek Copyright 1986                            Chris Guthrie
+    Netrek (Xtrek II) Copyright 1989                Kevin P. Smith
+                                                    Scott Silvey
+    Paradise II (Netrek II) Copyright 1993          Larry Denys
+                                                    Kurt Olsen
+                                                    Brandon Gillespie
+--------------------------------------------------------------------------*/
+
+#ifndef struct_h_
+#define struct_h_
+
+
+#include "defs.h"
+
+
+
+
+
+/*-----------------------------SHIP STRUCTURE------------------------------*/
+
+enum ship_types_e
+{
+  SCOUT, DESTROYER, CRUISER, BATTLESHIP, ASSAULT, STARBASE, ATT,
+  JUMPSHIP, FRIGATE, WARBASE, LIGHTCRUISER, CARRIER, UTILITY, PATROL
+
+#if 1
+#define	NUM_TYPES	14	/* this is less clean, but cc has a */
+  /* problem with using an enum constant */
+  /* as an array dimension.  POS compiler. */
+#else
+  NUM_TYPES
+#endif
+};
+
+struct drivestat
+{
+  /* various drive type statistics */
+  int acc;			/* acceleration */
+  int dec;			/* decelleration */
+  int cost;			/* fuel cost */
+  int maxspeed;			/* maximum speed */
+  int etemp;			/* engine temperature */
+};
+
+struct weaponstat
+{
+  short damage;			/* damage potential */
+  short speed;			/* speed for missiles, range for beams */
+  short cost;			/* fuel cost */
+  short fuse;			/* how long they last */
+  short wtemp;			/* weapon temperature cost */
+  short wtemp_halfarc;		/* Arc the penalty is calculated from */
+  short wtemp_factor;		/* Penalty Factor 1-16 of wtemp caused */
+  short count;			/* how many we can have airborne */
+  short aux;			/* aux field */
+  /* aux is turn rate for torps and plasmas. */
+};
+
+struct ship
+{
+
+  short s_type;			/* ship type, defined with the number */
+  short s_alttype;		/* This MUST be a legal vanilla bronco type */
+  char s_name[32];		/* ship's name */
+
+  /* engine characteristics */
+  int s_turns;			/* ship\'s turning */
+#undef	s_imp			/* bloody obsolete header files */
+  struct drivestat s_imp;	/* impulse drive stats */
+  struct drivestat s_after;	/* impulse drive stats */
+  struct drivestat s_warp;	/* impulse drive stats */
+  int s_warpinitcost;		/* fuel charge to initialize warp */
+  int s_warpinittime;		/* time to initialize warp */
+  int s_warpprepspeed;		/* speed while initializing warp */
+
+  short s_mass;			/* to guage affect of tractor beams */
+
+  /* tractor characteristics */
+  short s_tractstr;		/* Strength of tractor beam */
+  float s_tractrng;		/* tractor range */
+  int s_tractcost;		/* fuel used by tractors */
+  int s_tractetemp;		/* e-temp caused by tractors */
+
+  struct weaponstat s_torp;	/* torp characteristics */
+  struct weaponstat s_phaser;	/* phaser characteristics */
+  struct weaponstat s_missile;	/* missile characteristics */
+  struct weaponstat s_plasma;	/* plasma characteristics */
+  short s_missilestored;	/* how many missiles can we store? */
+
+  /* Raynfala's Butt Torp Code. Gjor's Ship Patch for his code to do it */
+  /* for each ship.						       */
+
+  short s_torp_penalty_halfarc;
+  short s_torp_penalty_factor;
+
+  int s_maxwpntemp;		/* max W-temp */
+  short s_wpncoolrate;		/* weapon cool rate */
+
+  int s_maxegntemp;		/* max engine temp */
+  short s_egncoolrate;		/* engine cool rate */
+
+  /* fuel characteristics */
+  int s_maxfuel;		/* ship's maximum fuel */
+  short s_recharge;		/* speed fuel recharges */
+  int s_mingivefuel;		/* ship must have this much to give fuel */
+  int s_takeonfuel;		/* how fast ship takes on fuel */
+
+  short s_expldam;		/* damage done by ship's explosion (assuming
+				 * his fuel tank is empty) */
+  short s_fueldam;		/* the amount of _additional_ damage that
+				 * this ship's explosion does with a full
+				 * tank */
+
+  /* miscellaneous army stats */
+  float s_armyperkill;		/* the number of armies per kill */
+  short s_maxarmies;		/* max armies ship can carry */
+  int s_bomb;			/* bomb damage ship can do */
+
+  /* hull, shield and repair stats */
+  short s_repair;		/* ship's repair rate */
+  int s_maxdamage;		/* maximum damage ship can take */
+  int s_maxshield;		/* maximum shield value */
+  int s_shieldcost;		/* cost in fuel of shields being up */
+
+  short s_detcost;		/* fuel cost of detting */
+  int s_detdist;		/* fuel cost of detting */
+  short s_cloakcost;		/* base fuel cost of cloaking */
+
+  short s_scanrange;		/* range of the ship's scanners */
+
+  short s_numports;		/* how many docking ports do we have? */
+
+  char s_letter;		/* the letter used to enter as that ship */
+  char s_desig1;		/* the designation used (such as A, in AS */
+  char s_desig2;		/* the designation used (such as S, in AS */
+
+  short s_bitmap;		/* the bitmap to use */
+  short s_width;		/* width of bitmap */
+  short s_height;		/* height of bitmap */
+
+  /* ship requisition limitations */
+  int s_timer;			/* value to set timer to get another ship */
+  int s_maxnum;			/* maximum number of these per team */
+  int s_rank;			/* minimum rank for this sucker */
+  int s_numdefn;		/* number of player necessary */
+  int s_numplan;		/* number of planets */
+
+  long s_nflags;		/* attributes for ship type, SFN flags */
+};
+
+/*
+ * ATTENTION!!! Changes to these flags should be mirrored in structdesc.c
+ */
+/* For s_nflags field */
+#if 0
+#define SFNDOCKON       (1<< 0)	/* specify a ship to docked on */
+#define SFNCANDOCK      (1<< 1)	/* specify a ship can dock */
+#else
+#define SFNUNDOCKABLE	(1<< 0)	/* this ship can not dock with another */
+#define SFNCANORBIT     (1<< 1)	/* specify a ship can orbit */
+#endif
+#define SFNCANWARP      (1<< 2)	/* this ship can go warp */
+#define SFNCANFUEL	(1<< 3)	/* base can give docked ships fuel */
+#define SFNCANREPAIR	(1<< 4)	/* base can repair docked ships */
+#define SFNCANREFIT	(1<< 5)	/* base allows a refit while docked */
+#define SFNARMYNEEDKILL (1<< 6)	/* does ship need kills to carry */
+
+#define SFNHASPHASERS	(1<< 7)	/* this ship has phasers */
+
+#define SFNPLASMASTYLE  (1<< 8)	/* style of firing plasmas */
+
+#define SFNMASSPRODUCED (1<< 9)	/* ship can appear docked to an SB or UT */
+
+#define SFNPLASMAARMED	(1<<10)
+#define SFNHASMISSILE	(1<<11)
+
+#define SFNHASFIGHTERS	(1<<12)	/* ship has a fighter bay */
+
+#if 0
+#define allows_docking(s_ship)	((s_ship).s_nflags & SFNDOCKON)
+#define can_dock(s_ship)	((s_ship).s_nflags & SFNCANDOCK)
+#else
+#define allows_docking(s_ship)	((s_ship).s_numports>0)
+#define can_dock(s_ship)	((s_ship).s_numports==0 && !((s_ship).s_nflags&SFNUNDOCKABLE))
+#endif
+/*-------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+/*----------------------------STATS STRUCTURE------------------------------*/
+
+struct stats
+{
+  int st_genocides;		/* number of genocides participated in */
+  float st_tmaxkills;		/* max kills ever */
+  float st_di;			/* total destruction inflicted for all time */
+  int st_tkills;		/* Kills in tournament play */
+  int st_tlosses;		/* Losses in tournament play */
+  int st_tarmsbomb;		/* Tournament armies bombed */
+  int st_tresbomb;		/* resources bombed off */
+  int st_tdooshes;		/* armies killed while being carried */
+  int st_tplanets;		/* Tournament planets conquered */
+  int st_tticks;		/* Tournament ticks */
+  /* SB/WB/JS stats are entirely separate */
+  int st_sbkills;		/* Kills as starbase */
+  int st_sblosses;		/* Losses as starbase */
+  int st_sbticks;		/* Time as starbase */
+  float st_sbmaxkills;		/* Max kills as starbase */
+  int st_wbkills;		/* Kills as warbase */
+  int st_wblosses;		/* Losses as warbase */
+  int st_wbticks;		/* Time as warbase */
+  float st_wbmaxkills;		/* Max kills as warbase */
+  int st_jsplanets;		/* planets assisted with in JS */
+  int st_jsticks;		/* ticks played as a JS */
+  long st_lastlogin;		/* Last time this player was played */
+  int st_flags;			/* Misc option flags */
+  int st_cluesuccess;		/* how many times you passed a clue check */
+  char st_pad[92];		/* space for expansion */
+  int st_rank;			/* Ranking of the player */
+  int st_royal;			/* royaly, specialty, rank */
+};
+
+/*
+ * These are for the flags field and control the preset options of the
+ * players client.
+ */
+#if 0
+#define ST_MAPMODE      0x001
+#define ST_NAMEMODE     0x002
+#define ST_SHOWSHIELDS  0x004
+#endif
+#define ST_NOBITMAPS	(1<<0)
+#define ST_KEEPPEACE    (1<<3)
+#if 0
+#define ST_SHOWLOCAL    0x010	/* two bits for these two */
+#define ST_SHOWGLOBAL   0x040
+#endif
+#define ST_CYBORG	(1<<8)
+
+/* initial value to put in flags */
+#define ST_INITIAL ST_KEEPPEACE
+/*
+ * ST_MAPMODE+ST_NAMEMODE+ST_SHOWSHIELDS+ \
+ * ST_KEEPPEACE+ST_SHOWLOCAL*2+ST_SHOWGLOBAL*2;
+ */
+
+/*-------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+/*---------------------------VARIOUS STRUCTURES----------------------------*/
+
+/*
+ * This is used to indicate various things about the game and to hold global
+ * stats about it.  All stats are only updated while in t-mode.
+ */
+struct status
+{
+  int active;			/* for interfacing with people who */
+  unsigned int wait, count;	/* want to get into the game */
+  unsigned int number, request, answer;
+  unsigned char tourn;		/* Tournament mode? */
+  unsigned long dooshes;	/* total number of armies dooshed */
+  unsigned long armsbomb;	/* all t-mode armies bombed */
+  unsigned long resbomb;	/* resources bombed */
+  unsigned long planets;	/* all t-mode planets taken */
+  unsigned long kills;		/* all t-mode kills made */
+  unsigned long losses;		/* all t-mode losses */
+  unsigned long genocides;	/* number of genocides */
+  unsigned long sbkills;	/* total kills in SB's */
+  unsigned long sblosses;	/* total losses in Sb's */
+  unsigned long sbtime;		/* total time in SB's */
+  unsigned long wbkills;	/* kills in warbases */
+  unsigned long wblosses;	/* losses in warbases */
+  unsigned long wbtime;		/* total time played in wb's */
+  unsigned long jsplanets;	/* total planets taken by jump ships */
+  unsigned long jstime;		/* total time in a jump ship */
+  unsigned long time;		/* t-mode time */
+  unsigned long timeprod;	/* t-mode ship ticks--sort of like */
+  /* manhours in t-mode */
+  unsigned long clock;		/* clock used for timestamping */
+  int nukegame;			/* set to PID of daemon */
+  int gameup;			/* is game up */
+};
+
+/*
+ * Some of the stuff above belongs in struct status2
+ */
+
+struct league_team
+{
+  int index;			/* team index, not mask. -1 means captain
+				 * hasn't chosen yet */
+  int captain;			/* player number of captain */
+  char name[32];
+  int timeouts_left;		/* NYI */
+  int ready;
+  int desirepause;		/* do we want to pause the game? */
+
+  struct
+  {
+    int regulation;		/* game length */
+    int overtime;
+    int maxplayers;		/* max players per team */
+    int galaxyreset;		/* do we want to reset the galaxy? */
+    int restart;		/* should we restart team selection? */
+  }   desired;
+};
+
+struct status2
+{
+#ifdef LEAGUE_SUPPORT
+  int league;			/* are we playing league? 0 means no. 1 means
+				 * we're prepping (captains choose sides). 2
+				 * means we're almost there. 3 means we're in
+				 * regulation league play. 4 means we're in
+				 * overtime */
+  int leagueticksleft;		/* ticks left in game play */
+
+  struct league_team home, away;
+
+  int timeout_timeleft;		/* ticks left in a timeout */
+  int awaypassed;		/* does the away team get first choice? this
+				 * becomes 1 if they PASS */
+  int paused;			/* contains 0 if the game is not paused.
+				 * contains the number of ticks left before
+				 * return to normal play if already paused */
+  int pausemsgfuse;		/* a fuse that prints out a reminder every
+				 * few seconds */
+#endif
+  int starttourn;
+  int newgalaxy;
+  int nontteamlock;
+};
+
+
+/*
+ * used for the request field of status.  These are used for a client
+ * querying the queue to see if he can get in
+ */
+
+enum queue_request_type_e
+{
+  REQFREE, REQWHO, REQDEAD
+};
+
+/*
+ * This structure is used to hold various info that each team has, such as
+ * how long before a certain ship type is done with construction.
+ */
+struct team
+{
+  char nickname[32];		/* he is now a %s  */
+  char name[32];		/* come join the %s */
+  char letter;			/* 1-letter abbrev */
+  char shortname[4];		/* 3-letter abbrev */
+
+  int s_turns[NUM_TYPES];	/* turns till another ship is legal */
+  int s_surrender;		/* minutes until this team surrenders */
+  int s_plcount;		/* how many planets this team owns */
+  int s_plcountold;		/* the old planet count */
+};
+
+
+/*
+ * this is used for getting a player name and password and fetching a players
+ * stats
+ */
+struct statentry
+{
+  char name[16];		/* player's name */
+  char password[16];		/* player's password */
+  struct stats stats;		/* player's stats */
+};
+
+/* Used by the function that computes ratings */
+struct rating
+{
+  float battle;
+  float strategy;
+  float special;
+
+  float bombrat;
+  float planetrat;
+  float resrat;
+  float offrat;
+  float dooshrat;
+  float ratio;
+
+  float sbrat;
+  float wbrat;
+  float jsrat;
+};
+
+/*-------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+/*-----------------------------PLAYER STRUCTURE----------------------------*/
+
+#define MAXPORTS	6	/* maximum number of docking bays a ship type
+				 * can have */
+
+/* These are defines for the p_whydead field of the player structure */
+enum why_dead_e
+{
+  KNOREASON,
+  KQUIT,			/* Player quit */
+  KTORP,			/* killed by torp */
+  KPHASER,			/* killed by phaser */
+  KPLANET,			/* killed by planet */
+  KSHIP,			/* killed by other ship */
+  KDAEMON,			/* killed by dying daemon */
+  KWINNER,			/* killed by a winner */
+  KGHOST,			/* killed because a ghost */
+  KGENOCIDE,			/* killed by genocide */
+  KPROVIDENCE,			/* killed by a hacker */
+  KPLASMA,			/* killed by a plasma torpedo */
+  KTOURNEND,			/* killed by the end of the tourn */
+  KOVER,			/* killed by overtime */
+  KTOURNSTART,			/* killed by the start of the tournament */
+  KBINARY,			/* killed by improper client */
+  KMISSILE,			/* killed by a missile */
+  KASTEROID			/* smashed by an asteroid */
+};
+
+/* These are number defines for the player structs p_status field */
+enum player_status_e
+{
+  PFREE,			/* player slot is not filled */
+  POUTFIT,			/* player in process of being ghost busted */
+  PALIVE,			/* player is alive */
+  PEXPLODE,			/* player is in process of exploding */
+  PDEAD,			/* player is dead */
+  PTQUEUE,			/* player is on the tournament queue */
+  POBSERVE			/* player is observing the game */
+};
+
+
+struct player
+{
+  int p_no;			/* player number in player array */
+  int p_updates;		/* Number of updates ship has survived */
+  enum player_status_e p_status;/* Player status */
+  char p_observer;		/* is the player only an observer? */
+  unsigned int p_flags;		/* Player flags */
+  char p_name[16];		/* name of player */
+  char p_login[16];		/* as much of user name and site we can hold */
+  char p_monitor[16];		/* Monitor being played on */
+  struct ship p_ship;		/* Personal ship statistics */
+  int p_x;			/* players x coord in the galaxy */
+  int p_y;			/* player y coord in the galaxy */
+
+  unsigned char p_dir;		/* Real direction */
+  int p_subdir;			/* fraction direction change */
+  unsigned char p_desdir;	/* desired direction */
+
+  int p_speed;			/* Real speed */
+  int p_subspeed;		/* Fractional speed */
+  short p_desspeed;		/* Desired speed */
+  short p_warpdesspeed;		/* Desired warp speed, after prep [BDyess] */
+
+  short p_team;			/* Team I'm on */
+  enum HomeAway
+  {
+    NEITHER, HOME, AWAY
+  }   p_homeaway;
+  char p_spyable;		/* can you watch this player? */
+  char p_teamspy;		/* (mask) what teams can this player watch? */
+
+  int p_damage;			/* Current damage */
+  int p_subdamage;		/* Fractional damage repair */
+
+  int p_shield;			/* Current shield power */
+  int p_subshield;		/* Fractional shield recharge */
+
+  short p_cloakphase;		/* Drawing stage of cloaking engage/disengage */
+
+  short p_ntorp;		/* Number of torps flying */
+  short p_nplasmatorp;		/* Number of plasma torps active */
+  short p_nthingys;		/* number of thingys we own. */
+  long p_specweap;		/* which special weapons we're packing */
+
+  char p_hostile;		/* Who my torps will hurt */
+  char p_swar;			/* Who am I at sticky war with */
+
+  float p_kills;		/* Enemies killed */
+  short p_planet;		/* Planet orbiting or locked onto */
+  char p_orbitdir;		/* direction you are orbiting the planet in */
+  short p_playerl;		/* Player locked onto */
+  short p_armies;		/* armies player is carrying */
+
+  int p_fuel;			/* fuel player's ship currently has */
+  short p_explode;		/* Keeps track of final explosion */
+
+  int p_etemp;			/* player's current engine temp */
+  int p_subetemp;		/* fractional part of E-temp */
+  short p_etime;		/* timer for coming out of E-temp */
+
+  int p_wtemp;			/* current weapon temp */
+  short p_wtime;		/* timer for coming out of W-temp */
+
+  enum why_dead_e p_whydead;	/* Tells you why you died */
+  short p_whodead;		/* Tells you who killed you */
+  struct stats p_stats;		/* player statistics */
+  short p_planets;		/* planets taken this game */
+  short p_armsbomb;		/* armies bombed this game */
+  short p_resbomb;		/* resources bombed */
+  short p_dooshes;		/* armies being carried killed */
+  int p_ghostbuster;		/* ??????????????? */
+  int p_docked;			/* If SB, # docked to, else no base host */
+  int p_port[MAXPORTS];		/* If SB, pno of ship docked to that port,
+				 * else p_port[0] = port # docked to on host. */
+  short p_tractor;		/* What player is in tractor lock */
+  int p_pos;			/* My position in the player file */
+  char p_full_hostname[32];	/* full hostname 4/13/92 TC */
+#if 0
+  int p_planfrac;		/* for getting fractional credit for */
+  int p_bombfrac;		/* bombing and planet taking */
+#endif
+  int p_warptime;		/* timer for warp countdown */
+  int p_jsdock;			/* to keep track of undocking from JS */
+  int p_lastjs;			/* player number of last JS ridden on */
+  int p_lastman;		/* flag used to beam up last men */
+
+  int p_lastrefit;		/* what shipyard you last refitted at (plno) */
+  /* ping stuff */
+  int p_avrt;			/* average round trip time */
+  int p_stdv;			/* standard deviation in round trip time */
+  int p_pkls;			/* packet loss (input/output) */
+
+  /* clue checking goop */
+  int p_cluecountdown;
+  int p_cluedelay;
+
+  int p_ntspid;			/* proc ID of ntserv in control of this slot */
+  int p_zone;			/* total warp zone bonus/penalty [BDyess] */
+
+#ifdef	RC_DISTRESS
+  int gen_distress;		/* generate generic distress messages for
+				 * client */
+#endif
+};
+
+/* These are defines that used for the player struct's p_flags field */
+#define PFSHIELD	  (1<< 0)	/* shields are raised */
+#define PFREPAIR	  (1<< 1)	/* player in repair mode */
+#define PFBOMB		  (1<< 2)	/* player is bombing */
+#define PFORBIT		  (1<< 3)	/* player is orbiting */
+#define PFCLOAK		  (1<< 4)	/* player is cloaked */
+#define PFWEP		  (1<< 5)	/* player is weapon temped */
+#define PFENG		  (1<< 6)	/* player is engine temped */
+#define PFROBOT		  (1<< 7)	/* player is a robot */
+#define PFBEAMUP	  (1<< 8)	/* player is beaming up */
+#define PFBEAMDOWN	  (1<< 9)	/* player is beaming down */
+#define PFSELFDEST	  (1<<10)	/* player is self destructing */
+#define PFGREEN		  (1<<11)	/* player at green alert */
+#define PFYELLOW	  (1<<12)	/* player is at yellow alert */
+#define PFRED		  (1<<13)	/* player is at red alert */
+#define PFPLOCK		  (1<<14)	/* Locked on a player */
+#define PFPLLOCK	  (1<<15)	/* Locked on a planet */
+#define PFCOPILOT	  (1<<16)	/* Allow copilots */
+#define PFWAR		  (1<<17)	/* computer reprogramming for war */
+#define PFPRACTR	  (1<<18)	/* practice type robot (no kills) */
+#define PFDOCK            (1<<19)	/* true if docked to a starbase */
+#define PFREFIT           (1<<20)	/* true if about to refit */
+#define PFREFITTING	  (1<<21)	/* true if currently refitting */
+#define PFTRACT  	  (1<<22)	/* tractor beam activated */
+#define PFPRESS  	  (1<<23)	/* pressor beam activated */
+#define PFDOCKOK	  (1<<24)	/* docking permission */
+#define PFSEEN		  (1<<25)	/* seen by enemy on galactic map? */
+#define PFWARPPREP	  (1<<26)	/* in warp prep */
+#define PFWARP		  (1<<27)	/* ship warping */
+#define PFAFTER		  (1<<28)	/* after burners on */
+#define PFWPSUSPENDED	  (1<<29)	/* warp prep suspended [BDyess] */
+#define PFSNAKE	          (1<<30)	/* it's a space snake */
+#define PFBIRD	          (1<<31)	/* it's a space bird */
+/*-------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+/*-----------------------------TORP STRUCTURE-------------------------------*/
+
+
+/* For status field of torp structure */
+enum torp_status_e
+{
+  TFREE,			/* torp is not being fired */
+  TMOVE,			/* torp is moving with wobble */
+  TEXPLODE,			/* torp is in the process of exploding */
+  TDET,				/* torp is being detted */
+  TOFF,				/* torp is off ??? */
+  TSTRAIGHT,			/* Non-wobbling torp */
+  TRETURN,			/* torp is returning to owner (fighters) */
+  TLAND				/* torp gets recovered */
+};
+
+struct basetorp
+{
+  int bt_no;
+  enum torp_status_e bt_status;
+  int bt_owner;
+  int bt_x, bt_y;
+  unsigned char bt_dir;
+  int bt_damage;
+  int bt_speed;
+  int bt_fuse;
+  char bt_war;
+  char bt_team;
+  char bt_whodet;		/* who detonated... */
+};
+
+
+struct torp
+{
+  struct basetorp t_base;
+#define t_no		t_base.bt_no
+#define t_status	t_base.bt_status
+#define t_owner		t_base.bt_owner
+#define t_x		t_base.bt_x
+#define t_y		t_base.bt_y
+#define t_dir		t_base.bt_dir
+#define t_damage	t_base.bt_damage
+#define t_speed		t_base.bt_speed
+#define t_fuse		t_base.bt_fuse
+#define t_war		t_base.bt_war
+#define t_team		t_base.bt_team
+#define t_whodet	t_base.bt_whodet
+  short t_turns;		/* rate of change of direction if tracking */
+};
+
+/*-------------------------------------------------------------------------*/
+
+struct missile
+{
+  struct basetorp ms_base;
+#define ms_no		ms_base.bt_no
+#define ms_status	ms_base.bt_status
+#define ms_owner	ms_base.bt_owner
+#define ms_x		ms_base.bt_x
+#define ms_y		ms_base.bt_y
+#define ms_dir		ms_base.bt_dir
+#define ms_damage	ms_base.bt_damage
+#define ms_speed	ms_base.bt_speed
+#define ms_fuse		ms_base.bt_fuse
+#define ms_war		ms_base.bt_war
+#define ms_team		ms_base.bt_team
+#define ms_whodet       ms_base.bt_whodet
+  short ms_turns;
+  short ms_locked;
+  short ms_type;		/* A missile, fighter, or mine */
+  short fi_hasfired;		/* has the fighter fired a torp? */
+};
+/* defines for ms_type */
+#define MISSILETHINGY 0
+#define FIGHTERTHINGY 1
+#define MINETHINGY 2
+
+enum thingy_type
+{
+  TT_NONE,
+  TT_WARP_BEACON
+};
+
+struct warp_beacon
+{
+  int owner;
+  int x, y;
+};
+
+struct thingy
+{
+  enum thingy_type type;
+  union
+  {
+    struct warp_beacon wbeacon;
+  }   u;
+};
+
+
+
+/*---------------------------PLASMA TORP STRUCTURE-------------------------*/
+/* For the plasma status field */
+struct plasmatorp
+{
+  struct basetorp pt_base;
+#define pt_no		pt_base.bt_no
+#define pt_status	pt_base.bt_status
+#define PTFREE	TFREE
+#define PTMOVE	TMOVE
+#define PTEXPLODE	TEXPLODE
+#define PTDET	TDET
+#define pt_owner	pt_base.bt_owner
+#define pt_x		pt_base.bt_x
+#define pt_y		pt_base.bt_y
+#define pt_dir		pt_base.bt_dir
+#define pt_damage	pt_base.bt_damage
+#define pt_speed	pt_base.bt_speed
+#define pt_fuse		pt_base.bt_fuse
+#define pt_war		pt_base.bt_war
+#define pt_team		pt_base.bt_team
+#define pt_whodet	pt_base.bt_whodet
+  short pt_turns;		/* ticks turned per cycle */
+};
+
+
+/*-------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+/*-----------------------------PHASER STRUCTURE---------------------------*/
+
+struct phaser
+{
+  int ph_status;		/* What it's up to */
+  unsigned char ph_dir;		/* direction */
+  int ph_target;		/* Who's being hit (for drawing) */
+  int ph_x, ph_y;		/* For when it hits a torp */
+  int ph_fuse;			/* Life left for drawing */
+  int ph_damage;		/* Damage inflicted on victim */
+};
+
+/* for phaser's status field */
+#define PHFREE 0x00		/* phaser not being fired */
+#define PHHIT  (1<<0)		/* When it hits a person */
+#define PHMISS (1<<1)		/* phaser missed */
+#define PHHIT2 (1<<2)		/* When it hits a plasma */
+
+/*-------------------------------------------------------------------------*/
+
+
+
+
+
+
+
+/*-----------------------------PLANET STRUCTURE---------------------------*/
+
+/* This structure is used to hold what each team knows about a planet */
+struct teaminfo
+{				/* to hold what a team knows about a planet */
+  int owner;			/* planet's owner */
+  int armies;			/* number of armies team knows about */
+  int flags;			/* flags team knows about */
+  int timestamp;		/* time info was taken */
+};
+
+struct planet
+{				/* all info about a planet */
+  int pl_no;			/* planet number */
+  int pl_flags;			/* attributes of planet */
+  int pl_owner;			/* the current owner of the planet */
+
+  int pl_x;			/* planet's coords */
+  int pl_y;			/* use the move_planet function to change
+				 * them */
+  int pl_radius;		/* distance from sun */
+  float pl_angle;		/* angular position relative to sun */
+  int pl_system;		/* planetary system number, 0 = no system */
+
+  char pl_name[16];		/* name of the planet */
+  char pl_namelen;		/* name's length--Cuts back on strlen's */
+#if 1
+  char pl_hostile;
+#else
+  char pl_torbit;		/* teams currently in orbit */
+#endif
+  int pl_tshiprepair;		/* repair and shipyard growth timer */
+  int pl_tagri;			/* agri growth timer */
+  int pl_tfuel;			/* fuel depot growth timer */
+  int pl_armies;		/* armies curently on planet */
+  int pl_warning;		/* timer so that planets don't talk too much */
+  int pl_hinfo;			/* which races have info on planet */
+  struct teaminfo pl_tinfo[MAXTEAM + 1];	/* to hold information for
+						 * races */
+  int pl_trevolt;		/* timer for planet revolting */
+  /* space grid support stuff */
+  int pl_next, pl_prev;		/* doubly linked list of planet numbers */
+  int pl_gridnum;		/* to hold grid square number */
+};
+
+/* defines for the pl_flags field of planet struct */
+#if 0
+#define PLHOME 	   0x000100	/* These 4 flags no longer are */
+#define PLCOUP     0x000200	/* used in the server */
+#define PLCHEAP    0x000400
+#define PLCORE     0x000800
+#define PLREPAIR   0x001010	/* planet can repair ships */
+#define PLFUEL     0x002020	/* planet has fuel depot */
+#define PLAGRI     0x004040	/* agricultural thingies built here */
+#define PLSHIPYARD 0x008000	/* planet has a shipyard on it */
+#define PLORESMASK 0x000070	/* mask for original resource flags */
+#define PLRESMASK  0x00F000	/* to mask off all but resource bits */
+#define PLRESSHIFT       12	/* bit to shift right by for resources */
+#define PLSTAR     0x010000	/* planet is actually a star */
+#define PLREDRAW   0x000080	/* Player close for redraw */
+#define PLPOISON   0x000000	/* poison atmosphere, no army growth */
+#define PLATYPE3   0x020000	/* slightly toxic, very slow army growth */
+#define PLATYPE2   0x040000	/* thin atmosphere, slow army growth */
+#define PLATYPE1   0x060000	/* normal human atmosphere, normal growth */
+#define PLATMASK   0x060000	/* to mask off everything but atmos bits */
+#define PLATSHIFT	 17	/* number of right bit shifts for atmos bits */
+#define PLBARREN   0X000000	/* rocky barren surface */
+#define PLDILYTH   0x080000	/* dilythium deposits on the planet */
+#define PLMETAL    0x100000	/* metal deposits on the planet */
+#define PLARABLE   0x200000	/* planet has farmland */
+#define PLSURMASK  0x380000	/* number of surface combinations */
+#define PLSURSHIFT 	 19	/* number of bit shift to surface */
+#define PLPARADISE 0x400000	/* Paradise server flag set to 1 for P server */
+#else
+
+/*
+ * pl_flags is an int of 32 bits:
+ * 
+ * bits 16 and 23 currently define the type of the planet.  The interpretation
+ * of the other bits is dependent upon the planet type.
+ * 
+ * Here is the interpretation for a planet bits 0..3
+ * n bits 4..6			planetary facilities (REPAIR,FUEL,AGRI) bit
+ * 7			redraw (archaic, recyclable?) bits 8..11
+ * ld flags (archaic, recyclable?) bits 12..15			paradise
+ * planetary facilities (REPAIR,FUEL,AGRI,SHIPY) bit  16
+ * osmic object type (also bit 23) bits 17,18			planet
+ * atmosphere type bits 19..21			planetary surface properties
+ * (DILYTH,METAL,ARABLE) bit  22			paradise planet flag
+ * (why?) bit  23			cosmic object type (also bit 16) bits
+ * 24..31	currently unallocated (8 bits to play with)
+ * 
+ * Asteroids are NYI but here is a draft standard: bits 12,15
+ * acilities (REPAIR,FUEL,SHIPY) bit  20			surface
+ * properties (DILYTH,METAL) other bits	currently unallocated
+ * 
+ */
+
+/*
+ * facilities, bits 4..6 and 12..15 valid for planets and asteroids
+ */
+#define PLREPAIR   ((1<<12) | (1<<4))	/* planet can repair ships */
+#define PLFUEL     ((1<<13) | (1<<5))	/* planet has fuel depot */
+#define PLAGRI     ((1<<14) | (1<<6))	/* agricultural thingies built here */
+#define PLSHIPYARD ((1<<15))	/* planet has a shipyard on it */
+#define PLORESMASK (0x7<<4)	/* mask for original resource flags */
+#define PLRESSHIFT       12	/* bit to shift right by for resources */
+#define PLRESMASK  (0xF<<PLRESSHIFT)	/* to mask off all but resource bits */
+
+#define PLREDRAW   (1<<7)	/* Player close for redraw */
+
+#define PLHOME 	   (1<< 8)	/* These 4 flags no longer are */
+#define PLCOUP     (1<< 9)	/* used in the server */
+#define PLCHEAP    (1<<10)
+#define PLCORE     (1<<11)
+
+/* cosmic object types, bits 16, 23, and 24 */
+#define PLPLANET	0	/* object is a planet */
+#define PLSTAR     (1<<16)	/* object is a star */
+#define PLAST	   (1<<23)	/* object is an asteroid NYI */
+#define PLNEB	   ((1<<16)|(1<<23))	/* object is a nebula NYI */
+#define PLBHOLE	                    (1<<24)	/* object is a black hole NYI */
+#define PLPULSAR   ((1<<16)|        (1<<24))	/* object is a pulsar NYI */
+#define PLUK1	   (        (1<<23)|(1<<24))	/* future expansion NYI */
+#define PLWHOLE	   ((1<<16)|(1<<23)|(1<<24))	/* object is a wormhole */
+#define PLTYPEMASK ((1<<16)|(1<<23)|(1<<24))	/* mask to extract object
+						 * type */
+#define PL_TYPE(p) ( (p).pl_flags & PLTYPEMASK )
+
+/*
+ * Atmosphere Types, bits 17 and 18. Valid for planets.
+ */
+#define PLATSHIFT	 17	/* number of right bit shifts for atmos bits */
+#define PLPOISON   (0<<PLATSHIFT)	/* poison atmosphere, no army growth */
+#define PLATYPE3   (1<<PLATSHIFT)	/* slightly toxic, very slow army
+					 * growth */
+#define PLATYPE2   (2<<PLATSHIFT)	/* thin atmosphere, slow army growth */
+#define PLATYPE1   (3<<PLATSHIFT)	/* normal human atmosphere, normal
+					 * growth */
+#define PLATMASK   (0x3<<PLATSHIFT)	/* to mask off everything but atmos
+					 * bits */
+
+/*
+ * Surface Properties, bits 19..21 Valid for planets and asteroids.
+ */
+#define PLBARREN   0		/* rocky barren surface */
+#define PLSURSHIFT 	 19	/* number of bit shift to surface */
+#define PLDILYTH   (1<<(PLSURSHIFT+0))	/* dilythium deposits on the planet */
+#define PLMETAL    (1<<(PLSURSHIFT+1))	/* metal deposits on the planet */
+#define PLARABLE   (1<<(PLSURSHIFT+2))	/* planet has farmland */
+#define PLSURMASK  (0x7<<PLSURSHIFT)	/* number of surface combinations */
+
+
+#define PLPARADISE (1<<22)	/* Paradise server flag set to 1 for P server */
+
+#endif
+/*-------------------------------------------------------------------------*/
+
+
+/*----------------------T E R R A I N   S T R U C T S----------------------*/
+/* Data */
+struct t_unit
+{
+  int alt1;			/* alt1, alt2 are currently unused in the
+				 * client */
+  int alt2;			/* according to MDM (5/16/95) */
+  char types;			/* modify the packet code as well if these
+				 * are put */
+};				/* back in, as well as the structs in
+				 * packets.h */
+
+/* Flags */
+#define T_EMPTY_SPACE 0x00
+#define T_ASTEROIDS   0x01
+#define T_NEBULA      0x02
+#define T_RADIATION   0x04
+#define T_EXPANSN1    0x08
+#define T_EXPANSN2    0x10
+#define T_EXPANSN3    0x20
+#define T_EXPANSN4    0x40
+#define T_EXPANSN5    0x80
+
+/*-------------------------------------------------------------------------*/
+
+
+/*-----------------------------MESSAGE STRUCTS-----------------------------*/
+
+struct message
+{
+  int m_no;			/* message number in array of messgs */
+  int m_flags;			/* flags for message type */
+  int m_time;			/* time message sent???? */
+  int m_recpt;			/* who it should be sent to */
+  char m_data[80];		/* the message string */
+  int m_from;			/* who it is from */
+};
+
+/*
+ * for m_flags field -- lower five bits used for what kind of group the
+ * message is sent to
+ */
+#define MVALID (1<<0)		/* the message is valid--has not been sent */
+#define MINDIV (1<<1)		/* sent to an individual */
+#define MTEAM  (1<<2)		/* sent to a team */
+#define MALL   (1<<3)		/* sent to eveyone */
+
+/* order these by importance (0x100 - 0x400) */
+/*
+ * many of these are not used by the client, so their incorrect value doesn't
+ * matter.  however we should note that the packet only has a width of 8 bits
+ * for the type field, and many of these flags are > 8 bits wide --eld
+ */
+
+#define	MGOD   ( 1<<4)		/* sent to god -- misc.c, socket.c */
+#define MGENO  ( 1<<5)		/* genocide message -- conquer.c */
+#define MCONQ  ( 2<<5)		/* conquer message -- planets.c */
+#define MTAKE  ( 1<<5)		/* planet taken message -- player.c */
+#define MDEST  ( 2<<5)		/* planet destroyed message -- player.c */
+#define MKILLA ( 5<<5)		/* a person killed -- dutil.c, snakemove.c */
+#define MBOMB  ( 3<<5)		/* bombarding planet -- planets.c */
+#define MKILLP ( 7<<5)		/* a person killed -- NOT USED */
+#define MKILL  ( 8<<5)		/* a person killed -- NOT USED */
+#define MLEAVE ( 9<<5)		/* player leaving game message -- main.c */
+#define MJOIN  (10<<5)		/* player joining game -- enter.c */
+#define MGHOST (11<<5)		/* player ghostbusted -- daemonII.c */
+#define MCOUP1 (12<<5)		/* a coup occured -- NOT USED */
+#define MCOUP2 (13<<5)		/* -- NOT USED */
+#define MDISTR (14<<5)		/* flag for a distress message */
+#define MMASK  (0xf<<5)		/* bits in the flags field should be sent --
+				 * 
+				/* message control structure */
+struct mctl
+{				/* used to keep track of position in */
+  int mc_current;		/* array we put our last message */
+};
+
+/*-------------------------------------------------------------------------*/
+
+
+
+struct rsa_key
+{
+  unsigned char client_type[KEY_SIZE];
+  unsigned char architecture[KEY_SIZE];
+  unsigned char global[KEY_SIZE];
+  unsigned char public[KEY_SIZE];
+};
+
+
+/*
+ * RCD stuff, from bronco server 2.7pl13.
+ */
+#ifdef RC_DISTRESS
+struct distress
+{
+  unsigned char sender;
+  unsigned char dam, shld, arms, wtmp, etmp, fuelp, sts;
+  unsigned char wtmpflag, etempflag, cloakflag, distype, macroflag, ttype;
+  unsigned char close_pl, close_en, target, tclose_pl, tclose_en, pre_app,
+      i;
+  unsigned char close_j, close_fr, tclose_j, tclose_fr;
+  unsigned char cclist[6];	/* CC list */
+  unsigned char preappend[80];	/* text which we pre- or append */
+};
+
+/*
+ * macro management
+ */
+struct dmacro_list
+{
+  char c;
+  char *name;
+  char *macro;
+};
+
+/*
+ * distress types
+ */
+enum dist_type
+{
+  /* help me do series */
+  take = 1, ogg, bomb, space_control, help1, help2, help3, help4,
+
+  /* doing series */
+  escorting, ogging, bombing, controlling, doing1, doing2, doing3, doing4,
+
+  /* other info series */
+  free_beer,			/* player x is totally hosed now */
+  no_gas,			/* player x has no gas */
+  crippled,			/* player x is crippled but may have fuel */
+  pickup,			/* player x picked up armies */
+  pop,				/* there was a pop somewhere */
+  carrying,			/* I am carrying */
+  other1, other2,
+
+  /* just a generic distress call */
+  generic
+};
+
+/*
+ * targets of messages
+ */
+enum target_type
+{
+  none,
+  planet,
+  player
+};
+
+/*
+ * from bronco server2.7pl3
+ */
+/*
+ * The General distress has format:
+ * 
+ * A 'E' will do byte1-8 inclusive. Macros can do more but haven't been
+ * implemented that way yet.
+ * 
+ * byte1: xxyzzzzz where zzzzz is dist_type, xx is target_type and y is 1 if
+ * this is a macro and not just a simple distress (a simple distress will
+ * ONLY send ship info like shields, armies, status, location, etc.)
+ * 
+ * byte2: 1fff ffff - f = percentage fuel remaining (0-100) byte3: 1ddd dddd - %
+ * damage byte4: 1sss ssss - % shields remaining byte5: 1eee eeee - % etemp
+ * byte6: 1www wwww - % wtemp byte7: 100a aaaa - armies carried byte8: (lsb
+ * of me->p_status) & 0x80 byte9: 1ppp pppp - planet closest to me byte10:
+ * 1eee eeee - enemy closest to me
+ * 
+ * Byte 11 and on are only sent if y (from byte 1) is = 1 although even for
+ * simplest case (y=0) we should send byte14+ = 0x80 and then a null so that
+ * in future we can send a cc list and pre/append text byte11: 1ttt tttt -
+ * target (either player number or planet number) byte12: 1ppp pppp - planet
+ * closest to target byte13: 1eee eeee - enemy closest to target byte14+: cc
+ * list (each player to cc this message to is 11pp ppp) cc list is terminated
+ * by 1000 0000 or 0100 0000 ) pre-pend     append byte15++: the text to pre
+ * or append .. depending on termination above. text is null terminated and
+ * the last thing in this distress
+ */
+
+#endif				/* RCD */
+
+struct command_handler
+{
+  char *command;
+  int tag;
+  char *desc;
+  int (*handler) ();
+};
+
+#ifdef VOTING
+struct vote_handler
+{
+  char *type;
+  int tag;
+  int minpass;
+  int start;
+  char *desc;
+  int frequency;
+  int (*handler) ();
+};
+
+#define VC_ALL     0x0001	/* Majority Vote */
+#define VC_TEAM    0x0002	/* Team Vote     */
+#define VC_GLOG    0x0010	/* Write Votes to God Log */
+#define VC_PLAYER  0x0020	/* Each player can be voted on, like eject */
+
+
+#endif
+
+/*-------------------------SOME CLIENT STRUCTURES--------------------------*/
+
+/* used to tell what planet or player mouse is pointing to */
+struct obtype
+{
+  int o_type;			/* mouse pointing to a player or planet */
+  int o_num;			/* the player or planet number */
+};
+
+/* used in the o_type structure */
+#define PLANETTYPE 1		/* mouse on planet */
+#define PLAYERTYPE 2		/* mouse on player */
+
+
+/* used to hold a players rank */
+struct rank
+{
+  int genocides;		/* minimum number of genocides */
+  float di;			/* minimum destruction inflicted */
+  float battle;			/* minimum battle ratings */
+  float strategy;		/* minimum strategy ratings */
+  float specship;		/* minimum total ratings in a specialty */
+  /* ship  SB + WB + JS */
+  char *name;			/* name of this rank */
+};
+
+
+struct royalty
+{
+  char *name;			/* name of rank */
+};
+
+/*-------------------------------------------------------------------------*/
+
+
+
+#endif
+
+/*---------END OF FILE---------*/