/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// host.c -- coordinates spawning and killing of local servers

#include "quakedef.h"
#include "r_local.h"

/*

A server can allways be started, even if the system started out as a client
to a remote system.

A client can NOT be started if the system started as a dedicated server.

Memory is cleared / released when a server or client begins, not when they end.

*/

// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  start
double	host_cpu_frametime;
double	host_org_frametime;

cvar_t	host_timescale = {"host_timescale", "1"};
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  end

quakeparms_t host_parms;

qboolean	host_initialized;		// true if into command execution

double		host_frametime;
double		host_time;
double		realtime;				// without any filtering or bounding
double		oldrealtime;			// last frame run
int			host_framecount;

int			host_hunklevel;

int			minimum_memory;

int			fps_count;	// 2001-11-31 FPS display by QuakeForge/Muff

client_t	*host_client;			// current client

jmp_buf 	host_abortserver;

byte		*host_basepal;
byte		*host_colormap;

cvar_t	r_skyalpha = {"r_skyalpha","0"}; //0.6 translucent sky

cvar_t	host_framerate = {"host_framerate","0"};	// set for slow motion
cvar_t	host_speeds = {"host_speeds","0"};			// set for running times

cvar_t	sys_ticrate = {"sys_ticrate","0.05"};
cvar_t	serverprofile = {"serverprofile","0"};

cvar_t	fraglimit = {"fraglimit","0",false,true};
cvar_t	timelimit = {"timelimit","0",false,true};
cvar_t	teamplay = {"teamplay","0",false,true};

cvar_t	samelevel = {"samelevel","0"};
cvar_t	noexit = {"noexit","0",false,true};

#ifdef QUAKE2
cvar_t	developer = {"developer","1"};	// should be 0 for release!
#else
cvar_t	developer = {"developer","0"};
#endif

cvar_t	skill = {"skill","1"};						// 0 - 3
cvar_t	deathmatch = {"deathmatch","0"};			// 0, 1, or 2
cvar_t	coop = {"coop","0"};			// 0 or 1

cvar_t	pausable = {"pausable","1"};

cvar_t	temp1 = {"temp1","0"};


/*
================
Host_EndGame
================
*/
void Host_EndGame(char *message, ...)
{
    va_list		argptr;
    char		string[1024];

    va_start(argptr,message);
    vsprintf(string,message,argptr);
    va_end(argptr);
    Con_DPrintf("Host_EndGame: %s\n",string);

    if (sv.active) {
        Host_ShutdownServer(false);
    }

    if (cls.state == ca_dedicated) {
        Sys_Error("Host_EndGame: %s\n",string);    // dedicated servers exit
    }

    if (cls.demonum != -1) {
        CL_NextDemo();
    } else {
        CL_Disconnect();
    }

    longjmp(host_abortserver, 1);
}

/*
================
Host_Error

This shuts down both the client and server
================
*/
void Host_Error(char *error, ...)
{
    va_list		argptr;
    char		string[1024];
    static	qboolean inerror = false;

    if (inerror) {
        Sys_Error("Host_Error: recursively entered");
    }
    inerror = true;

    SCR_EndLoadingPlaque();		// reenable screen updates

    va_start(argptr,error);
    vsprintf(string,error,argptr);
    va_end(argptr);
    Con_Printf("Host_Error: %s\n",string);

    if (sv.active) {
        Host_ShutdownServer(false);
    }

    if (cls.state == ca_dedicated) {
        Sys_Error("Host_Error: %s\n",string);    // dedicated servers exit
    }

    CL_Disconnect();
    cls.demonum = -1;

    inerror = false;

    longjmp(host_abortserver, 1);
}

