NetGameServer.cpp

Go to the documentation of this file.

/*  Project Starshatter 5.0
        Destroyer Studios LLC
        Copyright © 1997-2007. All Rights Reserved.

        SUBSYSTEM:    Stars.exe
        FILE:         NetGameServer.cpp
        AUTHOR:       John DiCamillo


        OVERVIEW
        ========
        Server-Side Network Game Manager class
*/

#include "MemDebug.h"
#include "NetGameServer.h"
#include "NetServerConfig.h"
#include "NetLobbyServer.h"
#include "NetPlayer.h"
#include "NetUser.h"
#include "NetMsg.h"
#include "NetData.h"
#include "StarServer.h"
#include "Ship.h"
#include "ShipDesign.h"
#include "Shield.h"
#include "Sim.h"
#include "SimEvent.h"
#include "Element.h"
#include "HUDView.h"
#include "RadioMessage.h"
#include "RadioView.h"
#include "Instruction.h"
#include "Hangar.h"
#include "FlightDeck.h"
#include "Mission.h"

#include "NetLayer.h"
#include "NetHost.h"
#include "NetPeer.h"
#include "NetUtil.h"
#include "Game.h"
#include "Light.h"

// +--------------------------------------------------------------------+

const int MAX_NET_FPS   = 20;
const int MIN_NET_FRAME = 1000 / MAX_NET_FPS;

// +--------------------------------------------------------------------+

NetGameServer::NetGameServer()
{
        Print("Constructing NetGameServer\n");

        WORD    server_port = 11101;

        if (NetServerConfig::GetInstance())
        server_port = NetServerConfig::GetInstance()->GetGamePort();

        NetAddr server(NetHost().Address().IPAddr(), server_port);

        link = new(__FILE__,__LINE__) NetLink(server);

        ListIter<SimRegion> rgn_iter = sim->GetRegions();
        while (++rgn_iter) {
                SimRegion* rgn = rgn_iter.value();

                ListIter<Ship> iter = rgn->Ships();
                while (++iter) {
                        Ship* s = iter.value();
                        s->SetObjID(GetNextObjID());
                        Observe(s);
                        ships.append(s);
                }
        }

        if (local_player) {
                Observe(local_player);
                objid = local_player->GetObjID();
        }
}

NetGameServer::~NetGameServer()
{
        ListIter<NetPlayer> player = players;
        while (++player) {
                NetPlayer* p = player.value();

                if (p->GetShip())
                p->GetShip()->SetRespawnCount(0);

                link->SendMessage(p->GetNetID(), NET_GAME_OVER, 0, 0, NetMsg::RELIABLE);
        }

        Sleep(500);

        ListIter<Ship> iter = ships;
        while (++iter) {
                Ship* s = iter.value();
                s->SetRespawnCount(0);
        }

        zombies.destroy();
        ships.clear();
}

// +--------------------------------------------------------------------+

void
NetGameServer::ExecFrame()
{
        NetGame::ExecFrame();
        CheckSessions();

        ListIter<SimRegion> rgn_iter = sim->GetRegions();
        while (++rgn_iter) {
                SimRegion* rgn = rgn_iter.value();

                ListIter<Ship> iter = rgn->Ships();
                while (++iter) {
                        Ship* s = iter.value();

                        if (s->GetObjID() == 0) {
                                s->SetObjID(GetNextObjID());
                                Observe(s);
                                ships.append(s);

                                NetJoinAnnounce join_ann;
                                join_ann.SetShip(s);
                                join_ann.SetName("Server A.I. Ship");
                                SendData(&join_ann);
                        }
                }
        }


        static DWORD time_mark = 0;

        if (!time_mark) time_mark = Game::RealTime();
        else if (Game::RealTime() - time_mark > 60000) {
                time_mark = Game::RealTime();

                if (link && players.size() > 0) {
                        Print("Server Stats\n-------------\n");
                        Print("  packets sent %d\n",          link->GetPacketsSent());
                        Print("  packets recv %d\n",          link->GetPacketsRecv());
                        Print("  bytes sent   %d\n",          link->GetBytesSent());
                        Print("  bytes recv   %d\n",          link->GetBytesRecv());
                        Print("  retries      %d\n",          link->GetRetries());
                        Print("  drops        %d\n",          link->GetDrops());
                        Print("  avg lag      %d msec\n",     link->GetLag());
                }
        }
}

