Moved Stars45 to StarsEx

1 files changed, 965 insertions, 0 deletions

diff --git a/StarsEx/NetData.h b/StarsEx/NetData.h
new file mode 100644
index 0000000..ebb7fd0
--- /dev/null
+++ b/StarsEx/NetData.h
@@ -0,0 +1,965 @@
+/*  Starshatter: The Open Source Project
+    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
+    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
+    Copyright (c) 1997-2006, Destroyer Studios LLC.
+
+    AUTHOR:       John DiCamillo
+
+
+    OVERVIEW
+    ========
+    Payload structures for multiplayer network packets
+*/
+
+#ifndef NetData_h
+#define NetData_h
+
+#include "Types.h"
+#include "Geometry.h"
+#include "Text.h"
+
+// +--------------------------------------------------------------------+
+
+// UNRELIABLE: 0x01 - 0x0F
+
+const BYTE NET_PING           = 0x01;
+const BYTE NET_PONG           = 0x02;
+const BYTE NET_OBJ_LOC        = 0x03;
+
+// RELIABLE:   0x10 - 0x7F
+
+const BYTE NET_JOIN_REQUEST   = 0x10;
+const BYTE NET_JOIN_ANNOUNCE  = 0x11;
+const BYTE NET_QUIT_REQUEST   = 0x12;
+const BYTE NET_QUIT_ANNOUNCE  = 0x13;
+const BYTE NET_KICK_REQUEST   = 0x14;
+const BYTE NET_KICK_ANNOUNCE  = 0x15;
+const BYTE NET_GAME_OVER      = 0x16;
+const BYTE NET_COMM_MESSAGE   = 0x17;
+const BYTE NET_CHAT_MESSAGE   = 0x18;
+const BYTE NET_DISCONNECT     = 0x19;
+
+const BYTE NET_OBJ_DAMAGE     = 0x20;
+const BYTE NET_OBJ_KILL       = 0x21;
+const BYTE NET_OBJ_SPAWN      = 0x22;
+const BYTE NET_OBJ_HYPER      = 0x23;
+const BYTE NET_OBJ_TARGET     = 0x24;
+const BYTE NET_OBJ_EMCON      = 0x25;
+const BYTE NET_SYS_DAMAGE     = 0x26;
+const BYTE NET_SYS_STATUS     = 0x27;
+
+const BYTE NET_ELEM_CREATE    = 0x28;
+const BYTE NET_SHIP_LAUNCH    = 0x29;
+const BYTE NET_NAV_DATA       = 0x2A;
+const BYTE NET_NAV_DELETE     = 0x2B;
+const BYTE NET_ELEM_REQUEST   = 0x2C;
+
+const BYTE NET_WEP_TRIGGER    = 0x30;
+const BYTE NET_WEP_RELEASE    = 0x31;
+const BYTE NET_WEP_DESTROY    = 0x32;
+
+const BYTE NET_SELF_DESTRUCT  = 0x3F;
+
+// +--------------------------------------------------------------------+
+
+class Ship;
+
+// +--------------------------------------------------------------------+
+
+class NetData
+{
+public:
+    static const char* TYPENAME() { return "NetData"; }
+
+    NetData()          { }
+    virtual ~NetData() { }
+
+    virtual int    Type()               const { return 0; }
+    virtual int    Length()             const { return 0; }
+    virtual BYTE*  Pack()                     { return 0; }
+    virtual bool   Unpack(const BYTE* data)   { return 0; }
+
+    virtual DWORD  GetObjID()           const { return 0; }
+    virtual void   SetObjID(DWORD o)          {           }
+};
+
+// +--------------------------------------------------------------------+
+
+class NetObjLoc : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetObjLoc"; }
+
+    NetObjLoc() : objid(0), throttle(false), augmenter(false), shield(0) { }
+    NetObjLoc(DWORD oid, const Point& pos, const Point& orient, const Point& vel) :
+    objid(oid), location(pos), euler(orient), velocity(vel),
+    throttle(false), augmenter(false), gear(false), shield(0) { }
+
+    enum { TYPE=NET_OBJ_LOC, SIZE=24 };
+
+    virtual BYTE*  Pack();
+    virtual bool   Unpack(const BYTE* data);
+    virtual int    Type()                     const { return TYPE;       }
+    virtual int    Length()                   const { return SIZE;       }
+
+    virtual DWORD  GetObjID()                 const { return objid;      }
+    virtual void   SetObjID(DWORD id)               { objid = id;        }
+
+    Point          GetLocation()              const { return location;   }
+    Point          GetVelocity()              const { return velocity;   }
+    Point          GetOrientation()           const { return euler;      }
+    bool           GetThrottle()              const { return throttle;   }
+    bool           GetAugmenter()             const { return augmenter;  }
+    bool           GetGearDown()              const { return gear;       }
+    int            GetShield()                const { return shield;     }
+
+    void           SetLocation(const Point& loc)    { location = loc; }
+    void           SetVelocity(const Point& v)      { velocity = v;   }
+    void           SetOrientation(const Point& o)   { euler = o;      }
+    void           SetThrottle(bool t)              { throttle = t;   }
+    void           SetAugmenter(bool a)             { augmenter = a;  }
+    void           SetGearDown(bool g)              { gear = g;       }
+    void           SetShield(int s)                 { shield = s;     }
+
+private:
+    DWORD    objid;
+    Point    location;
+    Point    velocity;
+    Point    euler;
+    bool     throttle;
+    bool     augmenter;
+    bool     gear;
+    int      shield;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetJoinRequest : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetJoinRequest"; }
+
+    NetJoinRequest() : index(0) { }
+
+    enum { TYPE=NET_JOIN_REQUEST, SIZE=128 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    const char*       GetName()               const { return name;    }
+    const char*       GetPassword()           const { return pass;    }
+    const char*       GetSerialNumber()       const { return serno;   }
+    const char*       GetElement()            const { return elem;    }
+    int               GetIndex()              const { return index;   }
+
+    void              SetName(const char* n)        { name = n;       }
+    void              SetPassword(const char* p)    { pass = p;       }
+    void              SetSerialNumber(const char* s){ serno = s;      }
+    void              SetElement(const char* n)     { elem = n;       }
+    void              SetIndex(int n)               { index = n;      }
+
+private:
+    Text     name;    // callsign
+    Text     pass;    // password
+    Text     serno;   // box cdkey
+    Text     elem;    // element to join
+    int      index;   // one-based index
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetJoinAnnounce : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetJoinAnnounce"; }
+
+    NetJoinAnnounce();
+
+    enum { TYPE=NET_JOIN_ANNOUNCE, SIZE=200 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;       }
+    virtual int       Length()                const { return SIZE;       }
+
+    virtual DWORD     GetObjID()              const { return objid;      }
+    virtual void      SetObjID(DWORD o)             { objid = o;         }
+
+    const char*       GetName()               const { return name;       }
+    const char*       GetElement()            const { return elem;       }
+    const char*       GetRegion()             const { return region;     }
+    const Point&      GetLocation()           const { return loc;        }
+    const Point&      GetVelocity()           const { return velocity;   }
+    int               GetIndex()              const { return index;      }
+    double            GetIntegrity()          const { return integrity;  }
+    int               GetRespawns()           const { return respawns;   }
+    int               GetDecoys()             const { return decoys;     }
+    int               GetProbes()             const { return probes;     }
+    int               GetFuel()               const { return fuel;       }
+    int               GetShield()             const { return shield;     }
+    const int*        GetAmmo()               const { return ammo;       }
+
+    void              SetShip(Ship* s);
+
+    void              SetName(const char* n)        { name = n;          }
+    void              SetElement(const char* n)     { elem = n;          }
+    void              SetRegion(const char* r)      { region = r;        }
+    void              SetLocation(const Point& l)   { loc = l;           }
+    void              SetVelocity(const Point& v)   { velocity = v;      }
+    void              SetIndex(int n)               { index = n;         }
+    void              SetIntegrity(double n)        { integrity = (float) n; }
+    void              SetRespawns(int n)            { respawns = n;      }
+    void              SetDecoys(int n)              { decoys = n;        }
+    void              SetProbes(int n)              { probes = n;        }
+    void              SetFuel(int n)                { fuel = n;          }
+    void              SetShield(int n)              { shield = n;        }
+    void              SetAmmo(const int* a);
+
+    virtual DWORD     GetNetID()              const { return nid;        }
+    virtual void      SetNetID(DWORD n)             { nid = n;           }
+
+private:
+    Text     name;       // callsign
+    Text     elem;       // element to join
+    Text     region;     // region ship is in
+    Point    loc;        // location of ship
+    Point    velocity;   // velocity of ship
+    int      index;      // one-based index
+    float    integrity;  // hull integrity
+    int      respawns;
+    int      decoys;
+    int      probes;
+    int      fuel;
+    int      shield;
+    int      ammo[16];
+    DWORD    objid;
+    DWORD    nid;        // not sent over network
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetQuitAnnounce : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetQuitAnnounce"; }
+
+    NetQuitAnnounce() : objid(0), disconnected(false) { }
+
+    enum { TYPE=NET_QUIT_ANNOUNCE, SIZE=5 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+    virtual bool      GetDisconnected()       const { return disconnected; }
+    virtual void      SetDisconnected(bool d)       { disconnected = d;    }
+
+private:
+    DWORD    objid;
+    bool     disconnected;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetDisconnect : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetDisconnect"; }
+
+    NetDisconnect() { }
+
+    enum { TYPE=NET_DISCONNECT, SIZE=2 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+private:
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetObjDamage : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetObjDamage"; }
+
+    NetObjDamage() : objid(0), damage(0), shotid(0) { }
+
+    enum { TYPE=NET_OBJ_DAMAGE, SIZE=12 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+    virtual DWORD     GetShotID()             const { return shotid;  }
+    virtual void      SetShotID(DWORD o)            { shotid = o;     }
+
+    float             GetDamage()             const { return damage;  }
+    void              SetDamage(float d)            { damage = d;     }
+
+private:
+    DWORD    objid;
+    float    damage;
+    DWORD    shotid;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetObjKill : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetObjKill"; }
+
+    NetObjKill() : objid(0), kill_id(0), killtype(0), respawn(false), deck(0) { }
+
+    enum { TYPE=NET_OBJ_KILL, SIZE=24,
+        KILL_MISC = 0,
+        KILL_PRIMARY,
+        KILL_SECONDARY,
+        KILL_COLLISION,
+        KILL_CRASH,
+        KILL_DOCK
+    };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+    virtual DWORD     GetKillerID()           const { return kill_id; }
+    virtual void      SetKillerID(DWORD o)          { kill_id = o;    }
+    virtual int       GetKillType()           const { return killtype;}
+    virtual void      SetKillType(int t)            { killtype = t;   }
+    virtual bool      GetRespawn()            const { return respawn; }
+    virtual void      SetRespawn(bool r)            { respawn = r;    }
+    virtual Point     GetRespawnLoc()         const { return loc;     }
+    virtual void      SetRespawnLoc(const Point& p) { loc = p;        }
+    virtual int       GetFlightDeck()         const { return deck;    }
+    virtual void      SetFlightDeck(int n)          { deck = n;       }
+
+private:
+    DWORD    objid;
+    DWORD    kill_id;
+    int      killtype;
+    bool     respawn;
+    Point    loc;
+    int      deck;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetObjHyper : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetObjHyper"; }
+
+    NetObjHyper() : objid(0), fc_src(0), fc_dst(0), transtype(0) { }
+
+    enum { TYPE=NET_OBJ_HYPER, SIZE=56 };
+
+    virtual BYTE*  Pack();
+    virtual bool   Unpack(const BYTE* data);
+    virtual int    Type()                     const { return TYPE;       }
+    virtual int    Length()                   const { return SIZE;       }
+
+    virtual DWORD  GetObjID()                 const { return objid;      }
+    virtual void   SetObjID(DWORD id)               { objid = id;        }
+
+    const Point&   GetLocation()              const { return location;   }
+    const Text&    GetRegion()                const { return region;     }
+    DWORD          GetFarcaster1()            const { return fc_src;     }
+    DWORD          GetFarcaster2()            const { return fc_dst;     }
+    int            GetTransitionType()        const { return transtype;  }
+
+    void           SetLocation(const Point& loc)    { location  = loc;   }
+    void           SetRegion(const char* rgn)       { region    = rgn;   }
+    void           SetFarcaster1(DWORD f)           { fc_src    = f;     }
+    void           SetFarcaster2(DWORD f)           { fc_dst    = f;     }
+    void           SetTransitionType(int t)         { transtype = t;     }
+
+private:
+    DWORD    objid;
+    Point    location;
+    Text     region;
+    DWORD    fc_src;
+    DWORD    fc_dst;
+    int      transtype;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetObjTarget : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetObjTarget"; }
+
+    NetObjTarget() : objid(0), tgtid(0), sysix(0) { }
+
+    enum { TYPE=NET_OBJ_TARGET, SIZE=7 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+    DWORD             GetTgtID()              const { return tgtid;   }
+    void              SetTgtID(DWORD o)             { tgtid = o;      }
+    int               GetSubtarget()          const { return sysix;   }
+    void              SetSubtarget(int n)           { sysix = n;      }
+
+private:
+    DWORD    objid;
+    DWORD    tgtid;
+    int      sysix;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetObjEmcon : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetObjEmcon"; }
+
+    NetObjEmcon() : objid(0), emcon(0) { }
+
+    enum { TYPE=NET_OBJ_EMCON, SIZE=5 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+    int               GetEMCON()              const { return emcon;   }
+    void              SetEMCON(int n)               { emcon = n;      }
+
+private:
+    DWORD    objid;
+    int      emcon;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetSysDamage : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetSysDamage"; }
+
+    NetSysDamage() : objid(0), sysix(-1), dmgtype(0), damage(0) { }
+
+    enum { TYPE=NET_SYS_DAMAGE, SIZE=12 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+    int               GetSystem()             const { return sysix;   }
+    void              SetSystem(int n)              { sysix = n;      }
+    BYTE              GetDamageType()         const { return dmgtype; }
+    void              SetDamageType(BYTE t)         { dmgtype = t;    }
+    double            GetDamage()             const { return damage;  }
+    void              SetDamage(double d)           { damage = d;     }
+
+private:
+    DWORD    objid;
+    int      sysix;
+    BYTE     dmgtype;
+    double   damage;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetSysStatus : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetSysStatus"; }
+
+    NetSysStatus() : objid(0), sysix(-1), status(0), power(0), reactor(0),
+    avail(1) { }
+
+    enum { TYPE=NET_SYS_STATUS, SIZE=12 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+    int               GetSystem()             const { return sysix;   }
+    void              SetSystem(int n)              { sysix = n;      }
+    BYTE              GetStatus()             const { return status;  }
+    void              SetStatus(BYTE s)             { status = s;     }
+    int               GetPower()              const { return power;   }
+    void              SetPower(int n)               { power = n;      }
+    int               GetReactor()            const { return reactor; }
+    void              SetReactor(int n)             { reactor = n;    }
+    double            GetAvailability()       const { return avail;   }
+    void              SetAvailablility(double a)    { avail = a;      }
+
+private:
+    DWORD    objid;
+    int      sysix;
+    int      status;
+    int      power;
+    int      reactor;
+    double   avail;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetWepTrigger : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetWepTrigger"; }
+
+    NetWepTrigger() : objid(0), tgtid(0), sysix(-1), index(0), count(0),
+    decoy(false), probe(false) { }
+
+    enum { TYPE=NET_WEP_TRIGGER, SIZE=10 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+    DWORD             GetTgtID()              const { return tgtid;   }
+    void              SetTgtID(DWORD o)             { tgtid = o;      }
+    int               GetSubtarget()          const { return sysix;   }
+    void              SetSubtarget(int n)           { sysix = n;      }
+    int               GetIndex()              const { return index;   }
+    void              SetIndex(int n)               { index = n;      }
+    int               GetCount()              const { return count;   }
+    void              SetCount(int n)               { count = n;      }
+    bool              GetDecoy()              const { return decoy;   }
+    void              SetDecoy(bool d)              { decoy = d;      }
+    bool              GetProbe()              const { return probe;   }
+    void              SetProbe(bool p)              { probe = p;      }
+
+private:
+    DWORD    objid;
+    DWORD    tgtid;
+    int      sysix;
+    int      index;
+    int      count;
+    bool     decoy;
+    bool     probe;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetWepRelease : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetWepRelease"; }
+
+    NetWepRelease() : objid(0), tgtid(0), wepid(0), sysix(-1), index(0),
+    decoy(false), probe(false) { }
+
+    enum { TYPE=NET_WEP_RELEASE, SIZE=11 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+    DWORD             GetTgtID()              const { return tgtid;   }
+    void              SetTgtID(DWORD o)             { tgtid = o;      }
+    int               GetSubtarget()          const { return sysix;   }
+    void              SetSubtarget(int n)           { sysix = n;      }
+    DWORD             GetWepID()              const { return wepid;   }
+    void              SetWepID(DWORD o)             { wepid = o;      }
+    int               GetIndex()              const { return index;   }
+    void              SetIndex(int n)               { index = n;      }
+    bool              GetDecoy()              const { return decoy;   }
+    void              SetDecoy(bool d)              { decoy = d;      }
+    bool              GetProbe()              const { return probe;   }
+    void              SetProbe(bool p)              { probe = p;      }
+
+private:
+    DWORD    objid;
+    DWORD    tgtid;
+    DWORD    wepid;
+    int      sysix;
+    int      index;
+    bool     decoy;
+    bool     probe;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetWepDestroy : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetWepDestroy"; }
+
+    NetWepDestroy() : objid(0) { }
+
+    enum { TYPE=NET_WEP_DESTROY, SIZE=4 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+private:
+    DWORD    objid;
+
+    BYTE     data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class RadioMessage;
+class NetCommMsg : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetCommMsg"; }
+
+    NetCommMsg() : objid(0), radio_message(0), length(0) { }
+    virtual ~NetCommMsg();
+
+    enum { TYPE=NET_COMM_MESSAGE, SIZE=200 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return length;  }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+    RadioMessage*     GetRadioMessage()             { return radio_message; }
+    void              SetRadioMessage(RadioMessage* m);
+
+private:
+    DWORD          objid;
+    RadioMessage*  radio_message;
+
+    int            length;
+    BYTE           data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetChatMsg : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetChatMsg"; }
+
+    NetChatMsg() : dstid(0), length(0) { }
+
+    enum { TYPE=NET_CHAT_MESSAGE, SIZE=210, MAX_CHAT=160, HDR_LEN=4, NAME_LEN=32 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return length;  }
+
+    virtual DWORD     GetDstID()              const { return dstid;   }
+    virtual void      SetDstID(DWORD d)             { dstid = d;      }
+    const Text&       GetName()               const { return name;    }
+    void              SetName(const char* m)        { name = m;       }
+    const Text&       GetText()               const { return text;    }
+    void              SetText(const char* m)        { text = m;       }
+
+private:
+    DWORD          dstid;
+    Text           name;
+    Text           text;
+
+    int            length;
+    BYTE           data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetElemRequest : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetElemRequest"; }
+
+    NetElemRequest();
+
+    enum { TYPE=NET_ELEM_REQUEST, SIZE=64, NAME_LEN=32 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;       }
+    virtual int       Length()                const { return SIZE;       }
+
+    const Text&       GetName()               const { return name;       }
+    void              SetName(const char* m)        { name = m;          }
+
+private:
+    Text           name;
+
+    BYTE           data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetElemCreate : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetElemCreate"; }
+
+    NetElemCreate();
+
+    enum { TYPE=NET_ELEM_CREATE, SIZE=192, NAME_LEN=32 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;       }
+    virtual int       Length()                const { return SIZE;       }
+
+    const Text&       GetName()               const { return name;       }
+    void              SetName(const char* m)        { name = m;          }
+    const Text&       GetCommander()          const { return commander;  }
+    void              SetCommander(const char* m)   { commander = m;     }
+    const Text&       GetObjective()         const  { return objective;  }
+    void              SetObjective(const char* m)   { objective = m;     }
+    const Text&       GetCarrier()            const { return carrier;    }
+    void              SetCarrier(const char* m)     { carrier = m;       }
+
+    int               GetIFF()                const { return iff;        }
+    void              SetIFF(int n)                 { iff = n;           }
+    int               GetType()               const { return type;       }
+    void              SetType(int n)                { type = n;          }
+    int               GetIntel()              const { return intel;      }
+    void              SetIntel(int n)               { intel = n;         }
+    int               GetObjCode()            const { return obj_code;   }
+    void              SetObjCode(int n)             { obj_code = n;      }
+    int               GetSquadron()           const { return squadron;   }
+    void              SetSquadron(int n)            { squadron = n;      }
+
+    int*              GetLoadout()                  { return load;       }
+    void              SetLoadout(int* n);
+    int*              GetSlots()                    { return slots;      }
+    void              SetSlots(int* n);
+
+    bool              GetAlert()              const { return alert;      }
+    void              SetAlert(bool a)              { alert = a;         }
+
+    bool              GetInFlight()           const { return in_flight;  }
+    void              SetInFlight(bool f)           { in_flight = f;     }
+
+private:
+    Text           name;
+    int            iff;
+    int            type;
+    int            intel;
+    int            obj_code;
+    int            squadron;
+
+    Text           commander;
+    Text           objective;
+    Text           carrier;
+
+    int            load[16];
+    int            slots[4];
+    bool           alert;
+    bool           in_flight;
+
+    BYTE           data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetShipLaunch : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetShipLaunch"; }
+
+    NetShipLaunch() : objid(0), squadron(0), slot(0) { }
+
+    enum { TYPE=NET_SHIP_LAUNCH, SIZE=16 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;       }
+    virtual int       Length()                const { return SIZE;       }
+
+    virtual DWORD     GetObjID()              const { return objid;      }
+    virtual int       GetSquadron()           const { return squadron;   }
+    virtual int       GetSlot()               const { return slot;       }
+
+    virtual void      SetObjID(DWORD o)             { objid = o;         }
+    virtual void      SetSquadron(int s)            { squadron = s;      }
+    virtual void      SetSlot(int s)                { slot = s;          }
+
+private:
+    DWORD          objid;
+    int            squadron;
+    int            slot;
+
+    BYTE           data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class Instruction;
+
+class NetNavData : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetNavData"; }
+
+    NetNavData();
+    virtual ~NetNavData();
+
+    enum { TYPE=NET_NAV_DATA, SIZE=144, NAME_LEN=32 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;       }
+    virtual int       Length()                const { return SIZE;       }
+
+    virtual DWORD     GetObjID()              const { return objid;      }
+    bool              IsAdd()                 const { return create;     }
+    bool              IsEdit()                const { return !create;    }
+    const Text&       GetElem()               const { return elem;       }
+    int               GetIndex()              const { return index;      }
+    Instruction*      GetNavPoint()           const { return navpoint;   }
+
+    virtual void      SetObjID(DWORD o)             { objid = o;         }
+    void              SetAdd(bool b)                { create = b;        }
+    void              SetElem(const char* e)        { elem = e;          }
+    void              SetIndex(int n)               { index = n;         }
+    void              SetNavPoint(Instruction* n);
+
+private:
+    DWORD             objid;
+    bool              create;
+    Text              elem;
+    int               index;
+    Instruction*      navpoint;
+
+    BYTE              data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetNavDelete : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetNavDelete"; }
+
+    NetNavDelete() : objid(0), index(0) { }
+
+    enum { TYPE=NET_NAV_DELETE, SIZE=40 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;       }
+    virtual int       Length()                const { return SIZE;       }
+
+    virtual DWORD     GetObjID()              const { return objid;      }
+    const Text&       GetElem()               const { return elem;       }
+    int               GetIndex()              const { return index;      }
+
+    virtual void      SetObjID(DWORD o)             { objid = o;         }
+    void              SetElem(const char* e)        { elem = e;          }
+    void              SetIndex(int n)               { index = n;         }
+
+private:
+    DWORD             objid;
+    Text              elem;
+    int               index;
+
+    BYTE              data[SIZE];
+};
+
+// +--------------------------------------------------------------------+
+
+class NetSelfDestruct : public NetData
+{
+public:
+    static const char* TYPENAME() { return "NetSelfDestruct"; }
+
+    NetSelfDestruct() : objid(0), damage(0) { }
+
+    enum { TYPE=NET_SELF_DESTRUCT, SIZE=8 };
+
+    virtual BYTE*     Pack();
+    virtual bool      Unpack(const BYTE* data);
+    virtual int       Type()                  const { return TYPE;    }
+    virtual int       Length()                const { return SIZE;    }
+
+    virtual DWORD     GetObjID()              const { return objid;   }
+    virtual void      SetObjID(DWORD o)             { objid = o;      }
+
+    float             GetDamage()             const { return damage;  }
+    void              SetDamage(float d)            { damage = d;     }
+
+private:
+    DWORD    objid;
+    float    damage;
+
+    BYTE     data[SIZE];
+};
+
+
+// +--------------------------------------------------------------------+
+
+#endif  // NetData_h
+