path: root/Stars45/StarServer.cpp

/*  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

*/

#include "MemDebug.h"

#include "StarServer.h"
#include "Campaign.h"
#include "CombatRoster.h"
#include "Galaxy.h"
#include "Mission.h"
#include "Sim.h"
#include "SimEvent.h"
#include "Ship.h"
#include "Contact.h"
#include "QuantumDrive.h"
#include "Power.h"
#include "SystemDesign.h"
#include "WeaponDesign.h"
#include "Shot.h"
#include "Drive.h"
#include "Explosion.h"
#include "FlightDeck.h"
#include "RadioMessage.h"
#include "RadioTraffic.h"
#include "Random.h"
#include "ModConfig.h"

#include "NetLayer.h"
#include "NetGame.h"
#include "NetHost.h"
#include "NetServer.h"
#include "HttpServer.h"
#include "HttpServletExec.h"
#include "NetAdminServer.h"
#include "NetLobbyServer.h"
#include "NetServerConfig.h"

#include "Token.h"
#include "MachineInfo.h"
#include "Game.h"
#include "ContentBundle.h"
#include "Keyboard.h"
#include "Mouse.h"
#include "EventDispatch.h"
#include "MultiController.h"
#include "DataLoader.h"
#include "ParseUtil.h"
#include "VersionInfo.h"

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

StarServer*       StarServer::instance = 0;

static Mission*   current_mission      = 0;
static double     time_til_change      = 0;
static bool       exit_latch           = true;

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

StarServer::StarServer()
: loader(0), time_mark(0), minutes(0), game_mode(MENU_MODE),
admin_server(0), lobby_server(0)
{
    if (!instance)
    instance = this;

    app_name     = "Starserver 5.0";
    title_text   = "Starserver";
    palette_name = "alpha";

    server      = true;
    show_mouse  = true;

    DataLoader::Initialize();
    loader       = DataLoader::GetLoader();
    int loadstat = loader->EnableDatafile("shatter.dat");

    if (loadstat != DataLoader::DATAFILE_OK) {
        const char* err_msg = loadstat == DataLoader::DATAFILE_INVALID ?
        "The file 'shatter.dat' appears to have been damaged.  Please re-install Starshatter." :
        "Starshatter cannot open the file 'shatter.dat'.  Please re-install Starshatter.";

        ::MessageBox(hwnd, err_msg, "Starshatter - Error", MB_OK);
        ::Print(err_msg);
        ::Print("\n\nFATAL ERROR: EXIT.");
        exit(-1);
    }

    if (loader->FindFile("start.dat"))
    loader->EnableDatafile("start.dat");

    // no images or sounds in server mode:
    loader->EnableMedia(false);
}

StarServer::~StarServer()
{
    delete admin_server;
    delete lobby_server;

    admin_server = 0;
    lobby_server = 0;

    // delete all the ships and stuff
    // BEFORE getting rid of the system
    // and weapons catalogs!
    delete world;
    world = 0; // don't let base class double delete the world

    Drive::Close();
    Explosion::Close();
    FlightDeck::Close();
    Campaign::Close();
    CombatRoster::Close();
    Galaxy::Close();
    RadioTraffic::Close();
    Ship::Close();
    WeaponDesign::Close();
    SystemDesign::Close();
    DataLoader::Close();
    NetServerConfig::Close();
    ModConfig::Close();

    instance = 0;

    server = false;
}

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

bool
StarServer::Init(HINSTANCE hi, HINSTANCE hpi, LPSTR cmdline, int nCmdShow)
{
    if (loader)
    loader->UseFileSystem(false);

    return Game::Init(hi, hpi, cmdline, nCmdShow);
}

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