void
NetGameServer::CheckSessions()
{
        if (!link)
        return;

        ListIter<NetPlayer> iter = players;
        while (++iter) {
                NetPlayer* player = iter.value();
                NetPeer*   peer   = link->FindPeer(player->GetNetID());

                if (peer && (NetLayer::GetUTC() - peer->LastReceiveTime()) > NET_DISCONNECT_TIME) {
                        // announce drop:
                        NetPlayer* zombie = iter.removeItem();
                        HUDView::Message(Game::GetText("NetGameServer.remote-discon").data(), zombie->Name());

                        // tell everyone else:
                        NetQuitAnnounce quit_ann;
                        quit_ann.SetObjID(zombie->GetObjID());
                        quit_ann.SetDisconnected(true);
                        SendData(&quit_ann);

                        // return remote ship to ship pool:
                        Ship* s = zombie->GetShip();
                        if (s) {
                                Observe(s);
                                ships.append(s);
                                s->SetNetworkControl(0);
                                zombie->SetShip(0);

                                NetJoinAnnounce join_ann;
                                join_ann.SetShip(s);
                                join_ann.SetName("Server A.I. Ship");
                                SendData(&join_ann);
                        }

                        zombies.append(zombie);
                }
        }
}

NetPlayer*
NetGameServer::FindZombieByObjID(DWORD objid)
{
        for (int i = 0; i < zombies.size(); i++) {
                NetPlayer* p = zombies[i];

                if (p->GetObjID() == objid)
                return p;
        }

        return 0;
}

// +--------------------------------------------------------------------+

void
NetGameServer::DoJoinRequest(NetMsg* msg)
{
        if (!msg) return;

        bool unpause = players.isEmpty();

        NetJoinRequest join_req;
        if (join_req.Unpack(msg->Data())) {
                HUDView::Message(Game::GetText("NetGameServer::join-request").data(), join_req.GetName(), join_req.GetElement(), join_req.GetIndex());

                DWORD nid       = msg->NetID();
                Text  name      = join_req.GetName();
                Text  serno     = join_req.GetSerialNumber();
                Text  elem_name = join_req.GetElement();
                int   index     = join_req.GetIndex();
                Ship* ship      = 0;
                Sim*  sim       = Sim::GetSim();

                if (sim) {
                        Element* element = sim->FindElement(elem_name);

                        if (element)
                        ship = element->GetShip(index);
                }

                if (!ship) {
                        Print("  JOIN DENIED: could not locate ship for remote player\n");
                        return;
                }

                if (!ship->GetObjID()) {
                        Print("  JOIN DENIED: remote player requested ship with objid = 0\n");
                        return;
                }

                NetLobbyServer* lobby = NetLobbyServer::GetInstance();

                if (lobby) {
                        NetUser* user = lobby->FindUserByName(name);

                        if (!user)
                        user = lobby->FindUserByNetID(nid);

                        if (!user) {
                                Print("  JOIN DENIED: remote player '%s' not found in lobby\n", name.data());
                                return;
                        }

                        else if (!user->IsAuthOK()) {
                                Print("  JOIN DENIED: remote player '%s' not authenticated\n", name.data());
                                return;
                        }
                }

                NetPlayer*  remote_player = FindPlayerByNetID(nid);
                if (remote_player && remote_player->GetShip() != ship) {
                        Print("  disconnecting remote player from ship '%s'\n", ship->Name());
                        players.remove(remote_player);
                        delete remote_player;
                        remote_player = 0;
                }

                if (!remote_player) {
                        Ignore(ship);
                        ships.remove(ship);

                        remote_player = new(__FILE__,__LINE__) NetPlayer(nid);
                        remote_player->SetName(name);
                        remote_player->SetSerialNumber(serno);
                        remote_player->SetObjID(ship->GetObjID());
                        remote_player->SetShip(ship);

                        HUDView::Message(Game::GetText("NetGameServer::join-announce").data());
                        Print("remote player name = %s\n", name.data());
                        Print("              obj  = %d\n", ship->GetObjID());
                        Print("              ship = %s\n", ship->Name());

                        remote_player->SetObjID(ship->GetObjID());

                        // tell the new player about the server:
                        if (local_player) {
                                NetJoinAnnounce join_ann;
                                join_ann.SetShip(local_player);
                                join_ann.SetName(player_name);
                                link->SendMessage(remote_player->GetNetID(), join_ann.Pack(), NetJoinAnnounce::SIZE, NetMsg::RELIABLE);
                        }

                        // tell the new player about the existing remote players:
                        ListIter<NetPlayer> iter = players;
                        while (++iter) {
                                Ship* s = iter->GetShip();

                                if (s) {
                                        NetJoinAnnounce join_ann;
                                        join_ann.SetShip(s);
                                        join_ann.SetName(iter->Name());
                                        join_ann.SetObjID(iter->GetObjID());
                                        link->SendMessage(remote_player->GetNetID(), join_ann.Pack(), NetJoinAnnounce::SIZE, NetMsg::RELIABLE);
                                }
                        }

                        // tell the new player about the A.I. controlled ships:
                        ListIter<Ship> ai_iter = ships;
                        while (++ai_iter) {
                                Ship* s = ai_iter.value();
                                if (s != local_player) {
                                        NetJoinAnnounce join_ann;
                                        join_ann.SetShip(s);
                                        join_ann.SetName("Server A.I. Ship");
                                        link->SendMessage(remote_player->GetNetID(), join_ann.Pack(), NetJoinAnnounce::SIZE, NetMsg::RELIABLE);
                                }
                        }

                        // make the new player an "existing" remote player:
                        players.append(remote_player);

                        // tell existing players about the new player:
                        // NOTE, this also provides the net id to the new player!
                        iter.reset();
                        while (++iter) {
                                Ship* s = remote_player->GetShip();

                                NetJoinAnnounce join_ann;
                                join_ann.SetShip(s);
                                join_ann.SetName(remote_player->Name());
                                join_ann.SetObjID(remote_player->GetObjID());
                                link->SendMessage(iter->GetNetID(), join_ann.Pack(), NetJoinAnnounce::SIZE, NetMsg::RELIABLE);
                        }

                        if (unpause) {
                                StarServer* s = StarServer::GetInstance();
                                if (s)
                                s->Pause(false);
                        }
                }
        }
}