/*
================
Host_FindMaxClients
================
*/
void	Host_FindMaxClients(void)
{
    int		i;

    svs.maxclients = 1;

    i = COM_CheckParm("-dedicated");
    if (i) {
        cls.state = ca_dedicated;
        if (i != (com_argc - 1)) {
            svs.maxclients = Q_atoi(com_argv[i+1]);
        } else {
            svs.maxclients = 8;
        }
    } else {
        cls.state = ca_disconnected;
    }

    i = COM_CheckParm("-listen");
    if (i) {
        if (cls.state == ca_dedicated) {
            Sys_Error("Only one of -dedicated or -listen can be specified");
        }
        if (i != (com_argc - 1)) {
            svs.maxclients = Q_atoi(com_argv[i+1]);
        } else {
            svs.maxclients = 8;
        }
    }
    if (svs.maxclients < 1) {
        svs.maxclients = 8;
    } else if (svs.maxclients > MAX_SCOREBOARD) {
        svs.maxclients = MAX_SCOREBOARD;
    }

    svs.maxclientslimit = svs.maxclients;
    if (svs.maxclientslimit < 4) {
        svs.maxclientslimit = 16;    // edited
    }
    svs.clients = Hunk_AllocName(svs.maxclientslimit*sizeof(client_t), "clients");

    if (svs.maxclients > 1) {
        Cvar_SetValue("deathmatch", 1.0);
    } else {
        Cvar_SetValue("deathmatch", 0.0);
    }
}

// Deathmatch/Coop not at the same time - begin
void Host_CheckDeathmatchValue(void)
{
    if (deathmatch.value && coop.value) {
        Cvar_SetValue("coop", 0);
    }
}
void Host_CheckCoopValue(void)
{
    if (deathmatch.value && coop.value) {
        Cvar_SetValue("deathmatch", 0);
    }
}
// Deathmatch/Coop not at the same time - end
// TIMESCALE extension - begin
void Host_CheckTimescaleValue(void)
{
    if (host_timescale.value < 0.0) {
        Cvar_SetValue("host_timescale", 0.0);
    } else if (host_timescale.value > 10.0) {
        Cvar_SetValue("host_timescale", 10.0);
    }
}
// TIMESCALE extension - end
/*
=======================
Host_InitLocal
======================
*/
void Host_InitLocal(void)
{
    Host_InitCommands();

// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  start
    Cvar_RegisterVariableWithCallback(&host_timescale, Host_CheckTimescaleValue);  // Edited
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  end
    Cvar_RegisterVariable(&r_skyalpha);  // translucent sky

    Cvar_RegisterVariable(&host_framerate);
    Cvar_RegisterVariable(&host_speeds);

    Cvar_RegisterVariable(&sys_ticrate);
    Cvar_RegisterVariable(&serverprofile);

    Cvar_RegisterVariable(&fraglimit);
    Cvar_RegisterVariable(&timelimit);
    Cvar_RegisterVariable(&teamplay);
    Cvar_RegisterVariable(&samelevel);
    Cvar_RegisterVariable(&noexit);
    Cvar_RegisterVariable(&skill);
    Cvar_RegisterVariable(&developer);
    Cvar_RegisterVariableWithCallback(&deathmatch, Host_CheckDeathmatchValue);  // Deathmatch/Coop not at the same time - edited
    Cvar_RegisterVariableWithCallback(&coop, Host_CheckCoopValue);  // Deathmatch/Coop not at the same time - edited

    Cvar_RegisterVariable(&pausable);

    Cvar_RegisterVariable(&temp1);

    Host_FindMaxClients();

    host_time = 1.0;		// so a think at time 0 won't get called
}


/*
===============
Host_WriteConfiguration

Writes key bindings and archived cvars to config.cfg
===============
*/
void Host_WriteConfiguration(void)
{
    FILE	*f;

// dedicated servers initialize the host but don't parse and set the
// config.cfg cvars
    if (host_initialized && !isDedicated) { // fixed
#ifndef _arch_dreamcast // VMU saves
        //	f = fopen (va("%s/config.cfg",com_gamedir), "wb"); // reduced config file - edited

#ifdef FLASH
        f = as3OpenWriteFile(va("%s/makaqu.cfg",com_gamedir));
#else
        f = fopen(va("%s/makaqu.cfg",com_gamedir), "wb");  // config.cfg replacement - edited
#endif


// VMU saves - begin
#else
        f = fopen("/ram/nxmakaqu.cfg", "wb");
#endif
// VMU saves - end
        if (!f) {
            Con_Printf("Couldn't write makaqu.cfg.\n");  // config.cfg replacement - edited
            return;
        }

        Key_WriteBindings(f);
        Cvar_WriteVariables(f);

        fclose(f);
// VMU saves - begin
#ifdef _arch_dreamcast
        {
            extern cvar_t savename;
            char filename[13], description[33];
            sprintf(filename, "%s.CFG", savename.string);
            sprintf(description, "%-32s", cl_name.string);
            VMU_Save("/ram/nxmakaqu.cfg", filename, "nxMakaqu config ", description);
        }
#endif
// VMU saves - end
    }
}


