/** Toggles a console variable. Useful for on/off values.
*
* This works on on/off, yes/no values only
*/
static void COM_Toggle_f(void)
{
consvar_t *cvar;
if (COM_Argc() != 2)
{
CONS_Printf("Toggle <cvar_name>\n"
"Toggle the value of a cvar\n");
return;
}
cvar = CV_FindVar(COM_Argv(1));
if (!cvar)
{
CONS_Printf("%s is not a cvar\n",COM_Argv(1));
return;
}
if (!(cvar->PossibleValue == CV_YesNo || cvar->PossibleValue == CV_OnOff))
{
CONS_Printf("%s is not a boolean value\n",COM_Argv(1));
return;
}
// netcvar don't change imediately
cvar->flags |= CV_SHOWMODIFONETIME;
CV_AddValue(cvar, +1);
}
/** Executes a script file.
*/
static void COM_Exec_f(void)
{
size_t length;
UINT8 *buf = NULL;
if (COM_Argc() < 2 || COM_Argc() > 3)
{
CONS_Printf("exec <filename> : run a script file\n");
return;
}
// load file
length = FIL_ReadFile(COM_Argv(1), &buf);
if (!buf)
{
if (!COM_CheckParm("-noerror"))
CONS_Printf("couldn't execute file %s\n", COM_Argv(1));
return;
}
if (!COM_CheckParm("-silent"))
CONS_Printf("executing %s\n", COM_Argv(1));
// insert text file into the command buffer
COM_BufAddText((char *)buf);
COM_BufAddText("\n");
// free buffer
Z_Free(buf);
}
/*
* Adds command line parameters as script statements Commands lead with
* a +, and continue until another +
*
* Set commands are added early, so they are guaranteed to be set before
* the client and server initialize for the first time.
*
* Other commands are added late, after all initialization is complete.
*/
void
Cbuf_AddEarlyCommands(qboolean clear)
{
int i;
char *s;
for (i = 0; i < COM_Argc(); i++)
{
s = COM_Argv(i);
if (strcmp(s, "+set"))
{
continue;
}
Cbuf_AddText(va("set %s %s\n", COM_Argv(i + 1), COM_Argv(i + 2)));
if (clear)
{
COM_ClearArgv(i);
COM_ClearArgv(i + 1);
COM_ClearArgv(i + 2);
}
i += 2;
}
}
void Command_Charability_f(void)
{
if (gamestate != GS_LEVEL || demoplayback)
{
CONS_Printf("%s", text[MUSTBEINLEVEL]);
return;
}
G_ModifyGame();
if (COM_Argc() < 3)
{
CONS_Printf("charability <1/2> <value>\n");
return;
}
if (netgame || multiplayer)
{
CONS_Printf("%s", text[CANTUSEMULTIPLAYER]);
return;
}
if (atoi(COM_Argv(1)) == 1)
players[consoleplayer].charability = atoi(COM_Argv(2));
else if (atoi(COM_Argv(1)) == 2)
players[consoleplayer].charability2 = atoi(COM_Argv(2));
else
CONS_Printf("charability <1/2> <value>\n");
}
/** Creates a command name that replaces another command.
*/
static void COM_Alias_f(void)
{
cmdalias_t *a;
char cmd[1024];
size_t i, c;
if (COM_Argc() < 3)
{
CONS_Printf("alias <name> <command>\n");
return;
}
a = ZZ_Alloc(sizeof *a);
a->next = com_alias;
com_alias = a;
a->name = Z_StrDup(COM_Argv(1));
// copy the rest of the command line
cmd[0] = 0; // start out with a null string
c = COM_Argc();
for (i = 2; i < c; i++)
{
strcat(cmd, COM_Argv(i));
if (i != c)
strcat(cmd, " ");
}
strcat(cmd, "\n");
a->value = Z_StrDup(cmd);
}
/*
=================
Cbuf_AddLateCommands
Adds command line parameters as script statements
Commands lead with a + and continue until another + or -
quake +vid_ref gl +map amlev1
Returns true if any late commands were added, which
will keep the demoloop from immediately starting
=================
*/
qboolean Cbuf_AddLateCommands (void)
{
int i, j;
int s;
char *text, *build, c;
int argc;
qboolean ret;
// build the combined string to parse from
s = 0;
argc = COM_Argc();
for (i=1 ; i<argc ; i++)
{
s += strlen (COM_Argv(i)) + 1;
}
if (!s)
return false;
text = (char *) Z_Malloc (s+1);
text[0] = 0;
for (i=1 ; i<argc ; i++)
{
strcat (text,COM_Argv(i));
if (i != argc-1)
strcat (text, " ");
}
// pull out the commands
build = (char *) Z_Malloc (s+1);
build[0] = 0;
for (i=0 ; i<s-1 ; i++)
{
if (text[i] == '+')
{
i++;
for (j=i ; (text[j] != '+') && (text[j] != '-') && (text[j] != 0) ; j++)
;
c = text[j];
text[j] = 0;
strcat (build, text+i);
strcat (build, "\n");
text[j] = c;
i = j-1;
}
}
ret = (build[0] != 0);
if (ret)
Cbuf_AddText (build);
Z_Free (text);
Z_Free (build);
return ret;
}
/*
===============
Cbuf_AddEarlyCommands
Set commands are added early, so they are guaranteed to be set before
the client and server initialize for the first time.
Other commands are added late, after all initialization is complete.
===============
*/
void Cbuf_AddEarlyCommands (void)
{
int i;
for (i=0 ; i<COM_Argc()-2 ; i++)
{
if (Q_stricmp(COM_Argv(i), "+set"))
continue;
Cbuf_AddText (va("set %s %s\n", COM_Argv(i+1), COM_Argv(i+2)));
i+=2;
}
}
static void setcontrol(INT32 (*gc)[2])
{
INT32 numctrl;
const char *namectrl;
INT32 keynum, keynum1, keynum2;
INT32 player = ((void*)gc == (void*)&gamecontrolbis ? 1 : 0);
boolean nestedoverride = false;
namectrl = COM_Argv(1);
for (numctrl = 0; numctrl < num_gamecontrols && stricmp(namectrl, gamecontrolname[numctrl]);
numctrl++)
;
if (numctrl == num_gamecontrols)
{
CONS_Printf(M_GetText("Control '%s' unknown\n"), namectrl);
return;
}
keynum1 = G_KeyStringtoNum(COM_Argv(2));
keynum2 = G_KeyStringtoNum(COM_Argv(3));
keynum = G_FilterKeyByVersion(numctrl, 0, player, &keynum1, &keynum2, &nestedoverride);
if (keynum >= 0)
{
(void)G_CheckDoubleUsage(keynum, true);
// if keynum was rejected, try it again with keynum2
if (!keynum && keynum2)
{
keynum1 = keynum2; // push down keynum2
keynum2 = 0;
keynum = G_FilterKeyByVersion(numctrl, 0, player, &keynum1, &keynum2, &nestedoverride);
if (keynum >= 0)
(void)G_CheckDoubleUsage(keynum, true);
}
}
if (keynum >= 0)
gc[numctrl][0] = keynum;
if (keynum2)
{
keynum = G_FilterKeyByVersion(numctrl, 1, player, &keynum1, &keynum2, &nestedoverride);
if (keynum >= 0)
{
if (keynum != gc[numctrl][0])
gc[numctrl][1] = keynum;
else
gc[numctrl][1] = 0;
}
}
else
gc[numctrl][1] = 0;
}
/** Parses a single line of text into arguments and tries to execute it.
* The text can come from the command buffer, a remote client, or stdin.
*
* \param ptext A single line of text.
*/
static void COM_ExecuteString(char *ptext)
{
xcommand_t *cmd;
cmdalias_t *a;
COM_TokenizeString(ptext);
// execute the command line
if (COM_Argc() == 0)
return; // no tokens
// check functions
for (cmd = com_commands; cmd; cmd = cmd->next)
{
if (!stricmp(com_argv[0], cmd->name)) //case insensitive now that we have lower and uppercase!
{
cmd->function();
return;
}
}
// check aliases
for (a = com_alias; a; a = a->next)
{
if (!stricmp(com_argv[0], a->name))
{
COM_BufInsertText(a->value);
return;
}
}
// check cvars
if (!CV_Command() && con_destlines)
CONS_Printf("Unknown command '%s'\n", COM_Argv(0));
}
void IN_Init (void)
{
#ifdef GLQUAKE
#ifdef WITH_EVDEV
int i;
#endif
#endif
Cvar_SetCurrentGroup (CVAR_GROUP_INPUT_MOUSE);
Cvar_Register (&m_filter);
#ifndef _Soft_SVGA
Cvar_Register (&_windowed_mouse);
#endif
Cvar_SetCurrentGroup (CVAR_GROUP_INPUT_KEYBOARD);
Cvar_Register (&cl_keypad);
Cvar_ResetCurrentGroup ();
if (!host_initialized)
{
#ifdef GLQUAKE
typedef enum { mt_none = 0, mt_dga, mt_normal, mt_evdev } mousetype_t;
extern cvar_t in_mouse;
#ifdef WITH_EVDEV
extern cvar_t in_mmt;
extern cvar_t in_evdevice;
#endif /* !WITH_EVDEV */
if (COM_CheckParm ("-nodga") || COM_CheckParm ("-nomdga"))
Cvar_LatchedSetValue (&in_mouse, mt_normal);
#ifdef WITH_EVDEV
if ((i = COM_CheckParm ("-mevdev")) && (i < COM_Argc() - 1)) {
Cvar_LatchedSet (&in_evdevice, COM_Argv(i + 1));
Cvar_LatchedSetValue (&in_mouse, mt_evdev);
}
if (COM_CheckParm ("-mmt"))
Cvar_LatchedSetValue (&in_mmt, 1);
#endif /* !WITH_EVDEV */
if (COM_CheckParm ("-nomouse"))
Cvar_LatchedSetValue (&in_mouse, mt_none);
#ifdef WITH_EVDEV
extern void IN_EvdevList_f(void);
Cmd_AddCommand ("in_evdevlist", IN_EvdevList_f);
#endif /* !WITH_EVDEV */
#endif /* !GLQUAKE */
#ifdef WITH_KEYMAP
IN_StartupKeymap();
#endif // WITH_KEYMAP
#ifdef GLQUAKE
Cmd_AddCommand ("in_restart", IN_Restart_f);
#endif
}
IN_StartupMouse ();
}
void Command_Scale_f(void)
{
INT32 scale = atoi(COM_Argv(1));
if (!cv_debug)
{
CONS_Printf("%s", text[NEED_DEVMODE]);
return;
}
if (netgame || multiplayer)
{
CONS_Printf("%s", text[SINGLEPLAYERONLY]);
return;
}
if (!(scale >= 5 && scale <= 400)) //COM_Argv(1) will return a null string if they did not give a paramater, so...
{
CONS_Printf("SCALE <value> (5-400): Set player scale size.\n");
return;
}
if (!players[consoleplayer].mo)
return;
players[consoleplayer].mo->destscale = (UINT16)scale;
CONS_Printf("Scale set to %d\n", players[consoleplayer].mo->destscale);
}
void Command_Hurtme_f(void)
{
if (gamestate != GS_LEVEL || demoplayback)
{
CONS_Printf("%s", text[MUSTBEINLEVEL]);
return;
}
if (!cv_debug)
{
CONS_Printf("%s", text[NEED_DEVMODE]);
return;
}
if (netgame || multiplayer)
{
CONS_Printf("%s", text[CANTUSEMULTIPLAYER]);
return;
}
if (COM_Argc() < 2)
{
CONS_Printf("hurtme <damage>\n");
return;
}
P_DamageMobj(players[consoleplayer].mo, NULL, NULL, atoi(COM_Argv(1)));
}
void PR2_Init(void)
{
int p;
int usedll;
Cvar_Register(&sv_progtype);
Cvar_Register(&sv_progsname);
#ifdef WITH_NQPROGS
Cvar_Register(&sv_forcenqprogs);
#endif
#ifdef QVM_PROFILE
Cvar_Register(&sv_enableprofile);
#endif
p = COM_CheckParm ("-progtype");
if (p && p < COM_Argc())
{
usedll = Q_atoi(COM_Argv(p + 1));
if (usedll > 2)
usedll = VM_NONE;
Cvar_SetValue(&sv_progtype,usedll);
}
Cmd_AddCommand ("edict", ED2_PrintEdict_f);
Cmd_AddCommand ("edicts", ED2_PrintEdicts);
Cmd_AddCommand ("edictcount", ED_Count);
Cmd_AddCommand ("profile", PR2_Profile_f);
Cmd_AddCommand ("mod", PR2_GameConsoleCommand);
memset(pr_newstrtbl, 0, sizeof(pr_newstrtbl));
}
void NET_InitClient(void)
{
int port = PORT_CLIENT;
int p;
p = COM_CheckParm ("-clientport");
if (p && p < COM_Argc()) {
port = atoi(COM_Argv(p+1));
}
if (cls.socketip == INVALID_SOCKET)
cls.socketip = UDP_OpenSocket (port);
if (cls.socketip == INVALID_SOCKET)
cls.socketip = UDP_OpenSocket (PORT_ANY); // any dynamic port
if (cls.socketip == INVALID_SOCKET)
Sys_Error ("Couldn't allocate client socket");
// init the message buffer
SZ_Init (&net_message, net_message_buffer, sizeof(net_message_buffer));
// determine my name & address
NET_GetLocalAddress (cls.socketip, &net_local_cl_ipadr);
Com_Printf_State (PRINT_OK, "Client port Initialized\n");
}
/** Delays execution of the rest of the commands until the next frame.
* Allows sequences of commands like "jump; fire; backward".
*/
static void COM_Wait_f(void)
{
if (COM_Argc() > 1)
com_wait = atoi(COM_Argv(1));
else
com_wait = 1; // 1 frame
}
/** Prints a line of text to the console.
*/
static void COM_Echo_f(void)
{
size_t i;
for (i = 1; i < COM_Argc(); i++)
CONS_Printf("%s ", COM_Argv(i));
CONS_Printf("\n");
}
void Command_CountMobjs_f(void)
{
thinker_t *th;
mobjtype_t i;
INT32 count;
if (gamestate != GS_LEVEL)
{
CONS_Printf(M_GetText("You must be in a level to use this.\n"));
return;
}
if (COM_Argc() >= 2)
{
size_t j;
for (j = 1; j < COM_Argc(); j++)
{
i = atoi(COM_Argv(j));
if (i >= NUMMOBJTYPES)
{
CONS_Printf(M_GetText("Object number %d out of range (max %d).\n"), i, NUMMOBJTYPES-1);
continue;
}
count = 0;
for (th = thinkercap.next; th != &thinkercap; th = th->next)
{
if (th->function.acp1 != (actionf_p1)P_MobjThinker)
continue;
if (((mobj_t *)th)->type == i)
count++;
}
CONS_Printf(M_GetText("There are %d objects of type %d currently in the level.\n"), count, i);
}
return;
}
CONS_Printf(M_GetText("Count of active objects in level:\n"));
for (i = 0; i < NUMMOBJTYPES; i++)
{
count = 0;
for (th = thinkercap.next; th != &thinkercap; th = th->next)
{
if (th->function.acp1 != (actionf_p1)P_MobjThinker)
continue;
if (((mobj_t *)th)->type == i)
count++;
}
CONS_Printf(" * %d: %d\n", i, count);
}
}
//memsize is the recommended amount of memory to use for hunk
void Host_InitMemory (int memsize)
{
int t;
if (COM_CheckParm ("-minmemory"))
memsize = MINIMUM_MEMORY;
if ((t = COM_CheckParm ("-heapsize")) != 0 && t + 1 < COM_Argc())
memsize = Q_atoi (COM_Argv(t + 1)) * 1024;
if ((t = COM_CheckParm ("-mem")) != 0 && t + 1 < COM_Argc())
memsize = Q_atoi (COM_Argv(t + 1)) * 1024 * 1024;
if (memsize < MINIMUM_MEMORY)
Sys_Error ("Only %4.1f megs of memory reported, can't execute game", memsize / (float)0x100000);
host_memsize = memsize;
host_membase = Q_malloc (host_memsize);
Memory_Init (host_membase, host_memsize);
}
/** Executes a script file.
*/
static void COM_Exec_f(void)
{
UINT8 *buf = NULL;
char filename[256];
if (COM_Argc() < 2 || COM_Argc() > 3)
{
CONS_Printf(M_GetText("exec <filename>: run a script file\n"));
return;
}
// load file
// Try with Argv passed verbatim first, for back compat
FIL_ReadFile(COM_Argv(1), &buf);
if (!buf)
{
// Now try by searching the file path
// filename is modified with the full found path
strcpy(filename, COM_Argv(1));
if (findfile(filename, NULL, true) != FS_NOTFOUND)
FIL_ReadFile(filename, &buf);
if (!buf)
{
if (!COM_CheckParm("-noerror"))
CONS_Printf(M_GetText("couldn't execute file %s\n"), COM_Argv(1));
return;
}
}
if (!COM_CheckParm("-silent"))
CONS_Printf(M_GetText("executing %s\n"), COM_Argv(1));
// insert text file into the command buffer
COM_BufAddText((char *)buf);
COM_BufAddText("\n");
// free buffer
Z_Free(buf);
}
int UDP_OpenSocket (unsigned short int port)
{
int newsocket;
struct sockaddr_in address;
unsigned long _true = true;
int i;
if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) {
Con_Printf ("UDP_OpenSocket: socket: (%i): %s\n", qerrno, strerror(qerrno));
return INVALID_SOCKET;
}
#ifndef _WIN32
if ((fcntl (newsocket, F_SETFL, O_NONBLOCK)) == -1) { // O'Rly?! @@@
Con_Printf ("UDP_OpenSocket: fcntl: (%i): %s\n", qerrno, strerror(qerrno));
closesocket(newsocket);
return INVALID_SOCKET;
}
#endif
if (ioctlsocket (newsocket, FIONBIO, &_true) == -1) { // make asynchronous
Con_Printf ("UDP_OpenSocket: ioctl: (%i): %s\n", qerrno, strerror(qerrno));
closesocket(newsocket);
return INVALID_SOCKET;
}
address.sin_family = AF_INET;
// check for interface binding option
if ((i = COM_CheckParm("-ip")) != 0 && i < COM_Argc()) {
address.sin_addr.s_addr = inet_addr(COM_Argv(i+1));
Con_DPrintf ("Binding to IP Interface Address of %s\n", inet_ntoa(address.sin_addr));
}
else {
address.sin_addr.s_addr = INADDR_ANY;
}
if (port == PORT_ANY) {
address.sin_port = 0;
}
else {
address.sin_port = htons(port);
}
if (bind (newsocket, (void *)&address, sizeof(address)) == -1) {
Con_Printf ("UDP_OpenSocket: bind: (%i): %s\n", qerrno, strerror(qerrno));
closesocket(newsocket);
return INVALID_SOCKET;
}
return newsocket;
}
void Rulesets_Init (void)
{
int temp;
Cvar_Register (&ruleset);
if ((temp = COM_CheckParm ("-ruleset")) && temp + 1 < COM_Argc()) {
if (!strcasecmp (COM_Argv(temp + 1), "smackdown")) {
Cvar_Set (&ruleset, "smackdown");
return;
} else if (!strcasecmp (COM_Argv(temp + 1), "mtfl")) {
Cvar_Set (&ruleset, "mtfl");
return;
} else if (strcasecmp (COM_Argv(temp + 1), "default")){
Cvar_Set (&ruleset, "default");
return;
} else {
Rulesets_Default ();
return;
}
}
}
/** Displays text on the center of the screen for a short time.
*/
static void COM_CEcho_f(void)
{
size_t i;
char cechotext[1024] = "";
for (i = 1; i < COM_Argc(); i++)
{
strncat(cechotext, COM_Argv(i), sizeof(cechotext)-1);
strncat(cechotext, " ", sizeof(cechotext)-1);
}
cechotext[sizeof(cechotext) - 1] = '\0';
HU_DoCEcho(cechotext);
}
/** Sets drawing flags for the CECHO command.
*/
static void COM_CEchoFlags_f(void)
{
if (COM_Argc() > 1)
{
const char *arg = COM_Argv(1);
if (arg[0] && arg[0] == '0' &&
arg[1] && arg[1] == 'x') // Use hexadecimal!
HU_SetCEchoFlags(axtoi(arg+2));
else
HU_SetCEchoFlags(atoi(arg));
}
else
CONS_Printf(M_GetText("cechoflags <flags>: set CEcho flags, prepend with 0x to use hexadecimal\n"));
}
/** Parses a single line of text into arguments and tries to execute it.
* The text can come from the command buffer, a remote client, or stdin.
*
* \param ptext A single line of text.
*/
static void COM_ExecuteString(char *ptext)
{
xcommand_t *cmd;
cmdalias_t *a;
static INT32 recursion = 0; // detects recursion and stops it if it goes too far
COM_TokenizeString(ptext);
// execute the command line
if (COM_Argc() == 0)
return; // no tokens
// check functions
for (cmd = com_commands; cmd; cmd = cmd->next)
{
if (!stricmp(com_argv[0], cmd->name)) //case insensitive now that we have lower and uppercase!
{
recursion = 0;
cmd->function();
return;
}
}
// check aliases
for (a = com_alias; a; a = a->next)
{
if (!stricmp(com_argv[0], a->name))
{
if (recursion > MAX_ALIAS_RECURSION)
{
CONS_Alert(CONS_WARNING, M_GetText("Alias recursion cycle detected!\n"));
recursion = 0;
return;
}
recursion++;
COM_BufInsertText(a->value);
return;
}
}
recursion = 0;
// check cvars
// Hurdler: added at Ebola's request ;)
// (don't flood the console in software mode with bad gr_xxx command)
if (!CV_Command() && con_destlines)
CONS_Printf(M_GetText("Unknown command '%s'\n"), COM_Argv(0));
}
// vid_mode <modenum>
//
static void VID_Command_Mode_f(void)
{
int modenum;
if (COM_Argc() != 2)
{
CONS_Printf(M_GetText("vid_mode <modenum> : set video mode, current video mode %i\n"), vid.modenum);
return;
}
modenum = atoi(COM_Argv(1));
if (modenum > VID_NumModes() || modenum < NUMSPECIALMODES) // don't accept the windowed mode 0
CONS_Printf("%s", M_GetText("No video modes present\n"));
else
setmodeneeded = modenum + 1; // request vid mode change
}
static void VID_ParseCmdLine(void)
{
int i, w = 0, h = 0, display = 0;
if (COM_CheckParm("-window") || COM_CheckParm("-startwindowed")) {
Cvar_LatchedSetValue(&r_fullscreen, 0);
}
if ((i = COM_CheckParm("-freq")) && i + 1 < COM_Argc()) {
Cvar_LatchedSetValue(&r_displayRefresh, Q_atoi(COM_Argv(i + 1)));
}
if ((i = COM_CheckParm("-bpp")) && i + 1 < COM_Argc()) {
Cvar_LatchedSetValue(&r_colorbits, Q_atoi(COM_Argv(i + 1)));
}
w = ((i = COM_CheckParm("-width")) && i + 1 < COM_Argc()) ? Q_atoi(COM_Argv(i + 1)) : 0;
h = ((i = COM_CheckParm("-height")) && i + 1 < COM_Argc()) ? Q_atoi(COM_Argv(i + 1)) : 0;
display = ((i = COM_CheckParm("-display")) && i + 1 < COM_Argc()) ? Q_atoi(COM_Argv(i + 1)) : 0;
if (i) {
if (COM_CheckParm("-window")) {
Cvar_LatchedSetValue(&vid_win_displayNumber, display);
} else {
Cvar_LatchedSetValue(&vid_displayNumber, display);
}
}
if (w && h) {
if (COM_CheckParm("-window")) {
Cvar_LatchedSetValue(&vid_win_width, w);
Cvar_LatchedSetValue(&vid_win_height, h);
} else {
Cvar_LatchedSetValue(&vid_width, w);
Cvar_LatchedSetValue(&vid_height, h);
}
} // else if (w || h) { Sys_Error("Must specify both -width and -height\n"); }
if ((i = COM_CheckParm("-conwidth")) && i + 1 < COM_Argc()) {
Cvar_SetValue(&r_conwidth, (float)Q_atoi(COM_Argv(i + 1)));
}
if ((i = COM_CheckParm("-conheight")) && i + 1 < COM_Argc()) {
Cvar_SetValue(&r_conheight, (float)Q_atoi(COM_Argv(i + 1)));
}
}
int D_SurfaceCacheForRes (int width, int height)
{
int size, pix;
if (COM_CheckParm ("-surfcachesize"))
{
size = Q_atoi(COM_Argv(COM_CheckParm("-surfcachesize")+1)) * 1024;
return size;
}
size = SURFCACHE_SIZE_AT_320X200;
pix = width*height;
if (pix > 64000)
size += (pix-64000)*3;
return size;
}
void Command_Devmode_f(void)
{
if (netgame || multiplayer)
return;
if (COM_Argc() > 1)
cv_debug = atoi(COM_Argv(1));
else if (!cv_debug)
cv_debug = 1;
else
cv_debug = 0;
if (!modifiedgame || savemoddata)
{
modifiedgame = true;
savemoddata = false;
if (!(netgame || multiplayer))
CONS_Printf("%s", text[GAMEMODIFIED]);
}
}
void Command_Devmode_f(void)
{
if (netgame
#ifndef _DEBUG
|| multiplayer
#endif
)
return;
if (COM_Argc() > 1)
cv_devmode = atoi(COM_Argv(1));
else if (!cv_devmode)
cv_devmode = 1;
else
cv_devmode = 0;
#ifndef _DEBUG // Only modify the game in release mode
G_ModifyGame();
#endif
}
void Command_Scale_f(void)
{
int scale = atoi(COM_Argv(1));
G_ModifyGame();
if (netgame
#ifndef _DEBUG
|| multiplayer
#endif
)
{
CONS_Printf("%s", text[SINGLEPLAYERONLY]);
return;
}
if (!scale)
{
CONS_Printf("Current scale: %d%%, Valid scale values are 25%% to 500%%\n", players[consoleplayer].mo->scale);
return;
}
else if (!(scale >= 25 && scale <= 500))
{
CONS_Printf("Valid scale values are 25%% to 500%%\n");
if (scale < 25)
scale = 25;
else if (scale > 500)
scale = 500;
}
if (!players[consoleplayer].mo)
{
CONS_Printf("%s",text[MUSTBEINLEVEL]);
return;
}
players[consoleplayer].mo->destscale = (USHORT)scale;
CONS_Printf("Scale set to %d%%\n", players[consoleplayer].mo->destscale);
}