void
NetGameServer::DoJoinAnnounce(NetMsg* msg)
{
        if (!msg) return;

        NetJoinAnnounce join_ann;
        if (join_ann.Unpack(msg->Data())) {
                Print("Server received Join Announce from '%s'\n", join_ann.GetName());
        }
}

void
NetGameServer::DoQuitRequest(NetMsg* msg)
{
        if (!msg) return;

        NetPlayer* player = FindPlayerByNetID(msg->NetID());

        if (player) {
                NetPlayer* zombie = players.remove(player);
                HUDView::Message(Game::GetText("NetGameServer.remote-quit").data(), zombie->Name());

                // tell everyone else:
                NetQuitAnnounce quit_ann;
                quit_ann.SetObjID(zombie->GetObjID());
                SendData(&quit_ann);

                // return remote ship to ship pool:
                Ship* s = zombie->GetShip();
                if (s) {
                        Observe(s);
                        ships.append(s);
                        s->SetNetworkControl(0);
                        zombie->SetShip(0);

                        NetJoinAnnounce join_ann;
                        join_ann.SetShip(s);
                        join_ann.SetName("Server A.I. Ship");
                        SendData(&join_ann);
                }

                zombies.append(zombie);
        }
        else {
                Print("Quit Request from unknown player NetID: %08X\n", msg->NetID());
        }
}

void
NetGameServer::DoQuitAnnounce(NetMsg* msg)
{
        if (!msg) return;
        Print("Server received Quit Announce from NetID: %08x\n", msg->NetID());
}

void
NetGameServer::DoGameOver(NetMsg* msg)
{
        if (!msg) return;
        Print("Server received Game Over from NetID: %08x\n", msg->NetID());
}

void
NetGameServer::DoDisconnect(NetMsg* msg)
{
        if (!msg) return;
        Print("Server received Disconnect from NetID: %08x\n", msg->NetID());
}

void
NetGameServer::DoObjLoc(NetMsg* msg)
{
        if (!msg) return;

        NetObjLoc obj_loc;
        obj_loc.Unpack(msg->Data());

        NetPlayer* player = FindPlayerByObjID(obj_loc.GetObjID());
        if (player && player->GetShip()) {
                player->DoObjLoc(&obj_loc);
        }

        else {
                player = FindZombieByObjID(obj_loc.GetObjID());

                if (player)
                SendDisconnect(player);
        }
}