/*
=================
SV_ClientPrintf

Sends text across to be displayed
FIXME: make this just a stuffed echo?
=================
*/
void SV_ClientPrintf(char *fmt, ...)
{
    va_list		argptr;
    char		string[1024];

    va_start(argptr,fmt);
    vsprintf(string, fmt,argptr);
    va_end(argptr);

    MSG_WriteByte(&host_client->message, svc_print);
    MSG_WriteString(&host_client->message, string);
}

/*
=================
SV_BroadcastPrintf

Sends text to all active clients
=================
*/
void SV_BroadcastPrintf(char *fmt, ...)
{
    va_list		argptr;
    char		string[1024];
    int			i;

    va_start(argptr,fmt);
    vsprintf(string, fmt,argptr);
    va_end(argptr);

    for (i=0 ; i<svs.maxclients ; i++)
        if (svs.clients[i].active && svs.clients[i].spawned) {
            MSG_WriteByte(&svs.clients[i].message, svc_print);
            MSG_WriteString(&svs.clients[i].message, string);
        }
}

/*
=================
Host_ClientCommands

Send text over to the client to be executed
=================
*/
void Host_ClientCommands(char *fmt, ...)
{
    va_list		argptr;
    char		string[1024];

    va_start(argptr,fmt);
    vsprintf(string, fmt,argptr);
    va_end(argptr);

    MSG_WriteByte(&host_client->message, svc_stufftext);
    MSG_WriteString(&host_client->message, string);
}

/*
=====================
SV_DropClient

Called when the player is getting totally kicked off the host
if (crash = true), don't bother sending signofs
=====================
*/
void SV_DropClient(qboolean crash)
{
    int		saveSelf;
    int		i;
    client_t *client;

    if (!crash) {
        // send any final messages (don't check for errors)
        if (NET_CanSendMessage(host_client->netconnection)) {
            MSG_WriteByte(&host_client->message, svc_disconnect);
            NET_SendMessage(host_client->netconnection, &host_client->message);
        }

        if (host_client->edict && host_client->spawned) {
            // call the prog function for removing a client
            // this will set the body to a dead frame, among other things
            saveSelf = pr_global_struct->self;
            pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
            PR_ExecuteProgram(pr_global_struct->ClientDisconnect);
            pr_global_struct->self = saveSelf;
        }

        Sys_Printf("Client %s removed\n",host_client->name);
    }

// break the net connection
    NET_Close(host_client->netconnection);
    host_client->netconnection = NULL;

// free the client (the body stays around)
    host_client->active = false;
    host_client->name[0] = 0;
    host_client->old_frags = -999999;
    net_activeconnections--;

// send notification to all clients
    for (i=0, client = svs.clients ; i<svs.maxclients ; i++, client++) {
        if (!client->active) {
            continue;
        }
        MSG_WriteByte(&client->message, svc_updatename);
        MSG_WriteByte(&client->message, host_client - svs.clients);
        MSG_WriteString(&client->message, "");
        MSG_WriteByte(&client->message, svc_updatefrags);
        MSG_WriteByte(&client->message, host_client - svs.clients);
        MSG_WriteShort(&client->message, 0);
        MSG_WriteByte(&client->message, svc_updatecolors);
        MSG_WriteByte(&client->message, host_client - svs.clients);
        MSG_WriteByte(&client->message, 0);
    }
}

