const char *stringvalue(const svalue_t & v)
{
static char buffer[256];
switch(v.type)
{
case svt_string:
return v.string;
case svt_mobj:
// return the class name
return (const char *)v.value.mobj->GetClass()->TypeName;
case svt_fixed:
{
double val = v.value.f / 65536.;
mysnprintf(buffer, countof(buffer), "%g", val);
return buffer;
}
case svt_int:
default:
mysnprintf(buffer, countof(buffer), "%i", v.value.i);
return buffer;
}
}
const char *FBaseCVar::ToString (UCVarValue value, ECVarType type)
{
switch (type)
{
case CVAR_Bool:
return value.Bool ? truestr : falsestr;
case CVAR_String:
return value.String;
case CVAR_Int:
mysnprintf (cstrbuf, countof(cstrbuf), "%i", value.Int);
break;
case CVAR_Float:
mysnprintf (cstrbuf, countof(cstrbuf), "%g", value.Float);
break;
case CVAR_GUID:
FormatGUID (cstrbuf, countof(cstrbuf), *value.pGUID);
break;
default:
strcpy (cstrbuf, "<huh?>");
break;
}
return cstrbuf;
}
void VMDumpConstants(FILE *out, const VMScriptFunction *func)
{
char tmp[21];
int i, j, k, kk;
if (func->KonstD != NULL && func->NumKonstD != 0)
{
printf_wrapper(out, "\nConstant integers:\n");
kk = (func->NumKonstD + 3) / 4;
for (i = 0; i < kk; ++i)
{
for (j = 0, k = i; j < 4 && k < func->NumKonstD; j++, k += kk)
{
mysnprintf(tmp, countof(tmp), "%3d. %d", k, func->KonstD[k]);
printf_wrapper(out, "%-20s", tmp);
}
printf_wrapper(out, "\n");
}
}
if (func->KonstF != NULL && func->NumKonstF != 0)
{
printf_wrapper(out, "\nConstant floats:\n");
kk = (func->NumKonstF + 3) / 4;
for (i = 0; i < kk; ++i)
{
for (j = 0, k = i; j < 4 && k < func->NumKonstF; j++, k += kk)
{
mysnprintf(tmp, countof(tmp), "%3d. %.16f", k, func->KonstF[k]);
printf_wrapper(out, "%-20s", tmp);
}
printf_wrapper(out, "\n");
}
}
if (func->KonstA != NULL && func->NumKonstA != 0)
{
printf_wrapper(out, "\nConstant addresses:\n");
kk = (func->NumKonstA + 3) / 4;
for (i = 0; i < kk; ++i)
{
for (j = 0, k = i; j < 4 && k < func->NumKonstA; j++, k += kk)
{
mysnprintf(tmp, countof(tmp), "%3d. %p:%d", k, func->KonstA[k].v, func->KonstATags()[k]);
printf_wrapper(out, "%-20s", tmp);
}
printf_wrapper(out, "\n");
}
}
if (func->KonstS != NULL && func->NumKonstS != 0)
{
printf_wrapper(out, "\nConstant strings:\n");
for (i = 0; i < func->NumKonstS; ++i)
{
printf_wrapper(out, "%3d. %s\n", i, func->KonstS[i].GetChars());
}
}
}
static void DrawCoordinates(player_t * CPlayer)
{
DVector3 pos;
char coordstr[18];
int h = SmallFont->GetHeight()+1;
if (!map_point_coordinates || !automapactive)
{
pos = CPlayer->mo->Pos();
}
else
{
DVector2 apos = AM_GetPosition();
double z = P_PointInSector(apos)->floorplane.ZatPoint(apos);
pos = DVector3(apos, z);
}
int vwidth, vheight;
if (active_con_scaletext() == 0)
{
vwidth = SCREENWIDTH / 2;
vheight = SCREENHEIGHT / 2;
}
else
{
vwidth = SCREENWIDTH / active_con_scaletext();
vheight = SCREENHEIGHT / active_con_scaletext();
}
int xpos = vwidth - SmallFont->StringWidth("X: -00000")-6;
int ypos = 18;
screen->DrawText(SmallFont, hudcolor_titl, vwidth - 6 - SmallFont->StringWidth(level.MapName), ypos, level.MapName,
DTA_KeepRatio, true,
DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);
screen->DrawText(SmallFont, hudcolor_titl, vwidth - 6 - SmallFont->StringWidth(level.LevelName), ypos + h, level.LevelName,
DTA_KeepRatio, true,
DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);
mysnprintf(coordstr, countof(coordstr), "X: %d", int(pos.X));
screen->DrawText(SmallFont, hudcolor_xyco, xpos, ypos+2*h, coordstr,
DTA_KeepRatio, true,
DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);
mysnprintf(coordstr, countof(coordstr), "Y: %d", int(pos.Y));
screen->DrawText(SmallFont, hudcolor_xyco, xpos, ypos+3*h, coordstr,
DTA_KeepRatio, true,
DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);
mysnprintf(coordstr, countof(coordstr), "Z: %d", int(pos.Z));
screen->DrawText(SmallFont, hudcolor_xyco, xpos, ypos+4*h, coordstr,
DTA_KeepRatio, true,
DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);
}
static void OpenExprType(FLispString &out, EZCCExprType type)
{
char buf[32];
if (unsigned(type) < PEX_COUNT_OF)
{
mysnprintf(buf, countof(buf), "expr %d", type);
}
else
{
mysnprintf(buf, countof(buf), "bad-pex-%u", type);
}
out.Open(buf);
}
void AddInt(int i, bool un=false)
{
char buf[16];
size_t len;
if (!un)
{
len = mysnprintf(buf, countof(buf), "%d", i);
}
else
{
len = mysnprintf(buf, countof(buf), "%uu", i);
}
Add(buf, len);
}
static void example_read_html(
struct arena* win, struct style* sty,
struct actor* act, struct pinid* pin)
{
int len = win->len;
u8* buf = win->buf;
len += mysnprintf(
buf+len, 0x100000-len,
"<div id=\"example\" style=\"width:50%%;height:100px;float:left;background-color:#82a977;\">"
);
len += mysnprintf(buf+len, 0x100000-len, "</div>\n");
win->len = len;
}
// Like DoGameSetup(), but for mod-specific cvars.
// Called after CVARINFO has been parsed.
void FGameConfigFile::DoModSetup(const char *gamename)
{
mysnprintf(section, countof(section), "%s.Player.Mod", gamename);
if (SetSection(section))
{
ReadCVars(CVAR_MOD|CVAR_USERINFO|CVAR_IGNORE);
}
mysnprintf(section, countof(section), "%s.LocalServerInfo.Mod", gamename);
if (SetSection (section))
{
ReadCVars (CVAR_MOD|CVAR_SERVERINFO|CVAR_IGNORE);
}
// Signal that these sections should be rewritten when saving the config.
bModSetup = true;
}
FString level_info_t::LookupLevelName()
{
if (flags & LEVEL_LOOKUPLEVELNAME)
{
const char *thename;
const char *lookedup;
lookedup = GStrings[LevelName];
if (lookedup == NULL)
{
thename = LevelName;
}
else
{
char checkstring[32];
// Strip out the header from the localized string
if (MapName.Len() > 3 && MapName[0] == 'E' && MapName[2] == 'M')
{
mysnprintf (checkstring, countof(checkstring), "%s: ", MapName.GetChars());
}
else if (MapName.Len() > 3 && MapName[0] == 'M' && MapName[1] == 'A' && MapName[2] == 'P')
{
mysnprintf (checkstring, countof(checkstring), "%d: ", atoi(&MapName[3]));
}
else if (MapName.Len() > 5 && MapName[0] == 'L' && MapName[1] == 'E' && MapName[2] == 'V' && MapName[3] == 'E' && MapName[4] == 'L')
{
mysnprintf (checkstring, countof(checkstring), "%d: ", atoi(&MapName[5]));
}
else
{
// make sure nothing is stripped.
checkstring[0] = '\0';
}
thename = strstr (lookedup, checkstring);
if (thename == NULL)
{
thename = lookedup;
}
else
{
thename += strlen (checkstring);
}
}
return thename;
}
else return LevelName;
}
// Moved from DoGameSetup so that it can happen after wads are loaded
void FGameConfigFile::DoKeySetup(const char *gamename)
{
static const struct { const char *label; FKeyBindings *bindings; } binders[] =
{
{ "Bindings", &Bindings },
{ "DoubleBindings", &DoubleBindings },
{ "AutomapBindings", &AutomapBindings },
{ NULL, NULL }
};
const char *key, *value;
sublen = countof(section) - 1 - mysnprintf(section, countof(section), "%s.", gamename);
subsection = section + countof(section) - sublen - 1;
section[countof(section) - 1] = '\0';
C_SetDefaultBindings ();
for (int i = 0; binders[i].label != NULL; ++i)
{
strncpy(subsection, binders[i].label, sublen);
if (SetSection(section))
{
FKeyBindings *bindings = binders[i].bindings;
bindings->UnbindAll();
while (NextInSection(key, value))
{
bindings->DoBind(key, value);
}
}
}
}
static char* format_delay(ptpdt_t *dt, char *ptr, uint32_t sz)
{
if(dt->s)
{
ptr += mysnprintf(ptr, sz, "%d", dt->s);
*ptr++ = 's';
}
else
{
ptr += mysnprintf(ptr, sz, "%d", dt->ns);
*ptr++ = 'n';
*ptr++ = 's';
}
*ptr = 0;
return ptr;
}
int bd_send_button_text(const struct board_t *board, int button, const char *text) {
char buffer[BUFFER_SIZE];
int len = mysnprintf(buffer, BUFFER_SIZE, "#T%1.1x:%s" CRLF, button & 0xf, text);
if (bd_send_command(board, buffer, len, BUFFER_SIZE) > 0)
return is_ok(buffer);
return -1;
}
int bd_send_button_states(const struct board_t *board, int button) {
char buffer[BUFFER_SIZE];
int len = mysnprintf(buffer, BUFFER_SIZE, "#C%2.2x" CRLF, button & 0xff);
if (bd_send_command(board, buffer, len, BUFFER_SIZE) > 0)
return is_ok(buffer);
return -1;
}
int bd_send_line(const struct board_t *board, int line, const char* str) {
char buffer[BUFFER_SIZE];
int len = mysnprintf(buffer, BUFFER_SIZE, "#L%2.2x:%s" CRLF, line, str);
if (bd_send_command(board, buffer, len, BUFFER_SIZE) > 0 )
return is_ok(buffer);
return -1;
}
int bd_disconnect(const struct board_t *board) {
char buffer[BUFFER_SIZE];
int len = mysnprintf(buffer, BUFFER_SIZE, "#Q" CRLF);
int res = bd_send_command(board, buffer, len, BUFFER_SIZE);
close(board->socket);
return res == 0;
}
void FGameConfigFile::AddAutoexec (FArgs *list, const char *game)
{
char section[64];
const char *key;
const char *value;
mysnprintf (section, countof(section), "%s.AutoExec", game);
// If <game>.AutoExec section does not exist, create it
// with a default autoexec.cfg file present.
CreateStandardAutoExec(section, false);
// Run any files listed in the <game>.AutoExec section
if (!SectionIsEmpty())
{
while (NextInSection (key, value))
{
if (stricmp (key, "Path") == 0 && *value != '\0')
{
FString expanded_path = ExpandEnvVars(value);
if (FileExists(expanded_path))
{
list->AppendArg (ExpandEnvVars(value));
}
}
}
}
}
UCVarValue FBaseCVar::FromFloat (float value, ECVarType type)
{
UCVarValue ret;
switch (type)
{
case CVAR_Bool:
ret.Bool = value != 0.f;
break;
case CVAR_Int:
ret.Int = (int)value;
break;
case CVAR_Float:
ret.Float = value;
break;
case CVAR_String:
mysnprintf (cstrbuf, countof(cstrbuf), "%g", value);
ret.String = cstrbuf;
break;
case CVAR_GUID:
ret.pGUID = NULL;
break;
default:
break;
}
return ret;
}
static void DrawHudNumber(FFont *font, int color, int num, int x, int y, int trans=0xc000)
{
char text[15];
mysnprintf(text, countof(text), "%d", num);
DrawHudText(font, color, text, x, y, trans);
}
/* write the current process id to the specified file */
static void create_pidfile(const char *filename)
{
int fd;
char buffer[20];
if (filename != NULL)
{
mkdirname(filename);
if ((fd = open(filename, O_RDWR | O_CREAT, 0644)) < 0)
{
log_log(LOG_ERR, "cannot create pid file (%s): %s",
filename, strerror(errno));
exit(EXIT_FAILURE);
}
if (lockf(fd, F_TLOCK, 0) < 0)
{
log_log(LOG_ERR, "cannot lock pid file (%s): %s",
filename, strerror(errno));
exit(EXIT_FAILURE);
}
if (ftruncate(fd, 0) < 0)
{
log_log(LOG_ERR, "cannot truncate pid file (%s): %s",
filename, strerror(errno));
exit(EXIT_FAILURE);
}
mysnprintf(buffer, sizeof(buffer), "%d\n", (int)getpid());
if (write(fd, buffer, strlen(buffer)) != (int)strlen(buffer))
{
log_log(LOG_ERR, "error writing pid file (%s): %s",
filename, strerror(errno));
exit(EXIT_FAILURE);
}
/* we keep the pidfile open so the lock remains valid */
}
}
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_GiveQuestItem)
{
ACTION_PARAM_START(1);
ACTION_PARAM_INT(questitem, 0);
// Give one of these quest items to every player in the game
for (int i = 0; i < MAXPLAYERS; ++i)
{
if (playeringame[i])
{
AInventory *item = static_cast<AInventory *>(Spawn (QuestItemClasses[questitem-1], 0,0,0, NO_REPLACE));
if (!item->CallTryPickup (players[i].mo))
{
item->Destroy ();
}
}
}
char messageid[64];
mysnprintf(messageid, countof(messageid), "TXT_QUEST_%d", questitem);
const char * name = GStrings[messageid];
if (name != NULL)
{
C_MidPrint (SmallFont, name);
}
}
void D_UserInfoChanged (FBaseCVar *cvar)
{
UCVarValue val;
FString escaped_val;
char foo[256];
if (cvar == &autoaim)
{
if (autoaim < 0.0f)
{
autoaim = 0.0f;
return;
}
else if (autoaim > 5000.0f)
{
autoaim = 5000.f;
return;
}
}
val = cvar->GetGenericRep (CVAR_String);
escaped_val = D_EscapeUserInfo(val.String);
if (4 + strlen(cvar->GetName()) + escaped_val.Len() > 256)
I_Error ("User info descriptor too big");
mysnprintf (foo, countof(foo), "\\%s\\%s", cvar->GetName(), escaped_val.GetChars());
Net_WriteByte (DEM_UINFCHANGED);
Net_WriteString (foo);
}
void FGameConfigFile::DoGameSetup (const char *gamename)
{
const char *key;
const char *value;
sublen = countof(section) - 1 - mysnprintf (section, countof(section), "%s.", gamename);
subsection = section + countof(section) - sublen - 1;
section[countof(section) - 1] = '\0';
strncpy (subsection, "UnknownConsoleVariables", sublen);
if (SetSection (section))
{
ReadCVars (0);
}
strncpy (subsection, "ConsoleVariables", sublen);
if (SetSection (section))
{
ReadCVars (0);
}
if (gameinfo.gametype & GAME_Raven)
{
SetRavenDefaults (gameinfo.gametype == GAME_Hexen);
}
// The NetServerInfo section will be read and override anything loaded
// here when it's determined that a netgame is being played.
strncpy (subsection, "LocalServerInfo", sublen);
if (SetSection (section))
{
ReadCVars (0);
}
strncpy (subsection, "Player", sublen);
if (SetSection (section))
{
ReadCVars (0);
}
strncpy (subsection, "ConsoleAliases", sublen);
if (SetSection (section))
{
const char *name = NULL;
while (NextInSection (key, value))
{
if (stricmp (key, "Name") == 0)
{
name = value;
}
else if (stricmp (key, "Command") == 0 && name != NULL)
{
C_SetAlias (name, value);
name = NULL;
}
}
}
OkayToWrite = true;
}
void RenderViewport::SetViewport(FLevelLocals *Level, RenderThread *thread, int fullWidth, int fullHeight, float trueratio)
{
int virtheight, virtwidth, virtwidth2, virtheight2;
if (!RenderingToCanvas)
{ // Set r_viewsize cvar to reflect the current view size
UCVarValue value;
char temp[16];
mysnprintf(temp, countof(temp), "%d x %d", viewwidth, viewheight);
value.String = temp;
r_viewsize.ForceSet(value, CVAR_String);
}
fuzzviewheight = viewheight - 2; // Maximum row the fuzzer can draw to
CenterX = viewwindow.centerx;
CenterY = viewwindow.centery;
virtwidth = virtwidth2 = fullWidth;
virtheight = virtheight2 = fullHeight;
if (AspectTallerThanWide(trueratio))
{
virtheight2 = virtheight2 * AspectMultiplier(trueratio) / 48;
}
else
{
virtwidth2 = virtwidth2 * AspectMultiplier(trueratio) / 48;
}
if (AspectTallerThanWide(viewwindow.WidescreenRatio))
{
virtheight = virtheight * AspectMultiplier(viewwindow.WidescreenRatio) / 48;
}
else
{
virtwidth = virtwidth * AspectMultiplier(viewwindow.WidescreenRatio) / 48;
}
double ypixelstretch = (Level->info) ? Level->info->pixelstretch : 1.2;
BaseYaspectMul = 320.0 * virtheight2 / (r_Yaspect * virtwidth2);
YaspectMul = 320.0 * virtheight / (r_Yaspect * virtwidth) * ypixelstretch / 1.2;
IYaspectMul = (double)virtwidth * r_Yaspect / 320.0 / virtheight;
InvZtoScale = YaspectMul * CenterX;
WallTMapScale2 = IYaspectMul / CenterX * 1.2 / ypixelstretch;
// thing clipping
fillshort(screenheightarray, viewwidth, (short)viewheight);
InitTextureMapping();
// Reset r_*Visibility vars
thread->Light->SetVisibility(this, r_visibility, !!(Level->flags3 & LEVEL3_NOLIGHTFADE));
SetupBuffer();
}
static bool Cht_ChangeStartSpot (cheatseq_t *cheat)
{
char cmd[64];
mysnprintf (cmd, countof(cmd), "changemap %s %c", level.mapname, cheat->Args[0]);
C_DoCommand (cmd);
return true;
}
const char *FFloatCVar::GetHumanString(int precision) const
{
if (precision < 0)
{
precision = 6;
}
mysnprintf(cstrbuf, countof(cstrbuf), "%.*g", precision, Value);
return cstrbuf;
}
void FormatGUID (char *buffer, size_t buffsize, const GUID &guid)
{
mysnprintf (buffer, buffsize, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
(uint32)guid.Data1, guid.Data2, guid.Data3,
guid.Data4[0], guid.Data4[1],
guid.Data4[2], guid.Data4[3],
guid.Data4[4], guid.Data4[5],
guid.Data4[6], guid.Data4[7]);
}
int bd_read_key(const struct board_t *board) {
char buffer[BUFFER_SIZE];
int len = mysnprintf(buffer, BUFFER_SIZE, "#K" CRLF);
if (bd_send_command(board, buffer, len, BUFFER_SIZE) > 0 && is_ok(buffer)) {
if (buffer[3] != ':')
return 0;
return strtol(buffer + 4, NULL, 16);
}
return -1;
}
static FStringProd *DoubleToString (FProduction *prod)
{
char buf[128];
FStringProd *newprod;
mysnprintf (buf, countof(buf), "%g", static_cast<FDoubleProd *>(prod)->Value);
newprod = NewStringProd (buf);
M_Free (prod);
return newprod;
}
static const char *KeyName (int key)
{
static char name[5];
if (KeyNames[key])
return KeyNames[key];
mysnprintf (name, countof(name), "#%d", key);
return name;
}
static int mkfilter_rpc_byname(const char *name, char *buffer, size_t buflen)
{
char safename[BUFLEN_SAFENAME];
/* escape attribute */
if (myldap_escape(name, safename, sizeof(safename)))
return -1;
/* build filter */
return mysnprintf(buffer, buflen, "(&%s(%s=%s))",
rpc_filter, attmap_rpc_cn, safename);
}