void
NetGameServer::DoObjDamage(NetMsg* msg)
{
        if (!msg) return;
        Print("Server received OBJ DAMAGE from NetID: %08x (ignored)\n", msg->NetID());
}

void
NetGameServer::DoObjKill(NetMsg* msg)
{
        if (!msg) return;

        NetObjKill obj_kill;
        obj_kill.Unpack(msg->Data());

        if (obj_kill.GetKillType() != NetObjKill::KILL_DOCK) {
                Print("Server received OBJ KILL from NetID: %08x (ignored)\n", msg->NetID());
                return;
        }

        Ship* ship = FindShipByObjID(obj_kill.GetObjID());
        if (ship) {
                Ship* killer = FindShipByObjID(obj_kill.GetKillerID());
                Text  killer_name = Game::GetText("NetGameServer.unknown");

                if (killer)
                killer_name = killer->Name();

                ShipStats* killee = ShipStats::Find(ship->Name());
                if (killee)
                killee->AddEvent(SimEvent::DOCK, killer_name);

                FlightDeck* deck = killer->GetFlightDeck(obj_kill.GetFlightDeck());
                sim->NetDockShip(ship, killer, deck);
        }
}

void
NetGameServer::DoObjSpawn(NetMsg* msg)
{
        if (!msg) return;
        Print("Server received OBJ SPAWN from NetID: %08x (ignored)\n", msg->NetID());
}

void
NetGameServer::DoObjHyper(NetMsg* msg)
{
        if (!msg) return;
        Print("Server received OBJ HYPER from NetID: %d\n", msg->NetID());

        NetObjHyper obj_hyper;
        obj_hyper.Unpack(msg->Data());

        NetPlayer* player = FindPlayerByObjID(obj_hyper.GetObjID());
        if (player && player->GetShip()) {
                if (player->DoObjHyper(&obj_hyper)) {
                        SendData(&obj_hyper);
                }
        }
        else {
                player = FindZombieByObjID(obj_hyper.GetObjID());

                if (player)
                SendDisconnect(player);
        }
}

void
NetGameServer::DoObjTarget(NetMsg* msg)
{
        if (!msg) return;

        NetObjTarget obj_target;
        obj_target.Unpack(msg->Data());

        NetPlayer* player = FindPlayerByObjID(obj_target.GetObjID());
        if (player) {
                player->DoObjTarget(&obj_target);
        }
        else {
                player = FindZombieByObjID(obj_target.GetObjID());

                if (player)
                SendDisconnect(player);
        }
}

void
NetGameServer::DoObjEmcon(NetMsg* msg)
{
        if (!msg) return;

        NetObjEmcon obj_emcon;
        obj_emcon.Unpack(msg->Data());

        NetPlayer* player = FindPlayerByObjID(obj_emcon.GetObjID());
        if (player) {
                player->DoObjEmcon(&obj_emcon);
        }
        else {
                player = FindZombieByObjID(obj_emcon.GetObjID());

                if (player)
                SendDisconnect(player);
        }
}

// +--------------------------------------------------------------------+

void
NetGameServer::DoSysDamage(NetMsg* msg)
{
        if (!msg) return;

        NetSysDamage sys_damage;
        sys_damage.Unpack(msg->Data());

        NetPlayer* player = FindZombieByObjID(sys_damage.GetObjID());

        if (player)
        SendDisconnect(player);
}

void
NetGameServer::DoSysStatus(NetMsg* msg)
{
        if (!msg) return;

        NetSysStatus sys_status;
        sys_status.Unpack(msg->Data());

        Ship*       ship     = FindShipByObjID(sys_status.GetObjID());
        NetPlayer*  player   = FindPlayerByNetID(msg->NetID());

        if (ship) {
                if (!player || ship->GetObjID() != player->GetObjID()) {
                        return;
                }

                player->DoSysStatus(&sys_status);

                // rebroadcast:
                System* sys = ship->GetSystem(sys_status.GetSystem());
                NetUtil::SendSysStatus(ship, sys);
        }

        else {
                player = FindZombieByObjID(sys_status.GetObjID());

                if (player)
                SendDisconnect(player);
        }
}

// +--------------------------------------------------------------------+