/*
==================
Host_ShutdownServer

This only happens at the end of a game, not between levels
==================
*/
void Host_ShutdownServer(qboolean crash)
{
    int		i;
    int		count;
    sizebuf_t	buf;
    char		message[4];
    double	start;

    if (!sv.active) {
        return;
    }

    sv.active = false;

// stop all client sounds immediately
    if (cls.state == ca_connected) {
        CL_Disconnect();
    }

// flush any pending messages - like the score!!!
    start = Sys_FloatTime();
    do {
        count = 0;
        for (i=0, host_client = svs.clients ; i<svs.maxclients ; i++, host_client++) {
            if (host_client->active && host_client->message.cursize) {
                if (NET_CanSendMessage(host_client->netconnection)) {
                    NET_SendMessage(host_client->netconnection, &host_client->message);
                    SZ_Clear(&host_client->message);
                } else {
                    NET_GetMessage(host_client->netconnection);
                    count++;
                }
            }
        }
        if ((Sys_FloatTime() - start) > 3.0) {
            break;
        }
    } while (count);

// make sure all the clients know we're disconnecting
    buf.data = message;
    buf.maxsize = 4;
    buf.cursize = 0;
    MSG_WriteByte(&buf, svc_disconnect);
    count = NET_SendToAll(&buf, 5);
    if (count) {
        Con_Printf("Host_ShutdownServer: NET_SendToAll failed for %u clients\n", count);
    }

    for (i=0, host_client = svs.clients ; i<svs.maxclients ; i++, host_client++)
        if (host_client->active) {
            SV_DropClient(crash);
        }

//
// clear structures
//
    memset(&sv, 0, sizeof(sv));
    memset(svs.clients, 0, svs.maxclientslimit*sizeof(client_t));
}


/*
================
Host_ClearMemory

This clears all the memory used by both the client and server, but does
not reinitialize anything.
================
*/
void Host_ClearMemory(void)
{
    Con_DPrintf("Clearing memory\n");
    D_FlushCaches();
    Mod_ClearAll();
    if (host_hunklevel) {
        Hunk_FreeToLowMark(host_hunklevel);
    }

    cls.signon = 0;
    memset(&sv, 0, sizeof(sv));
    memset(&cl, 0, sizeof(cl));
}


//============================================================================


/*
===================
Host_FilterTime

Returns false if the time is too short to run a frame
===================
*/
qboolean Host_FilterTime(float time)
{
    realtime += time;

    if (!cls.timedemo && realtime - oldrealtime < 1.0/72.0) {
        return false;    // framerate is too high
    }

// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  start
//	host_frametime = realtime - oldrealtime;
    host_org_frametime = host_cpu_frametime = realtime - oldrealtime;
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  end
    oldrealtime = realtime;

    if (host_framerate.value > 0)
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  start
//		host_frametime = host_framerate.value;
    {
        host_org_frametime = host_framerate.value;
    }
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  end
    else {
        // don't allow really long or short frames
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  start
        /*
        		if (host_frametime > 0.1)
        			host_frametime = 0.1;
        		if (host_frametime < 0.001)
        			host_frametime = 0.001;
        */
        if (host_org_frametime > 0.1) {
            host_org_frametime = 0.1;
        }
        if (host_org_frametime < 0.001) {
            host_org_frametime = 0.001;
        }
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  end
    }
    host_frametime = host_org_frametime * host_timescale.value;	// 2001-10-20 TIMESCALE extension by Tomaz/Maddes

    return true;
}


/*
===================
Host_GetConsoleCommands

Add them exactly as if they had been typed at the console
===================
*/
void Host_GetConsoleCommands(void)
{
    char	*cmd;

    while (1) {
        cmd = Sys_ConsoleInput();
        if (!cmd) {
            break;
        }
        Cbuf_AddText(cmd);
    }
}


/*
==================
Host_ServerFrame

==================
*/
#ifdef FPS_20