bool
StarServer::InitGame()
{
    if (!Game::InitGame())
    return false;

    RandomInit();
    ModConfig::Initialize();
    NetServerConfig::Initialize();
    SystemDesign::Initialize("sys.def");
    WeaponDesign::Initialize("wep.def");
    Ship::Initialize();
    Galaxy::Initialize();
    CombatRoster::Initialize();
    Campaign::Initialize();

    Drive::Initialize();
    Explosion::Initialize();
    FlightDeck::Initialize();
    Ship::Initialize();
    Shot::Initialize();
    RadioTraffic::Initialize();

    time_mark = Game::GetInstance()->GetClock()->GameTime();
    minutes   = 0;

    NetServerConfig* server_config = NetServerConfig::GetInstance();
    if (!server_config)
    return false;

    ::Print("\n\n\nStarshatter Server Init\n");
    ::Print("-----------------------\n");
    ::Print("Server Name:       %s\n", (const char*) server_config->Name());
    ::Print("Server Type:       %d\n", server_config->GetGameType());

    if (server_config->GetMission().length() > 0)
    ::Print("Server Mission:    %s\n", (const char*) server_config->GetMission());

    ::Print("Lobby Server Port: %d\n", server_config->GetLobbyPort());
    ::Print("Admin Server Port: %d\n", server_config->GetAdminPort());
    ::Print("-----------------------\n");

    NetLobbyServer* nls = new(__FILE__,__LINE__) NetLobbyServer;
    NetAdminServer* nas = NetAdminServer::GetInstance(server_config->GetAdminPort());
    nas->SetServerName(server_config->Name());

    lobby_server = nls;
    admin_server = nas;

    return true;
}

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

void
StarServer::SetGameMode(int m)
{
    if (game_mode == m)
    return;

    if (m == LOAD_MODE) {
        Print("  game_mode = LOAD_MODE\n");
        paused = true;
    }

    else if (m == PLAY_MODE) {
        Print("  game_mode = PLAY_MODE\n");

        if (!world) {
            CreateWorld();
            InstantiateMission();
        }

        // stand alone server should wait for players to connect
        // before unpausing the simulation...
        clock.SetTimeCompression(1.0);
        Pause(true);
    }

    else if (m == MENU_MODE) {
        Print("  game_mode = MENU_MODE\n");
        paused = true;

        Sim* sim = (Sim*) world;

        if (sim)
        sim->UnloadMission();
    }

    game_mode = m;
}

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

void
StarServer::SetNextMission(const char* script)
{
    if (lobby_server)
    lobby_server->SetServerMission(script);
}

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

void
StarServer::CreateWorld()
{
    RadioTraffic::Initialize();

    // create world
    if (!world) {
        Sim* sim = new(__FILE__,__LINE__) Sim(0);
        world = sim;
        Print("  World Created.\n");
    }
}

void
StarServer::InstantiateMission()
{
    Memory::Check();

    current_mission = 0;

    if (Campaign::GetCampaign()) {
        current_mission = Campaign::GetCampaign()->GetMission();
    }

    Sim* sim = (Sim*) world;

    if (sim) {
        sim->UnloadMission();

        if (current_mission) {
            sim->LoadMission(current_mission);
            sim->ExecMission();
            sim->SetTestMode(false);

            Print("  Mission Instantiated.\n");
        }

        else {
            Print("  *** WARNING: StarServer::InstantiateMission() - no mission selected ***\n");
        }
    }

    Memory::Check();
}

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

bool
StarServer::GameLoop()
{
    if (active && paused) {
        UpdateWorld();
        GameState();
    }

    else if (!active) {
        UpdateWorld();
        GameState();
        Sleep(10);
    }

    Game::GameLoop();
    return false;  // must return false to keep processing
    // true tells the outer loop to sleep until a
    // windows event is available
}

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

void
StarServer::UpdateWorld()
{
    Galaxy* galaxy = Galaxy::GetInstance();
    if (galaxy) galaxy->ExecFrame();

    Campaign* campaign = Campaign::GetCampaign();
    if (campaign) campaign->ExecFrame();

    if (paused) {
        if (world)
        world->ExecFrame(0);
    }

    else {
        Drive::StartFrame();

        if (world)
        world->ExecFrame(clock.Delta());
    }

    static DWORD refresh_time = 0;
    if (clock.RealTime() - refresh_time > 1000) {
        refresh_time = clock.RealTime();
        RedrawWindow(hwnd, 0, 0, RDW_ERASE|RDW_INVALIDATE);
    }
}

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

