static void entremove(localentity_t *e)
{
int i;
- i = (e - localentity) / sizeof(localentity_t);
+ i = (int)((e - localentity) / sizeof(localentity_t));
if (i < 0 || i >= MAX_LOCALENTITIES)
return; // this should be an error
//memset(e, 0, sizeof(*e));
VectorCopy(cl.mviewangles[0], cl.mviewangles[1]);
for (i = 0;i < 3;i++)
{
- r = FS_Read(cls.demofile, &f, 4);
+ r = (int)FS_Read(cls.demofile, &f, 4);
cl.mviewangles[0][i] = LittleFloat(f);
}
strlcpy (name, ent->render.model->name, 25);
else
strcpy(name, "--no model--");
- for (j = strlen(name);j < 25;j++)
+ for (j = (int)strlen(name);j < 25;j++)
name[j] = ' ';
Con_Printf("%3i: %s:%4i (%5i %5i %5i) [%3i %3i %3i] %4.2f %5.3f\n", i, name, ent->render.frame, (int) ent->render.origin[0], (int) ent->render.origin[1], (int) ent->render.origin[2], (int) ent->render.angles[0] % 360, (int) ent->render.angles[1] % 360, (int) ent->render.angles[2] % 360, ent->render.scale, ent->render.alpha);
}
Host_Error ("svc_lightstyle >= MAX_LIGHTSTYLES");
strlcpy (cl_lightstyle[i].map, MSG_ReadString(), sizeof (cl_lightstyle[i].map));
cl_lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
- cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
+ cl_lightstyle[i].length = (int)strlen(cl_lightstyle[i].map);
break;
case svc_sound:
{1.0, 1.0, 1.0, 1.0}, // white
// [515]'s BX_COLOREDTEXT extension
{1.0, 1.0, 1.0, 0.5}, // half transparent
- {0.5, 0.5, 0.5, 1.0} // half brightness
+ {0.5, 0.5, 0.5, 1.0} // half brightness
// Black's color table
//{1.0, 1.0, 1.0, 1.0},
//{1.0, 0.0, 0.0, 1.0},
color = string_colors[colorindex];
if( maxlen < 1)
- len = strlen( text );
+ len = (int)strlen( text );
else
- len = min( maxlen, (signed) strlen( text ) );
+ len = min( maxlen, (int) strlen( text ) );
start = current = text;
while( len > 0 ) {
} while( len > 0 && '0' <= *current && *current <= '9' );
// set the color
color = string_colors[colorindex];
- // we jump over the color tag
+ // we jump over the color tag
start = current;
}
}
t = (int) ((r_timereport_current - r_timereport_temp) * 1000000.0);
dpsnprintf(tempbuf, sizeof(tempbuf), "%8i %s", t, desc);
- length = strlen(tempbuf);
+ length = (int)strlen(tempbuf);
while (length < 20)
tempbuf[length++] = ' ';
tempbuf[length] = 0;
if (alpha < (1.0f / 255.0f))
return;
if (maxlen < 1)
- len = strlen(string);
+ len = (int)strlen(string);
else
for (len = 0;len < maxlen && string[len];len++);
for (;len > 0 && string[0] == ' ';string++, x += scalex, len--);
{
int l;
- l = strlen (text);
+ l = (int)strlen (text);
if (cmd_text.cursize + l >= cmd_text.maxsize)
{
return;
}
- SZ_Write (&cmd_text, text, strlen (text));
+ SZ_Write (&cmd_text, text, (int)strlen (text));
}
if (Cmd_Argc() > 1)
{
partial = Cmd_Argv (1);
- len = strlen(partial);
+ len = (int)strlen(partial);
}
else
{
if (cmd_argc < MAX_ARGS)
{
- l = strlen(com_token) + 1;
+ l = (int)strlen(com_token) + 1;
if (cmd_tokenizebufferpos + l > CMD_TOKENIZELENGTH)
{
Con_Printf("Cmd_TokenizeString: ran out of %i character buffer space for command arguements\n", CMD_TOKENIZELENGTH);
const char *Cmd_CompleteCommand (const char *partial)
{
cmd_function_t *cmd;
- int len;
+ size_t len;
len = strlen(partial);
int Cmd_CompleteCountPossible (const char *partial)
{
cmd_function_t *cmd;
- int len, h;
+ size_t len;
+ int h;
h = 0;
len = strlen(partial);
const char **Cmd_CompleteBuildList (const char *partial)
{
cmd_function_t *cmd;
- int len = 0;
- int bpos = 0;
- int sizeofbuf = (Cmd_CompleteCountPossible (partial) + 1) * sizeof (const char *);
+ size_t len = 0;
+ size_t bpos = 0;
+ size_t sizeofbuf = (Cmd_CompleteCountPossible (partial) + 1) * sizeof (const char *);
const char **buf;
len = strlen(partial);
const char *Cmd_CompleteAlias (const char *partial)
{
cmdalias_t *alias;
- int len;
+ size_t len;
len = strlen(partial);
int Cmd_CompleteAliasCountPossible (const char *partial)
{
cmdalias_t *alias;
- int len;
+ size_t len;
int h;
h = 0;
const char **Cmd_CompleteAliasBuildList (const char *partial)
{
cmdalias_t *alias;
- int len = 0;
- int bpos = 0;
- int sizeofbuf = (Cmd_CompleteAliasCountPossible (partial) + 1) * sizeof (const char *);
+ size_t len = 0;
+ size_t bpos = 0;
+ size_t sizeofbuf = (Cmd_CompleteAliasCountPossible (partial) + 1) * sizeof (const char *);
const char **buf;
len = strlen(partial);
// attention, it has been eradicated from here, its only (former) use in
// all of darkplaces.
MSG_WriteByte(&cls.message, clc_stringcmd);
- SZ_Write(&cls.message, s, strlen(s) + 1);
+ SZ_Write(&cls.message, s, (int)strlen(s) + 1);
}
/*
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};
-unsigned short CRC_Block(const qbyte *data, int size)
+unsigned short CRC_Block(const qbyte *data, size_t size)
{
unsigned short crc = CRC_INIT_VALUE;
while (size--)
if (!s)
SZ_Write (sb, "", 1);
else
- SZ_Write (sb, s, strlen(s)+1);
+ SZ_Write (sb, s, (int)strlen(s)+1);
}
void MSG_WriteCoord13i (sizebuf_t *sb, float f)
l = *text;
commentprefixlength = 0;
if (commentprefix)
- commentprefixlength = strlen(commentprefix);
+ commentprefixlength = (int)strlen(commentprefix);
while (*l && *l != '\n' && *l != '\r')
{
if (*l > ' ')
void Com_HexDumpToConsole(const qbyte *data, int size);
-unsigned short CRC_Block(const qbyte *data, int size);
+unsigned short CRC_Block(const qbyte *data, size_t size);
//============================================================================
// If we need to enlarge the log queue
if (len > remain)
{
- unsigned int factor = ((logq_ind + len) / logq_size) + 1;
+ size_t factor = ((logq_ind + len) / logq_size) + 1;
qbyte* newqueue;
logq_size *= factor;
// use strlen of edit_line instead of key_linepos to allow editing
// of early characters w/o erasing
- y = strlen(text);
+ y = (int)strlen(text);
// fill out remainder with spaces
for (i = y; i < 256; i++)
const char **walk = list;
while (*walk) {
- len = strlen(*walk);
+ len = (int)strlen(*walk);
if (len > maxlen)
maxlen = len;
walk++;
maxlen += 1;
while (*list) {
- len = strlen(*list);
+ len = (int)strlen(*list);
if (pos + maxlen >= width) {
Con_Print("\n");
pos = 0;
else
list[0] = Cmd_CompleteAliasBuildList(s);
cmd = *list[0];
- cmd_len = strlen (cmd);
+ cmd_len = (int)strlen (cmd);
} else {
if (c)
cmd = *(list[0] = Cmd_CompleteBuildList(s));
if (a)
cmd = *(list[2] = Cmd_CompleteAliasBuildList(s));
- cmd_len = strlen (s);
+ cmd_len = (int)strlen (s);
do {
for (i = 0; i < 3; i++) {
char ch = cmd[cmd_len];
const char *Cvar_CompleteVariable (const char *partial)
{
cvar_t *cvar;
- int len;
+ size_t len;
len = strlen(partial);
int Cvar_CompleteCountPossible (const char *partial)
{
cvar_t *cvar;
- int len;
+ size_t len;
int h;
h = 0;
const char **Cvar_CompleteBuildList (const char *partial)
{
const cvar_t *cvar;
- int len = 0;
- int bpos = 0;
- int sizeofbuf = (Cvar_CompleteCountPossible (partial) + 1) * sizeof (const char *);
+ size_t len = 0;
+ size_t bpos = 0;
+ size_t sizeofbuf = (Cvar_CompleteCountPossible (partial) + 1) * sizeof (const char *);
const char **buf;
len = strlen(partial);
cvar->flags |= flags;
Cvar_SetQuick_Internal (cvar, value);
// also set the default value (but only once)
- if (~cvar->flags & CVAR_DEFAULTSET)
+ if (~cvar->flags & CVAR_DEFAULTSET)
{
cvar->flags |= CVAR_DEFAULTSET;
{
cvar_t *cvar;
const char *partial;
- int len, count;
+ size_t len;
+ int count;
if (Cmd_Argc() > 1)
{
mempool_t *fs_mempool;
-int fs_filesize;
+size_t fs_filesize;
pack_t *packlist = NULL;
{
qbyte *central_dir, *ptr;
unsigned int ind;
- int remaining;
+ size_t remaining;
// Load the central directory in memory
central_dir = Mem_Alloc (tempmempool, eocd->cdir_size);
if ((ptr[8] & 0x29) == 0 && (ptr[38] & 0x18) == 0)
{
// Still enough bytes for the name?
- if ((size_t) remaining < namesize || namesize >= sizeof (*pack->files))
+ if (remaining < namesize || namesize >= sizeof (*pack->files))
{
Mem_Free (central_dir);
return -1;
if (i && i < com_argc-1)
{
strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
- i = strlen (fs_basedir);
+ i = (int)strlen (fs_basedir);
if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
fs_basedir[i-1] = 0;
}
pfile = &pack->files[pack_ind];
- fs_filesize = -1;
+ fs_filesize = 0;
// If we don't have the true offset, get it now
if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
// Not found?
if (search == NULL)
{
- fs_filesize = -1;
+ fs_filesize = 0;
return NULL;
}
}
ztk->zstream.next_in = &ztk->input[ztk->in_ind];
- ztk->zstream.avail_in = ztk->in_len - ztk->in_ind;
+ ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
// Now that we are sure we have compressed data available, we need to determine
// if it's better to inflate it in "file->buff" or directly in "buffer"
else
{
ztk->zstream.next_out = &((qbyte*)buffer)[done];
- ztk->zstream.avail_out = buffersize;
+ ztk->zstream.avail_out = (unsigned int)buffersize;
error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
if (error != Z_OK && error != Z_STREAM_END)
{
switch (whence)
{
case SEEK_CUR:
- offset += file->position - file->buff_len + file->buff_ind;
+ offset += (long)(file->position - file->buff_len + file->buff_ind);
break;
case SEEK_SET:
break;
case SEEK_END:
- offset += file->real_length;
+ offset += (long)file->real_length;
break;
default:
Give the current position in a file
====================
*/
-long FS_Tell (qfile_t* file)
+size_t FS_Tell (qfile_t* file)
{
return file->position - file->buff_len + file->buff_ind;
}
fssearch_t *search;
searchpath_t *searchpath;
pack_t *pak;
- int i, basepathlength, numfiles, numchars;
+ size_t i, basepathlength, numfiles, numchars;
stringlist_t *dir, *dirfile, *liststart, *listcurrent, *listtemp;
const char *slash, *backslash, *colon, *separator;
char *basepath;
extern int con_linewidth;
int FS_ListDirectory(const char *pattern, int oneperline)
{
- int numfiles;
- int numcolumns;
- int numlines;
- int columnwidth;
- int linebufpos;
- int i, j, k, l;
+ size_t numfiles;
+ size_t numcolumns;
+ size_t numlines;
+ size_t columnwidth;
+ size_t linebufpos;
+ size_t i, j, k, l;
const char *name;
char linebuf[4096];
fssearch_t *search;
if (l < numfiles)
{
name = search->filenames[l];
- for (j = 0;name[j] && j < (int)sizeof(linebuf) - 1;j++)
+ for (j = 0;name[j] && linebufpos + 1 < sizeof(linebuf);j++)
linebuf[linebufpos++] = name[j];
// space out name unless it's the last on the line
- if (k < (numcolumns - 1) && l < (numfiles - 1))
- for (;j < columnwidth && j < (int)sizeof(linebuf) - 1;j++)
+ if (k + 1 < numcolumns && l + 1 < numfiles)
+ for (;j < columnwidth && linebufpos + 1 < sizeof(linebuf);j++)
linebuf[linebufpos++] = ' ';
}
}
extern char fs_gamedir [MAX_OSPATH];
extern char fs_basedir [MAX_OSPATH];
-extern int fs_filesize; // set by FS_Open (in "read" mode) and FS_LoadFile
+extern size_t fs_filesize; // set by FS_Open (in "read" mode) and FS_LoadFile
// ------ Main functions ------ //
int FS_Getc (qfile_t* file);
int FS_UnGetc (qfile_t* file, unsigned char c);
int FS_Seek (qfile_t* file, long offset, int whence);
-long FS_Tell (qfile_t* file);
+size_t FS_Tell (qfile_t* file);
void FS_Purge (qfile_t* file);
typedef struct fssearch_s
if (cl.worldmodel)
{
strlcpy(entname, cl.worldmodel->name, sizeof(entname));
- l = strlen(entname) - 4;
+ l = (int)strlen(entname) - 4;
if (l >= 0 && !strcmp(entname + l, ".bsp"))
{
strcpy(entname + l, ".ent");
void Host_Tell_f(void)
{
client_t *save;
- int j;
+ size_t j;
const char *p1, *p2;
char text[1024]; // LordHavoc: FIXME: temporary buffer overflow fix (was 64)
qboolean fromServer = false;
}
while (p2 > p1 && (p2[-1] == '\n' || p2[-1] == '\r'))
p2--;
- for (j = strlen(text);j < (int)(sizeof(text) - 2) && p1 < p2;)
+ for (j = strlen(text);j < (sizeof(text) - 2) && p1 < p2;)
text[j++] = *p1++;
text[j++] = '\n';
text[j++] = 0;
{
int i;
strtok(cbd, "\n\r\b");
- i = strlen(cbd);
+ i = (int)strlen(cbd);
if (i + key_linepos >= MAX_INPUTLINE)
i= MAX_INPUTLINE - key_linepos;
if (i > 0)
{
history_line--;
strcpy(key_lines[edit_line], key_lines[history_line]);
- key_linepos = strlen(key_lines[edit_line]);
+ key_linepos = (int)strlen(key_lines[edit_line]);
}
return;
}
else
{
strcpy(key_lines[edit_line], key_lines[history_line]);
- key_linepos = strlen(key_lines[edit_line]);
+ key_linepos = (int)strlen(key_lines[edit_line]);
}
return;
}
if (key_linepos < MAX_INPUTLINE-1)
{
int len;
- len = strlen(&key_lines[edit_line][key_linepos]);
+ len = (int)strlen(&key_lines[edit_line][key_linepos]);
// check insert mode, or always insert if at end of line
if (key_insert || len == 0)
{
void
Key_SetBinding (int keynum, int bindmap, const char *binding)
{
- char *new;
- int l;
+ char *new;
+ size_t l;
if (keynum == -1)
return;
void M_ScanSaves (void)
{
- int i, j, len;
+ size_t i, j, len;
char name[MAX_OSPATH];
char buf[SAVEGAME_COMMENT_LENGTH + 256];
const char *t;
{
strcpy (m_filenames[i], "--- UNUSED SLOT ---");
loadable[i] = false;
- sprintf (name, "s%i.sav", i);
+ sprintf (name, "s%i.sav", (int)i);
f = FS_Open (name, "rb", false, false);
if (!f)
continue;
break;
if (setup_cursor == 0)
{
- l = strlen(setup_myname);
+ l = (int)strlen(setup_myname);
if (l < 15)
{
setup_myname[l+1] = 0;
{
DrawQ_Fill(menu_x, menu_y + opty, 320, 8, optnum == optcursor ? (0.5 + 0.2 * sin(realtime * M_PI)) : 0, 0, 0, 0.5, 0);
M_ItemPrint(0, opty, s, enabled);
- M_DrawCheckbox(0 + strlen(s) * 8 + 8, opty, yes);
+ M_DrawCheckbox(0 + (int)strlen(s) * 8 + 8, opty, yes);
}
opty += 8;
optnum++;
{
DrawQ_Fill(menu_x, menu_y + opty, 320, 8, optnum == optcursor ? (0.5 + 0.2 * sin(realtime * M_PI)) : 0, 0, 0, 0.5, 0);
M_ItemPrint(0, opty, s, enabled);
- M_DrawSlider(0 + strlen(s) * 8 + 8, opty, value, minvalue, maxvalue);
+ M_DrawSlider(0 + (int)strlen(s) * 8 + 8, opty, value, minvalue, maxvalue);
}
opty += 8;
optnum++;
int i, l, linelength, firstline, lastline, lines;
for (i = 0, linelength = 0, firstline = 9999, lastline = -1;m_quit_message[i];i++)
{
- if ((l = strlen(m_quit_message[i])))
+ if ((l = (int)strlen(m_quit_message[i])))
{
if (firstline > i)
firstline = i;
if (lanConfig_cursor == 2)
{
- l = strlen(lanConfig_joinname);
+ l = (int)strlen(lanConfig_joinname);
if (l < 21)
{
lanConfig_joinname[l+1] = 0;
break;
if (lanConfig_cursor == 0)
{
- l = strlen(lanConfig_portname);
+ l = (int)strlen(lanConfig_portname);
if (l < 5)
{
lanConfig_portname[l+1] = 0;
case K_BACKSPACE:
if (gameoptions_cursor == 9)
{
- l = strlen(hostname.string);
+ l = (int)strlen(hostname.string);
if (l)
{
l = min(l - 1, 37);
break;
if (gameoptions_cursor == 9)
{
- l = strlen(hostname.string);
+ l = (int)strlen(hostname.string);
if (l < 37)
{
memcpy(hostnamebuf, hostname.string, l);
int NetConn_WriteString(lhnetsocket_t *mysocket, const char *string, const lhnetaddress_t *peeraddress)
{
// note this does not include the trailing NULL because we add that in the parser
- return NetConn_Write(mysocket, string, strlen(string), peeraddress);
+ return NetConn_Write(mysocket, string, (int)strlen(string), peeraddress);
}
int NetConn_SendReliableMessage(netconn_t *conn, sizebuf_t *data)
Con_Printf("Server failed to open socket on address %s\n", addressstring2);
}
}
- else
+ else
{
Con_Printf("Server unable to parse address %s\n", addressstring);
// if it cant parse one address, it wont be able to parse another for sure
int left;
ptr = out_msg + length;
- left = out_size - length;
+ left = (int)out_size - length;
for (i = 0;i < (unsigned int)svs.maxclients;i++)
{
const char *PRVM_GetString(int num);
int PRVM_SetEngineString(const char *s);
-int PRVM_AllocString(int bufferlength, char **pointer);
+int PRVM_AllocString(size_t bufferlength, char **pointer);
void PRVM_FreeString(int num);
//============================================================================
// kind of helper function
static qboolean checkextension(const char *name)
{
- int len;
+ size_t len;
char *e, *start;
len = strlen(name);
const string VM_cvar_defstring (string)
========================
*/
-void VM_cvar_defstring (void)
+void VM_cvar_defstring (void)
{
char *out;
const char *name;
//void(float fhandle, string s) fputs = #113; // writes a line of text to the end of the file
void VM_fputs(void)
{
- int stringlength;
+ size_t stringlength;
char string[VM_STRINGTEMP_LENGTH];
int filenum;
char *tokens[256], tokenbuf[4096];
void VM_tokenize (void)
{
- int pos;
+ size_t pos;
const char *p;
VM_SAFEPARMCOUNT(1,VM_tokenize);
char *PRVM_GlobalString (int ofs)
{
char *s;
- int i;
+ size_t i;
ddef_t *def;
void *val;
static char line[128];
char *PRVM_GlobalStringNoContents (int ofs)
{
- int i;
+ size_t i;
ddef_t *def;
static char line[128];
// LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print)
void PRVM_ED_Print(prvm_edict_t *ed)
{
- int l;
+ size_t l;
ddef_t *d;
int *v;
int i, j;
*/
qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
{
- int i, l;
+ size_t i, l;
char *new_p;
ddef_t *def;
prvm_eval_t *val;
case ev_entity:
while (*s && *s <= ' ')
s++;
- i = atoi(s);
- if (i < 0 || i >= prog->limit_edicts)
- Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i) on %s\n", i, MAX_EDICTS, PRVM_NAME);
+ i = (unsigned int)atoi(s);
+ if (i >= prog->limit_edicts)
+ Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, (unsigned int)MAX_EDICTS, PRVM_NAME);
while (i >= prog->max_edicts)
PRVM_MEM_IncreaseEdicts();
//SV_IncreaseEdicts();
qboolean anglehack;
qboolean init;
char keyname[256];
- int n;
+ size_t n;
init = false;
{
if (prog->progs->ofs_strings + prog->stringssize >= fs_filesize)
PRVM_ERROR ("%s: %s strings go past end of file\n", PRVM_NAME, filename);
- prog->stringssize += strlen (prog->strings + prog->stringssize) + 1;
+ prog->stringssize += (int)strlen (prog->strings + prog->stringssize) + 1;
}
prog->numknownstrings = 0;
prog->maxknownstrings = 0;
name = tempstring2;
}
strcat(tempstring, name);
- for (j = strlen(name);j < 25;j++)
+ for (j = (int)strlen(name);j < 25;j++)
strcat(tempstring, " ");
sprintf(tempstring2, "%5d", counts[i]);
strcat(tempstring, tempstring2);
return -1 - i;
}
-int PRVM_AllocString(int bufferlength, char **pointer)
+int PRVM_AllocString(size_t bufferlength, char **pointer)
{
int i;
if (!bufferlength)
*/
void PRVM_PrintStatement (dstatement_t *s)
{
- int i;
-
+ size_t i;
+
if( prog->statement_linenums ) {
int opnum;
void R_Shadow_SaveWorldLights(void)
{
dlight_t *light;
- int bufchars, bufmaxchars;
+ size_t bufchars, bufmaxchars;
char *buf, *oldbuf;
char name[MAX_QPATH];
char line[1024];
// draw level name
if (gamemode == GAME_NEXUIZ) {
- l = strlen (cl.worldmodel->name);
+ l = (int) strlen (cl.worldmodel->name);
Sbar_DrawString (232 - l*4, 12, cl.worldmodel->name);
} else {
- l = strlen (cl.levelname);
+ l = (int) strlen (cl.levelname);
Sbar_DrawString (232 - l*4, 12, cl.levelname);
}
}
// print the text
//DrawQ_String(x, y, va("%c%4i %s", (s - cl.scores) == cl.playerentity - 1 ? 13 : ' ', (int) s->frags, s->name), 0, 8, 8, 1, 1, 1, 1 * sbar_alpha_fg.value, 0);
// FIXME: use a constant for this color tag instead
- DrawQ_ColoredString(x, y, va("%c%4i %s" STRING_COLOR_DEFAULT_STR, (s - cl.scores) == cl.playerentity - 1 ? 13 : ' ', (int) s->frags, s->name), 0, 8, 8, 1, 1, 1, 1 * sbar_alpha_fg.value, 0, NULL );
+ DrawQ_ColoredString(x, y, va("%c%4i %s" STRING_COLOR_DEFAULT_STR, (s - cl.scores) == cl.playerentity - 1 ? 13 : ' ', (int) s->frags, s->name), 0, 8, 8, 1, 1, 1, 1 * sbar_alpha_fg.value, 0, NULL );
return 8;
}
// paint up to end
if (ch->end < end)
- count = ch->end - ltime;
+ count = (int)ch->end - ltime;
else
count = end - ltime;