void _Host_ServerFrame(void)
{
// run the world state
    pr_global_struct->frametime = host_frametime;
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  start
    if (pr_global_cpu_frametime) {
        G_FLOAT(pr_global_cpu_frametime->ofs) = host_cpu_frametime;
    }

    if (pr_global_org_frametime) {
        G_FLOAT(pr_global_org_frametime->ofs) = host_org_frametime;
    }
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  end

// read client messages
    SV_RunClients();

// move things around and think
// always pause in single player if in console or menus
// begin
#ifdef _arch_dreamcast
    if (!sv.paused && key_dest == key_game)
#else
// end
    if (!sv.paused && (svs.maxclients > 1 || key_dest == key_game))
#endif // Edited
        SV_Physics();
}

void Host_ServerFrame(void)
{
    float	save_host_frametime;
    float	temp_host_frametime;

// run the world state
    pr_global_struct->frametime = host_frametime;
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  start
    if (pr_global_cpu_frametime) {
        G_FLOAT(pr_global_cpu_frametime->ofs) = host_cpu_frametime;
    }

    if (pr_global_org_frametime) {
        G_FLOAT(pr_global_org_frametime->ofs) = host_org_frametime;
    }
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  end

// set the time and clear the general datagram
    SV_ClearDatagram();

// check for new clients
    SV_CheckForNewClients();

    temp_host_frametime = save_host_frametime = host_frametime;
    while (temp_host_frametime > (1.0/72.0)) {
        if (temp_host_frametime > 0.05) {
            host_frametime = 0.05;
        } else {
            host_frametime = temp_host_frametime;
        }
        temp_host_frametime -= host_frametime;
        _Host_ServerFrame();
    }
    host_frametime = save_host_frametime;

// send all messages to the clients
    SV_SendClientMessages();
}

#else

void Host_ServerFrame(void)
{
// run the world state
    pr_global_struct->frametime = host_frametime;
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  start
    if (pr_global_cpu_frametime) {
        G_FLOAT(pr_global_cpu_frametime->ofs) = host_cpu_frametime;
    }

    if (pr_global_org_frametime) {
        G_FLOAT(pr_global_org_frametime->ofs) = host_org_frametime;
    }
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes  end

// set the time and clear the general datagram
    SV_ClearDatagram();

// check for new clients
    SV_CheckForNewClients();

// read client messages
    SV_RunClients();

// move things around and think
// always pause in single player if in console or menus
// begin
#ifdef _arch_dreamcast
    if (!sv.paused && key_dest == key_game)
#else
// end
    if (!sv.paused && (svs.maxclients > 1 || key_dest == key_game))
#endif // Edited
        SV_Physics();

// send all messages to the clients
    SV_SendClientMessages();
}

#endif


/*
==================
Host_Frame

Runs all active servers
==================
*/
void _Host_Frame(float time)
{
    static double		time1 = 0;
    static double		time2 = 0;
    static double		time3 = 0;
    int			pass1, pass2, pass3;

    if (setjmp(host_abortserver)) {
        return;    // something bad happened, or the server disconnected
    }

// keep the random time dependent
    rand();

// decide the simulation time
    if (!Host_FilterTime(time)) {
        return;    // don't run too fast, or packets will flood out
    }

// get new key events
    Sys_SendKeyEvents();

// allow mice or other external controllers to add commands
    IN_Commands();

// process console commands
    Cbuf_Execute();

    NET_Poll();

// if running the server locally, make intentions now
    if (sv.active) {
        CL_SendCmd();
    }

//-------------------
//
// server operations
//
//-------------------

// check for commands typed to the host
    Host_GetConsoleCommands();

    if (sv.active) {
        Host_ServerFrame();
    }

//-------------------
//
// client operations
//
//-------------------

// if running the server remotely, send intentions now after
// the incoming messages have been read
    if (!sv.active) {
        CL_SendCmd();
    }

    host_time += host_frametime;

// fetch results from server
    if (cls.state == ca_connected) {
        CL_ReadFromServer();
    }

// update video
    if (host_speeds.value) {
        time1 = Sys_FloatTime();
    }

    SCR_UpdateScreen();

    if (host_speeds.value) {
        time2 = Sys_FloatTime();
    }

// update audio
    if (cls.signon == SIGNONS) {
        S_Update(r_origin, vpn, vright, vup);
        CL_DecayLights();
    } else {
        S_Update(vec3_origin, vec3_origin, vec3_origin, vec3_origin);
    }

    CDAudio_Update();

    if (host_speeds.value) {
        pass1 = (int)(time1 - time3)*1000;
        time3 = Sys_FloatTime();
        pass2 = (int)(time2 - time1)*1000;
        pass3 = (int)(time3 - time2)*1000;
        Con_Printf("%3i tot %3i server %3i gfx %3i snd\n",
                   pass1+pass2+pass3, pass1, pass2, pass3);
    }

    host_framecount++;
    fps_count++;	// 2001-11-31 FPS display by QuakeForge/Muff
}