void
StarServer::GameState()
{
    if (lobby_server) {
        lobby_server->ExecFrame();

        if (lobby_server->GetStatus() == NetServerInfo::PERSISTENT)
        paused = NetGame::NumPlayers() < 1;
    }

    if (game_mode == MENU_MODE) {
        Sleep(30);
    }

    else if (game_mode == LOAD_MODE) {
        CreateWorld();
        InstantiateMission();

        SetGameMode(PLAY_MODE);
    }

    else if (game_mode == PLAY_MODE) {
        if (Game::GetInstance()->GetClock()->GameTime() - time_mark > 60000) {
            time_mark = Game::GetInstance()->GetClock()->GameTime();
            minutes++;
            if (minutes > 60)
            Print("  TIME %2d:%02d:00\n", minutes/60, minutes%60);
            else
            Print("  TIME    %2d:00\n", minutes);
        }

        Sleep(10);
    }

    Memory::Check();
}

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

bool
StarServer::OnPaint()
{
    PAINTSTRUCT paintstruct;
    HDC hdc = BeginPaint(hwnd, &paintstruct);

    Text txt_title = title_text;
    Text txt_mode;
    Text txt_users = ContentBundle::GetInstance()->GetText("server.no-users");
    char buf[256];

    txt_title += " ";
    txt_title += versionInfo;

    switch (game_mode) {
    case LOAD_MODE:
    case MENU_MODE:
        txt_mode = ContentBundle::GetInstance()->GetText("server.mode.lobby");

        if (lobby_server) {
            sprintf_s(buf, ContentBundle::GetInstance()->GetText("server.users").data(), lobby_server->NumUsers());
            txt_users = buf;
        }
        break;

    case PLAY_MODE:
        txt_mode = ContentBundle::GetInstance()->GetText("server.mode.active");
        if (lobby_server) {
            sprintf_s(buf, ContentBundle::GetInstance()->GetText("server.users-and-players").data(), lobby_server->NumUsers(), NetGame::NumPlayers());
        }
        else {
            sprintf_s(buf, ContentBundle::GetInstance()->GetText("server.players").data(), NetGame::NumPlayers());
        }
        txt_users = buf;
        break;

    default:
        txt_mode = ContentBundle::GetInstance()->GetText("server.mode.other");
        break;
    }

    if (lobby_server && lobby_server->GetStatus() == NetServerInfo::PERSISTENT)
    txt_mode += " " + ContentBundle::GetInstance()->GetText("server.alt.persistent");

    if (paused)
    txt_mode += " " + ContentBundle::GetInstance()->GetText("server.alt.paused");

    TextOut(hdc, 4,  4, txt_title, txt_title.length());
    TextOut(hdc, 4, 22, txt_mode,  txt_mode.length());
    TextOut(hdc, 4, 40, txt_users, txt_users.length());

    Sim* sim = Sim::GetSim();
    if (sim && sim->GetMission()) {
        Mission* mission = sim->GetMission();
        Text txt_msn = ContentBundle::GetInstance()->GetText("server.mission");
        txt_msn += mission->Name();
        TextOut(hdc, 4, 58, txt_msn, txt_msn.length());
    }

    EndPaint(hwnd, &paintstruct);
    return true;
}

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

DWORD WINAPI StarServerShutdownProc(LPVOID link)
{
    StarServer* stars = (StarServer*) link;

    Sleep(3000);

    if (stars) {
        stars->Exit();
        return 0;
    }

    return (DWORD) E_POINTER;
}

DWORD WINAPI StarServerRestartProc(LPVOID link)
{
    StarServer* stars = (StarServer*) link;

    Sleep(3000);

    if (stars) {
        char cmdline[256];
        strcpy_s(cmdline, "stars -server");

        STARTUPINFO s;
        ZeroMemory(&s, sizeof(s));
        s.cb = sizeof(s);

        PROCESS_INFORMATION pi;
        ZeroMemory(&pi, sizeof(pi));

        CreateProcess("stars.exe", cmdline, 0, 0, 0, 0, 0, 0, &s, &pi);
        stars->Exit();
        CloseHandle( pi.hProcess );
        CloseHandle( pi.hThread );
        return 0;
    }

    return (DWORD) E_POINTER;
}

void
StarServer::Shutdown(bool restart)
{
    DWORD thread_id = 0;

    if (restart)
    CreateThread(0, 4096, StarServerRestartProc,  (LPVOID) this, 0, &thread_id);
    else
    CreateThread(0, 4096, StarServerShutdownProc, (LPVOID) this, 0, &thread_id);
}