void
NetGameServer::DoElemRequest(NetMsg* msg)
{
        if (!msg) return;

        NetElemRequest elem_request;
        elem_request.Unpack(msg->Data());

        Sim*     sim   = Sim::GetSim();
        Element* elem  = sim->FindElement(elem_request.GetName());

        if (elem) {
                int   squadron = -1;
                int   slots[]  = { -1,-1,-1,-1 };
                Ship* carrier  = elem->GetCarrier();

                if (carrier && carrier->GetHangar()) {
                        Hangar* hangar = carrier->GetHangar();

                        for (int i = 0; i < 4; i++) {
                                hangar->FindSquadronAndSlot(elem->GetShip(i+1), squadron, slots[i]);
                        }
                }

                NetUtil::SendElemCreate(elem, squadron, slots, false, true);
        }
}

// +--------------------------------------------------------------------+

void
NetGameServer::DoElemCreate(NetMsg* msg)
{
        if (!msg) return;

        NetElemCreate elem_create;
        elem_create.Unpack(msg->Data());

        Sim*     sim   = Sim::GetSim();
        Element* elem  = sim->CreateElement(elem_create.GetName(),
        elem_create.GetIFF(),
        elem_create.GetType());

        int*     load     = elem_create.GetLoadout();
        int*     slots    = elem_create.GetSlots();
        int      squadron = elem_create.GetSquadron();
        int      code     = elem_create.GetObjCode();
        Text     target   = elem_create.GetObjective();
        bool     alert    = elem_create.GetAlert();

        elem->SetIntelLevel(elem_create.GetIntel());
        elem->SetLoadout(load);

        if (code > Instruction::RTB || target.length() > 0) {
                Instruction* obj  = new(__FILE__,__LINE__) Instruction(code, target);
                elem->AddObjective(obj);
        }

        Ship* carrier = sim->FindShip(elem_create.GetCarrier());
        if (carrier) {
                elem->SetCarrier(carrier);

                Hangar* hangar = carrier->GetHangar();
                if (hangar) {
                        Text squadron_name = hangar->SquadronName(squadron);
                        elem->SetSquadron(squadron_name);

                        FlightDeck* deck   = 0;
                        int         queue  = 1000;

                        for (int i = 0; i < carrier->NumFlightDecks(); i++) {
                                FlightDeck* d = carrier->GetFlightDeck(i);

                                if (d && d->IsLaunchDeck()) {
                                        int dq = hangar->PreflightQueue(d);

                                        if (dq < queue) {
                                                queue = dq;
                                                deck  = d;
                                        }
                                }
                        }

                        for (int i = 0; i < 4; i++) {
                                int slot = slots[i];
                                if (slot > -1) {
                                        hangar->GotoAlert(squadron, slot, deck, elem, load, !alert);
                                }
                        }
                }
        }

        NetUtil::SendElemCreate(elem,
        elem_create.GetSquadron(),
        elem_create.GetSlots(),
        elem_create.GetAlert());
}

void
NetGameServer::DoShipLaunch(NetMsg* msg)
{
        if (!msg) return;

        NetShipLaunch ship_launch;
        ship_launch.Unpack(msg->Data());

        Sim*  sim      = Sim::GetSim();
        int   squadron = ship_launch.GetSquadron();
        int   slot     = ship_launch.GetSlot();

        NetPlayer* player = FindPlayerByObjID(ship_launch.GetObjID());
        if (player) {
                Ship* carrier = player->GetShip();

                if (carrier) {
                        Hangar* hangar = carrier->GetHangar();

                        if (hangar) {
                                hangar->Launch(squadron, slot);
                        }

                        NetUtil::SendShipLaunch(carrier, squadron, slot);
                }
        }
}

void
NetGameServer::DoNavData(NetMsg* msg)
{
        if (!msg) return;

        NetNavData nav_data;
        nav_data.Unpack(msg->Data());

        Element* elem = sim->FindElement(nav_data.GetElem());

        if (elem) {
                if (nav_data.IsAdd()) {
                        Instruction* navpt = new(__FILE__,__LINE__) Instruction(*nav_data.GetNavPoint());
                        Instruction* after = 0;
                        int          index = nav_data.GetIndex();

                        if (index >= 0 && index < elem->GetFlightPlan().size())
                        after = elem->GetFlightPlan().at(index);

                        elem->AddNavPoint(navpt, after, false);
                }

                else {
                        Instruction* navpt = nav_data.GetNavPoint();
                        Instruction* exist = 0;
                        int          index = nav_data.GetIndex();

                        if (navpt && index >= 0 && index < elem->GetFlightPlan().size()) {
                                exist = elem->GetFlightPlan().at(index);
                                *exist = *navpt;
                        }
                }

                SendData(&nav_data);
        }
}