void Host_Frame(float time)
{
    double	time1, time2;
    static double	timetotal;
    static int		timecount;
    int		i, c, m;

    if (!serverprofile.value) {
        _Host_Frame(time);
        return;
    }

    time1 = Sys_FloatTime();
    _Host_Frame(time);
    time2 = Sys_FloatTime();

    timetotal += time2 - time1;
    timecount++;

    if (timecount < 1000) {
        return;
    }

    m = (int)(timetotal*1000.)/timecount;
    timecount = 0;
    timetotal = 0;
    c = 0;
    for (i=0 ; i<svs.maxclients ; i++) {
        if (svs.clients[i].active) {
            c++;
        }
    }

    Con_Printf("serverprofile: %2i clients %2i msec\n",  c,  m);
}

//============================================================================


extern int vcrFile;
#define	VCR_SIGNATURE	0x56435231
// "VCR1"

void Host_InitVCR(quakeparms_t *parms)
{
    int		i, len, n;
    char	*p;

    if (COM_CheckParm("-playback")) {
        if (com_argc != 2) {
            Sys_Error("No other parameters allowed with -playback\n");
        }

        Sys_FileOpenRead("quake.vcr", &vcrFile);
        if (vcrFile == -1) {
            Sys_Error("playback file not found\n");
        }

        Sys_FileRead(vcrFile, &i, sizeof(int));
        if (i != VCR_SIGNATURE) {
            Sys_Error("Invalid signature in vcr file\n");
        }

        Sys_FileRead(vcrFile, &com_argc, sizeof(int));
        com_argv = malloc(com_argc * sizeof(char *));
        com_argv[0] = parms->argv[0];
        for (i = 0; i < com_argc; i++) {
            Sys_FileRead(vcrFile, &len, sizeof(int));
            p = malloc(len);
            Sys_FileRead(vcrFile, p, len);
            com_argv[i+1] = p;
        }
        com_argc++; /* add one for arg[0] */
        parms->argc = com_argc;
        parms->argv = com_argv;
    }

    if ((n = COM_CheckParm("-record")) != 0) {
        vcrFile = Sys_FileOpenWrite("quake.vcr");

        i = VCR_SIGNATURE;
        Sys_FileWrite(vcrFile, &i, sizeof(int));
        i = com_argc - 1;
        Sys_FileWrite(vcrFile, &i, sizeof(int));
        for (i = 1; i < com_argc; i++) {
            if (i == n) {
                len = 10;
                Sys_FileWrite(vcrFile, &len, sizeof(int));
                Sys_FileWrite(vcrFile, "-playback", len);
                continue;
            }
            len = Q_strlen(com_argv[i]) + 1;
            Sys_FileWrite(vcrFile, &len, sizeof(int));
            Sys_FileWrite(vcrFile, com_argv[i], len);
        }
    }

}