void
NetGameServer::DoNavDelete(NetMsg* msg)
{
        if (!msg) return;

        NetNavDelete nav_delete;
        nav_delete.Unpack(msg->Data());

        Element* elem = sim->FindElement(nav_delete.GetElem());

        if (elem) {
                int index = nav_delete.GetIndex();

                if (index < 0) {
                        elem->ClearFlightPlan(false);
                }

                else if (index < elem->FlightPlanLength()) {
                        Instruction* npt = elem->GetFlightPlan().at(index);
                        elem->DelNavPoint(npt, false);
                }

                SendData(&nav_delete);
        }
}

void
NetGameServer::DoWepTrigger(NetMsg* msg)
{
        if (!msg) return;

        NetWepTrigger trigger;
        trigger.Unpack(msg->Data());

        NetPlayer* player = FindPlayerByObjID(trigger.GetObjID());
        if (player) {
                player->DoWepTrigger(&trigger);
        }
        else {
                player = FindZombieByObjID(trigger.GetObjID());

                if (player)
                SendDisconnect(player);
        }
}

void
NetGameServer::DoWepRelease(NetMsg* msg)
{
        if (!msg) return;

        NetWepRelease release;
        release.Unpack(msg->Data());

        NetPlayer* player = FindPlayerByObjID(release.GetObjID());
        if (player) {
                player->DoWepRelease(&release);
        }
        else {
                player = FindZombieByObjID(release.GetObjID());

                if (player)
                SendDisconnect(player);
        }

        Print("WEP RELEASE on server? objid = %d\n", release.GetObjID());
}

void
NetGameServer::DoWepDestroy(NetMsg* msg)
{
}

void
NetGameServer::DoCommMsg(NetMsg* msg)
{
        if (!msg) return;

        NetCommMsg comm_msg;
        comm_msg.Unpack(msg->Data());

        RadioMessage* radio_msg = comm_msg.GetRadioMessage();

        NetPlayer* player = FindPlayerByObjID(comm_msg.GetObjID());
        if (player && radio_msg) {
                player->DoCommMessage(&comm_msg);

                int channel = comm_msg.GetRadioMessage()->Channel();

                ListIter<NetPlayer> dst = players;
                while (++dst) {
                        NetPlayer* remote_player = dst.value();
                        if (remote_player->GetNetID() &&
                                        (channel == 0 || channel == remote_player->GetIFF())) {

                                BYTE* data  = comm_msg.Pack();
                                int   size  = comm_msg.Length();

                                link->SendMessage(remote_player->GetNetID(), data, size, NetMsg::RELIABLE);
                        }
                }
        }
        else {
                player = FindZombieByObjID(comm_msg.GetObjID());

                if (player)
                SendDisconnect(player);
        }
}

void
NetGameServer::DoChatMsg(NetMsg* msg)
{
        if (!msg) return;

        NetChatMsg chat_msg;
        chat_msg.Unpack(msg->Data());

        RouteChatMsg(chat_msg);
}

void
NetGameServer::RouteChatMsg(NetChatMsg& chat_msg)
{
        DWORD dst_id = chat_msg.GetDstID();

        // broadcast or team:
        if (dst_id == 0xffff || dst_id <= 10) {
                BYTE* data  = chat_msg.Pack();
                int   size  = chat_msg.Length();

                ListIter<NetPlayer> dst = players;
                while (++dst) {
                        NetPlayer* remote_player = dst.value();
                        if (remote_player->GetNetID() && chat_msg.GetName() != remote_player->Name()) {
                                if (dst_id == 0xffff || dst_id == 0 || remote_player->GetIFF() == (int) dst_id-1)
                                link->SendMessage(remote_player->GetNetID(), data, size);
                        }
                }

                if (local_player && (dst_id == 0xffff || dst_id == 0 || local_player->GetIFF() == (int) dst_id-1)) {
                        Text name = chat_msg.GetName();
                        if (name.length() < 1)
                        name = Game::GetText("NetGameServer.chat.unknown");

                        // don't echo general messages from the local player.
                        // they are already displayed by the chat entry code
                        // in starshatter.cpp

                        if (name != player_name)
                        HUDView::Message("%s> %s", name.data(), chat_msg.GetText().data());
                }
        }

        // direct to local player:
        else if (local_player && local_player->GetObjID() == dst_id) {
                Text name = chat_msg.GetName();
                if (name.length() < 1)
                name = Game::GetText("NetGameServer.chat.unknown");

                HUDView::Message("%s> %s", name.data(), chat_msg.GetText().data());
        }

        // ship-to-ship, but not to local player:
        else if (!local_player || local_player->GetObjID() != dst_id) {
                NetPlayer* remote_player = FindPlayerByObjID(dst_id);
                if (remote_player && remote_player->GetNetID()) {
                        BYTE* data  = chat_msg.Pack();
                        int   size  = chat_msg.Length();
                        link->SendMessage(remote_player->GetNetID(), data, size);
                }

                // record message in server log:
                ::Print("%s> %s\n", chat_msg.GetName().data(), chat_msg.GetText().data());
        }

        if (dst_id == 0xffff)
        return;

        // record message in chat log:
        NetLobbyServer*   lobby  = NetLobbyServer::GetInstance();

        if (!lobby)
        return;

        NetUser* user = lobby->FindUserByName(chat_msg.GetName());

        if (user)
        lobby->AddChat(user, chat_msg.GetText(), false);   // don't re-route
}

// +--------------------------------------------------------------------+

const char* FormatGameTime();

void
NetGameServer::DoSelfDestruct(NetMsg* msg)
{
        if (!msg) return;

        NetSelfDestruct self_destruct;
        self_destruct.Unpack(msg->Data());

        Ship*       ship     = FindShipByObjID(self_destruct.GetObjID());
        NetPlayer*  player   = FindPlayerByNetID(msg->NetID());

        if (ship) {
                if (!player || ship->GetObjID() != player->GetObjID()) {
                        Print("NetGameServer::DoSelfDestruct - received request for ship '%s' from wrong player %s\n",
                        ship->Name(), player ? player->Name() : "null");

                        return;
                }

                ship->InflictNetDamage(self_destruct.GetDamage());

                SendData(&self_destruct);

                int ship_destroyed = (!ship->InTransition() && ship->Integrity() < 1.0f);

                // then delete the ship:
                if (ship_destroyed) {
                        NetUtil::SendObjKill(ship, 0, NetObjKill::KILL_MISC);
                        Print("    %s Self Destruct (%s)\n", ship->Name(), FormatGameTime());

                        ShipStats* killee = ShipStats::Find(ship->Name());
                        if (killee)
                        killee->AddEvent(SimEvent::DESTROYED, ship->Name());

                        ship->DeathSpiral();
                }
        }
}

// +--------------------------------------------------------------------+

void
NetGameServer::Send()
{
        if (players.isEmpty())
        return;

        DWORD time = Game::GameTime();

        // don't flood the network...
        if (time - last_send_time < MIN_NET_FRAME)
        return;

        last_send_time = time;

        // tell the remote players where *we* are:
        if (local_player && !local_player->IsNetObserver() && objid) {
                double r, p, y;
                local_player->Cam().Orientation().ComputeEulerAngles(r,p,y);

                NetObjLoc obj_loc;
                obj_loc.SetObjID(objid);
                obj_loc.SetLocation(local_player->Location());
                obj_loc.SetVelocity(local_player->Velocity());
                obj_loc.SetOrientation(Point(r,p,y));
                obj_loc.SetThrottle(local_player->Throttle() > 10);
                obj_loc.SetAugmenter(local_player->Augmenter());
                obj_loc.SetGearDown(local_player->IsGearDown());

                Shield* shield = local_player->GetShield();
                if (shield)
                obj_loc.SetShield((int) shield->GetPowerLevel());
                else
                obj_loc.SetShield(0);

                SendData(&obj_loc);
        }

        // tell each remote player where all the others are:
        ListIter<NetPlayer> src = players;
        while (++src) {
                NetPlayer* player = src.value();

                Ship* player_ship = player->GetShip();

                if (player_ship) {
                        double r, p, y;
                        player_ship->Cam().Orientation().ComputeEulerAngles(r,p,y);

                        NetObjLoc obj_loc;
                        obj_loc.SetObjID(player->GetObjID());
                        obj_loc.SetLocation(player_ship->Location());
                        obj_loc.SetVelocity(player_ship->Velocity());
                        obj_loc.SetOrientation(Point(r,p,y));
                        obj_loc.SetThrottle(player_ship->Throttle() > 10);
                        obj_loc.SetAugmenter(player_ship->Augmenter());
                        obj_loc.SetGearDown(player_ship->IsGearDown());

                        Shield* shield = player_ship->GetShield();
                        if (shield)
                        obj_loc.SetShield((int) shield->GetPowerLevel());
                        else
                        obj_loc.SetShield(0);

                        BYTE* obj_loc_data = obj_loc.Pack();

                        ListIter<NetPlayer> dst = players;
                        while (++dst) {
                                NetPlayer* remote_player = dst.value();
                                if (remote_player->GetNetID() && remote_player != player)
                                link->SendMessage(remote_player->GetNetID(), obj_loc_data, NetObjLoc::SIZE);
                        }
                }
        }

        // tell each remote player where all the A.I. ships are:
        ListIter<Ship> ai_iter = ships;
        while (++ai_iter) {
                Ship* s = ai_iter.value();

                if (s && !s->IsStatic()) {
                        double r, p, y;
                        s->Cam().Orientation().ComputeEulerAngles(r,p,y);

                        NetObjLoc obj_loc;
                        obj_loc.SetObjID(s->GetObjID());
                        obj_loc.SetLocation(s->Location());
                        obj_loc.SetVelocity(s->Velocity());
                        obj_loc.SetOrientation(Point(r,p,y));
                        obj_loc.SetThrottle(s->Throttle() > 10);
                        obj_loc.SetAugmenter(s->Augmenter());
                        obj_loc.SetGearDown(s->IsGearDown());

                        Shield* shield = s->GetShield();
                        if (shield)
                        obj_loc.SetShield((int) shield->GetPowerLevel());
                        else
                        obj_loc.SetShield(0);

                        SendData(&obj_loc);
                }
        }
}