/*
====================
Host_Init
====================
*/
void Host_Init(quakeparms_t *parms)
{
    loadedfile_t	*fileinfo;	// 2001-09-12 Returning information about loaded file by Maddes

//Edited	if (standard_quake)
    minimum_memory = MINIMUM_MEMORY;
//	else
//		minimum_memory = MINIMUM_MEMORY_LEVELPAK;

    if (COM_CheckParm("-minmemory")) {
        parms->memsize = minimum_memory;
    }

    host_parms = *parms;

    if (parms->memsize < minimum_memory) {
        Sys_Error("Only %4.1f megs of memory available, can't execute game", parms->memsize / (float)0x100000);
    }

    com_argc = parms->argc;
    com_argv = parms->argv;

    Memory_Init(parms->membase, parms->memsize);
    Cbuf_Init();
    Cmd_Init();
    Con_Init();
    V_Init();
    Chase_Init();
    Host_InitVCR(parms);
    COM_Init(parms->basedir);
    Host_InitLocal();
    W_LoadWadFile("gfx.wad");
    Key_Init();
    M_Init();
    PR_Init();
    Mod_Init();
    NET_Init();
    SV_Init();

    Con_DPrintf("Exe: "__TIME__" "__DATE__"\n");  // edited
    Con_DPrintf("%4.1f megabyte heap\n",parms->memsize/ (1024*1024.0));  // edited

    R_InitTextures();		// needed even for dedicated servers

    if (cls.state != ca_dedicated) {
// 2001-09-12 Returning information about loaded file by Maddes  start
        /*
        		host_basepal = (byte *)COM_LoadHunkFile ("gfx/palette.lmp");
        		if (!host_basepal)
        */
        fileinfo = COM_LoadHunkFile("gfx/palette.lmp");
        if (!fileinfo)
// 2001-09-12 Returning information about loaded file by Maddes  end
        {
            Sys_Error("Couldn't load gfx/palette.lmp");
        }
        host_basepal = fileinfo->data;	// 2001-09-12 Returning information about loaded file by Maddes
// 2001-09-12 Returning information about loaded file by Maddes  start
        /*
        		host_colormap = (byte *)COM_LoadHunkFile ("gfx/colormap.lmp");
        		if (!host_colormap)
        */
        fileinfo = COM_LoadHunkFile("gfx/colormap.lmp");
        if (!fileinfo)
// 2001-09-12 Returning information about loaded file by Maddes  end
        {
            Sys_Error("Couldn't load gfx/colormap.lmp");
        }
        host_colormap = fileinfo->data;	// 2001-09-12 Returning information about loaded file by Maddes

#ifndef _arch_dreamcast // Edited
#ifndef _WIN32 // on non win32, mouse comes before video for security reasons
        IN_Init();
#endif
        VID_Init(host_basepal);

        Draw_Init();
        SCR_Init();
        R_Init();
#ifndef	_WIN32
        // on Win32, sound initialization has to come before video initialization, so we
        // can put up a popup if the sound hardware is in use
        S_Init();
#else

#ifdef	GLQUAKE
        // FIXME: doesn't use the new one-window approach yet
        S_Init();
#endif

#endif	// _WIN32
        CDAudio_Init();
        Sbar_Init();
        CL_Init();
#ifdef _WIN32 // on non win32, mouse comes before video for security reasons
        IN_Init();
#endif
#else
        IN_Init();
        VID_Init(host_basepal);

        Draw_Init();
        SCR_Init();
        R_Init();
        CDAudio_Init();
        S_Init();
        Sbar_Init();
        CL_Init();
#endif
    }


    Cbuf_InsertText("exec quake.rc\n");  // moved to menu.c

    Hunk_AllocName(0, "-HOST_HUNKLEVEL-");
    host_hunklevel = Hunk_LowMark();
    host_initialized = true;
}


/*
===============
Host_Shutdown

FIXME: this is a callback from Sys_Quit and Sys_Error.  It would be better
to run quit through here before the final handoff to the sys code.
===============
*/
void Host_Shutdown(void)
{
    static qboolean isdown = false;

    if (isdown) {
        printf("recursive shutdown\n");
        return;
    }
    isdown = true;

// keep Con_Printf from trying to update the screen
    scr_disabled_for_loading = true;

#ifndef _arch_dreamcast // VMU saves
    Host_WriteConfiguration();
#endif // VMU saves

    CDAudio_Shutdown();
    NET_Shutdown();
    S_Shutdown();
    IN_Shutdown();

    if (cls.state != ca_dedicated) {
        VID_Shutdown();
    }
}