// +--------------------------------------------------------------------+

void
NetGameServer::SendData(NetData* net_data)
{
        if (net_data) {
                BYTE* data  = net_data->Pack();
                int   size  = net_data->Length();
                BYTE  flags = 0;
                bool  all   = true;  // include player with objid in net_data?
                DWORD oid   = net_data->GetObjID();

                BYTE  msg_type = net_data->Type();

                if (msg_type >= 0x10)
                flags |= NetMsg::RELIABLE;

                if (msg_type == NET_WEP_TRIGGER   ||
                                msg_type == NET_COMM_MESSAGE  ||
                                msg_type == NET_CHAT_MESSAGE  ||
                                msg_type == NET_OBJ_HYPER     ||
                                msg_type == NET_ELEM_CREATE   ||
                                msg_type == NET_NAV_DATA      ||
                                msg_type == NET_NAV_DELETE) {
                        all = false;
                }

                ListIter<NetPlayer> dst = players;
                while (++dst) {
                        NetPlayer* remote_player = dst.value();
                        if (remote_player->GetNetID() && (all || oid != remote_player->GetObjID()))
                        link->SendMessage(remote_player->GetNetID(), data, size, flags);
                }
        }
}

void
NetGameServer::SendDisconnect(NetPlayer* zombie)
{
        if (zombie) {
                NetDisconnect  disconnect;
                BYTE*          data  = disconnect.Pack();
                int            size  = disconnect.Length();
                BYTE           flags = NetMsg::RELIABLE;

                if (zombie->GetNetID())
                link->SendMessage(zombie->GetNetID(), data, size, flags);
        }
}

// +--------------------------------------------------------------------+

bool
NetGameServer::Update(SimObject* obj)
{
        if (obj->Type() == SimObject::SIM_SHIP) {
                Ship* s = (Ship*) obj;
                if (local_player == s)
                local_player = 0;

                if (ships.contains(s))
                ships.remove(s);
        }

        return SimObserver::Update(obj);
}

const char*
NetGameServer::GetObserverName() const
{
        return "NetGameServer";
}

// +--------------------------------------------------------------------+

void
NetGameServer::Respawn(DWORD oid, Ship* spawn)
{
        if (!oid || !spawn) return;

        Print("NetGameServer::Respawn(%d, %s)\n", oid, spawn->Name());
        spawn->SetObjID(oid);
        Observe(spawn);

        NetPlayer* p = FindPlayerByObjID(oid);
        if (p)
        p->SetShip(spawn);
        else
        ships.append(spawn);

        if (objid == oid) {
                Print("  RESPAWN LOCAL PLAYER\n\n");
                local_player = spawn;
        }
}