PSZ Settings :: GetFileEAType( SHORT type = BMF_INVALID )
{
if( type == BMF_INVALID )
type = SHORT( QueryFileFormat() );
if( ( type >= BMF_12 ) && ( type < BMF_INVALID ) )
return ifi[ type ].eaType;
return "";
}
// Draws "Entering <LevelName>"
void WI_drawEL(void)
{
int y = WI_TITLEY;
// draw "Entering"
V_DrawPatch((SCREENWIDTH - SHORT(entering->width))/2,
y,
entering);
// draw level
y += (5*SHORT(lnames[wbs->next]->height))/4;
V_DrawPatch((SCREENWIDTH - SHORT(lnames[wbs->next]->width))/2,
y,
lnames[wbs->next]);
}
//---------------------------------------------------------------------------
void __fastcall TFileViewDlg::TabSChange(TObject *Sender)
{
if( m_DisEvent ) return;
m_DisEvent++;
m_CurFile = -1;
m_CurPage = pTabS->TabIndex;
pCurPage = pFileV[m_CurPage];
UD->Max = SHORT(pCurPage->m_MaxPage-1);
UD->Position = SHORT(pCurPage->m_CurPage);
if( (pCurPage->pList == NULL) || (pCurPage->pBitmapS == NULL) ){
LoadImage();
}
UpdateBitmap();
UpdateStat();
m_DisEvent--;
}
FOURCC Settings :: GetFOURCC( SHORT type = BMF_INVALID )
{
if( type == BMF_INVALID )
type = SHORT( QueryFileFormat() );
if( ( type >= BMF_12 ) && ( type < BMF_INVALID ) )
return ifi[ type ].fourcc;
return 0L;
}
uint16_t
vncrdshort(Vnc *v)
{
uint8_t buf[2];
vncrdbytes(v, buf, 2);
return SHORT(buf);
}
ushort
vncrdshort(Vnc *v)
{
uchar buf[2];
vncrdbytes(v, buf, 2);
return SHORT(buf);
}
void
WI_drawOnLnode
( int n,
patch_t* c[] )
{
int i;
int left;
int top;
int right;
int bottom;
boolean fits = false;
i = 0;
do
{
left = lnodes[wbs->epsd][n].x - SHORT(c[i]->leftoffset);
top = lnodes[wbs->epsd][n].y - SHORT(c[i]->topoffset);
right = left + SHORT(c[i]->width);
bottom = top + SHORT(c[i]->height);
if (left >= 0
&& right < SCREENWIDTH
&& top >= 0
&& bottom < SCREENHEIGHT)
{
fits = true;
}
else
{
i++;
}
} while (!fits && i!=2 && c[i] != NULL);
if (fits && i<2)
{
V_DrawPatch(lnodes[wbs->epsd][n].x,
lnodes[wbs->epsd][n].y,
c[i]);
}
else
{
// DEBUG
printf("Could not place patch on level %d", n+1);
}
}
//
// R_GenerateComposite
// Using the texture definition,
// the composite texture is created from the patches,
// and each column is cached.
//
void R_GenerateComposite (int texnum)
{
byte* block;
texture_t* texture;
texpatch_t* patch;
patch_t* realpatch;
int x;
int x1;
int x2;
int i;
postColumn_t* patchcol;
short* collump;
unsigned short* colofs;
texture = ::g->s_textures[texnum];
block = (byte*)DoomLib::Z_Malloc (::g->s_texturecompositesize[texnum],
PU_CACHE_SHARED,
&::g->s_texturecomposite[texnum]);
collump = ::g->s_texturecolumnlump[texnum];
colofs = ::g->s_texturecolumnofs[texnum];
// Composite the columns together.
patch = texture->patches;
for (i=0 , patch = texture->patches;
i<texture->patchcount;
i++, patch++)
{
realpatch = (patch_t*)W_CacheLumpNum (patch->patch, PU_CACHE_SHARED);
x1 = patch->originx;
x2 = x1 + SHORT(realpatch->width);
if (x1<0)
x = 0;
else
x = x1;
if (x2 > texture->width)
x2 = texture->width;
for ( ; x<x2 ; x++)
{
// Column does not have multiple patches?
if (collump[x] >= 0)
continue;
patchcol = (postColumn_t *)((byte *)realpatch
+ LONG(realpatch->columnofs[x-x1]));
R_DrawColumnInCache (patchcol,
block + colofs[x],
patch->originy,
texture->height);
}
}
}
void WI_drawNetgameStats(void)
{
int i;
int x;
int y;
int pwidth = SHORT(::g->percent->width);
WI_slamBackground();
// draw animated background
WI_drawAnimatedBack();
WI_drawLF();
// draw stat titles (top line)
V_DrawPatch(NG_STATSX+NG_SPACINGX-SHORT(::g->kills->width),
NG_STATSY, FB, ::g->kills);
V_DrawPatch(NG_STATSX+2*NG_SPACINGX-SHORT(::g->items->width),
NG_STATSY, FB, ::g->items);
V_DrawPatch(NG_STATSX+3*NG_SPACINGX-SHORT(::g->secret->width),
NG_STATSY, FB, ::g->secret);
if (::g->dofrags)
V_DrawPatch(NG_STATSX+4*NG_SPACINGX-SHORT(::g->wistuff_frags->width),
NG_STATSY, FB, ::g->wistuff_frags);
// draw stats
y = NG_STATSY + SHORT(::g->kills->height);
for (i=0 ; i<MAXPLAYERS ; i++)
{
if (!::g->playeringame[i])
continue;
x = NG_STATSX;
V_DrawPatch(x-SHORT(::g->wistuff_p[i]->width), y, FB, ::g->wistuff_p[i]);
// No splitscreen on PC
if (i == ::g->me /* && !gameLocal->IsSplitscreen() */ )
V_DrawPatch(x-SHORT(::g->wistuff_p[i]->width), y, FB, ::g->star);
x += NG_SPACINGX;
WI_drawPercent(x-pwidth, y+10, ::g->cnt_kills[i]); x += NG_SPACINGX;
WI_drawPercent(x-pwidth, y+10, ::g->cnt_items[i]); x += NG_SPACINGX;
WI_drawPercent(x-pwidth, y+10, ::g->cnt_secret[i]); x += NG_SPACINGX;
if (::g->dofrags)
WI_drawNum(x, y+10, ::g->cnt_frags[i], -1);
y += WI_SPACINGY;
}
}
/*
==================
=
= V_DrawShadowedPatch
=
= Masks a column based masked pic to the screen.
=
==================
*/
void V_DrawShadowedPatch(int x, int y, patch_t *patch)
{
int count,col;
column_t *column;
byte *desttop, *dest, *source;
byte *desttop2, *dest2;
int w;
y -= SHORT(patch->topoffset);
x -= SHORT(patch->leftoffset);
if (x<0||x+SHORT(patch->width) >SCREENWIDTH || y<0 || y+SHORT(patch->height)>SCREENHEIGHT
)
I_Error ("Bad V_DrawPatch");
col = 0;
desttop = screen+y*SCREENWIDTH+x;
desttop2 = screen+(y+2)*SCREENWIDTH+x+2;
w = SHORT(patch->width);
for ( ; col<w ; x++, col++, desttop++, desttop2++)
{
column = (column_t *)((byte *)patch + LONG(patch->columnofs[col]));
// step through the posts in a column
while (column->topdelta != 0xff )
{
source = (byte *)column + 3;
dest = desttop + column->topdelta*SCREENWIDTH;
dest2 = desttop2 + column->topdelta*SCREENWIDTH;
count = column->length;
while (count--)
{
*dest2 = tinttable[((*dest2)<<8)];
dest2 += SCREENWIDTH;
*dest = *source++;
dest += SCREENWIDTH;
}
column = (column_t *)( (byte *)column + column->length
+ 4 );
}
//
// P_InitSwitchList()
//
// Only called at game initialization in order to list the set of switches
// and buttons known to the engine. This enables their texture to change
// when activated, and in the case of buttons, change back after a timeout.
//
// This routine modified to read its data from a predefined lump or
// PWAD lump called SWITCHES rather than a static table in this module to
// allow wad designers to insert or modify switches.
//
// Lump format is an array of byte packed switchlist_t structures, terminated
// by a structure with episode == -0. The lump can be generated from a
// text source file using SWANTBLS.EXE, distributed with the BOOM utils.
// The standard list of switches and animations is contained in the example
// source text file DEFSWANI.DAT also in the BOOM util distribution.
//
// Rewritten by Lee Killough to remove limit 2/8/98
//
void P_InitSwitchList(void)
{
int i, index = 0;
int episode = (gamemode == registered || gamemode==retail) ?
2 : gamemode == commercial ? 3 : 1;
const switchlist_t *alphSwitchList; //jff 3/23/98 pointer to switch table
int lump = W_GetNumForName("SWITCHES"); // cph - new wad lump handling
//jff 3/23/98 read the switch table from a predefined lump
alphSwitchList = (const switchlist_t *)W_CacheLumpNum(lump);
for (i=0;;i++)
{
if (index+1 >= max_numswitches)
switchlist = realloc(switchlist, sizeof *switchlist *
(max_numswitches = max_numswitches ? max_numswitches*2 : 8));
if (SHORT(alphSwitchList[i].episode) <= episode) //jff 5/11/98 endianess
{
int texture1, texture2;
if (!SHORT(alphSwitchList[i].episode))
break;
// Ignore switches referencing unknown texture names, instead of exiting.
// Warn if either one is missing, but only add if both are valid.
texture1 = R_CheckTextureNumForName(alphSwitchList[i].name1);
if (texture1 == -1)
lprintf(LO_WARN, "P_InitSwitchList: unknown texture %s\n",
alphSwitchList[i].name1);
texture2 = R_CheckTextureNumForName(alphSwitchList[i].name2);
if (texture2 == -1)
lprintf(LO_WARN, "P_InitSwitchList: unknown texture %s\n",
alphSwitchList[i].name2);
if (texture1 != -1 && texture2 != -1) {
switchlist[index++] = texture1;
switchlist[index++] = texture2;
}
}
}
numswitches = index/2;
switchlist[index] = -1;
W_UnlockLumpNum(lump);
}
void WI_drawNetgameStats(void)
{
int i;
int x;
int y;
int pwidth = SHORT(percent->width);
WI_slamBackground();
// draw animated background
WI_drawAnimatedBack();
WI_drawLF();
// draw stat titles (top line)
V_DrawPatch(NG_STATSX+NG_SPACINGX-SHORT(kills->width),
NG_STATSY, FB, kills);
V_DrawPatch(NG_STATSX+2*NG_SPACINGX-SHORT(items->width),
NG_STATSY, FB, items);
V_DrawPatch(NG_STATSX+3*NG_SPACINGX-SHORT(secret->width),
NG_STATSY, FB, secret);
if (dofrags)
V_DrawPatch(NG_STATSX+4*NG_SPACINGX-SHORT(frags->width),
NG_STATSY, FB, frags);
// draw stats
y = NG_STATSY + SHORT(kills->height);
for (i=0 ; i<MAXPLAYERS ; i++)
{
if (!playeringame[i])
continue;
x = NG_STATSX;
V_DrawPatch(x-SHORT(p[i]->width), y, FB, p[i]);
if (i == me)
V_DrawPatch(x-SHORT(p[i]->width), y, FB, star);
x += NG_SPACINGX;
WI_drawPercent(x-pwidth, y+10, cnt_kills[i]); x += NG_SPACINGX;
WI_drawPercent(x-pwidth, y+10, cnt_items[i]); x += NG_SPACINGX;
WI_drawPercent(x-pwidth, y+10, cnt_secret[i]); x += NG_SPACINGX;
if (dofrags)
WI_drawNum(x, y+10, cnt_frags[i], -1);
y += WI_SPACINGY;
}
}
static void F_CastPrint(char *text)
{
const char *ch = text;
int c;
int cx;
int w;
int width = 0;
while (ch)
{
c = *ch++;
if (!c)
break;
c = toupper(c) - HU_FONTSTART;
if (c < 0 || c > HU_FONTSIZE)
{
width += 4;
continue;
}
w = SHORT(hu_font[c]->width);
width += w;
}
// draw it
cx = (ORIGINALWIDTH - width) / 2;
ch = text;
while (ch)
{
c = *ch++;
if (!c)
break;
c = toupper(c) - HU_FONTSTART;
if (c < 0 || c > HU_FONTSIZE)
{
cx += 4;
continue;
}
w = SHORT(hu_font[c]->width);
V_DrawPatchWithShadow(cx + 1, 181, hu_font[c], false);
cx += w;
}
}
// Checks if the lump can be a Doom patch
static dboolean CheckIfPatch(int lump)
{
int size;
int width, height;
const patch_t *patch;
dboolean result;
size = W_LumpLength(lump);
// minimum length of a valid Doom patch
if (size < 13)
return false;
patch = (const patch_t *)W_CacheLumpNum(lump, PU_STATIC);
width = SHORT(patch->width);
height = SHORT(patch->height);
result = (height > 0 && height <= 16384 && width > 0 && width <= 16384 && width < size / 4);
if (result)
{
// The dimensions seem like they might be valid for a patch, so
// check the column directory for extra security. All columns
// must begin after the column directory, and none of them must
// point past the end of the patch.
int x;
for (x = 0; x < width; ++x)
{
unsigned int ofs = LONG(patch->columnofs[x]);
// Need one byte for an empty column (but there's patches that don't know that!)
if (ofs < (unsigned int)width * 4 + 8 || ofs >= (unsigned int)size)
{
result = false;
break;
}
}
}
W_ReleaseLumpNum(lump);
return result;
}
//
// V_DrawPatchFlipped
// Masks a column based masked pic to the screen.
// Flips horizontally, e.g. to mirror face.
//
void
V_DrawPatchFlipped
( int x,
int y,
int scrn,
patch_t* patch )
{
int count;
int col;
column_t* column;
byte* desttop;
byte* dest;
byte* source;
int w;
y -= SHORT(patch->topoffset);
x -= SHORT(patch->leftoffset);
#ifdef RANGECHECK
if (x<0
||x+SHORT(patch->width) >SCREENWIDTH
|| y<0
|| y+SHORT(patch->height)>SCREENHEIGHT
|| (unsigned)scrn>4)
{
fprintf( stderr, "Patch origin %d,%d exceeds LFB\n", x,y );
I_Error ("Bad V_DrawPatch in V_DrawPatchFlipped");
}
#endif
if (!scrn)
V_MarkRect (x, y, SHORT(patch->width), SHORT(patch->height));
col = 0;
desttop = screens[scrn]+y*SCREENWIDTH+x;
w = SHORT(patch->width);
for ( ; col<w ; x++, col++, desttop++)
{
column = (column_t *)((byte *)patch + LONG(patch->columnofs[w-1-col]));
// step through the posts in a column
while (column->topdelta != 0xff )
{
source = (byte *)column + 3;
dest = desttop + column->topdelta*SCREENWIDTH;
count = column->length;
while (count--)
{
*dest = *source++;
dest += SCREENWIDTH;
}
column = (column_t *)( (byte *)column + column->length
+ 4 );
}
}
}
void F_TextWrite (void)
{
{
// erase the entire screen to a tiled background
const byte *src; // cph - const
int x,y;
int lump;
// killough 4/17/98:
src = W_CacheLumpNum(lump = firstflat + R_FlatNumForName(finaleflat));
V_DrawBlock(0, 0, 0, 64, 64, src, 0);
for (y=0 ; y<SCREENHEIGHT ; y+=64)
for (x=y ? 0 : 64; x<SCREENWIDTH ; x+=64)
V_CopyRect(0, 0, 0, ((SCREENWIDTH-x) < 64) ? (SCREENWIDTH-x) : 64,
((SCREENHEIGHT-y) < 64) ? (SCREENHEIGHT-y) : 64, x, y, 0);
W_UnlockLumpNum(lump);
}
V_MarkRect (0, 0, SCREENWIDTH, SCREENHEIGHT);
{ // draw some of the text onto the screen
int cx = 10;
int cy = 10;
const char* ch = finaletext; // CPhipps - const
int count = (finalecount - 10)/Get_TextSpeed(); // phares
int w;
if (count < 0)
count = 0;
for ( ; count ; count-- ) {
int c = *ch++;
if (!c)
break;
if (c == '\n') {
cx = 10;
cy += 11;
continue;
}
c = toupper(c) - HU_FONTSTART;
if (c < 0 || c> HU_FONTSIZE) {
cx += 4;
continue;
}
w = SHORT (hu_font[c]->width);
if (cx+w > SCREENWIDTH)
break;
// CPhipps - patch drawing updated
V_DrawMemPatch(cx, cy, 0, hu_font[c], NULL, VPT_STRETCH);
cx+=w;
}
}
}
int
WI_drawNum
( int x,
int y,
int n,
int digits )
{
int fontwidth = SHORT(num[0]->width);
int neg;
int temp;
if (digits < 0)
{
if (!n)
{
// make variable-length zeros 1 digit long
digits = 1;
}
else
{
// figure out # of digits in #
digits = 0;
temp = n;
while (temp)
{
temp /= 10;
digits++;
}
}
}
neg = n < 0;
if (neg)
n = -n;
// if non-number, do not draw it
if (n == 1994)
return 0;
// draw the new number
while (digits--)
{
x -= fontwidth;
V_DrawPatch(x, y, FB, num[ n % 10 ]);
n /= 10;
}
// draw a minus sign if necessary
if (neg)
V_DrawPatch(x-=8, y, FB, wiminus);
return x;
}
virtual void visitXformVar(XformVar* v)
{
XformVarInvoke *invoke = dynamic_cast<XformVarInvoke*>(v);
if (invoke == 0) { res = v; return; }
int userDebugSave = user_debug;
int isInDebug = user_debug || debug_xform();
if (isInDebug > 0) {
user_debug = userDebugSave-1;
if (user_debug) {
std:: cerr << "Invoking " << SHORT(v->toString(DEBUG_NO_VAR),500) << "\n";
}
}
res = invoke->eval();
if (isInDebug) {
std:: cerr << "Result of invoking " << SHORT(v->toString(DEBUG_NO_VAR),500) << "\n";
std:: cerr << "===>" << res->toString() << "\n";
user_debug = userDebugSave;
}
}
static int getPatchIsNotTileable(const patch_t *patch)
{
int x = 0;
int lastColumnDelta = 0;
const column_t *column;
int cornerCount = 0;
int hasAHole = 0;
for (x = 0; x < SHORT(patch->width); ++x)
{
int numPosts = 0;
column = (const column_t *)((const byte *)patch + LONG(patch->columnofs[x]));
if (!x)
lastColumnDelta = column->topdelta;
else if (lastColumnDelta != column->topdelta)
hasAHole = 1;
while (column->topdelta != 0xFF)
{
// check to see if a corner pixel filled
if (!x && !column->topdelta)
cornerCount++;
else if (!x && column->topdelta + column->length >= SHORT(patch->height))
cornerCount++;
else if (x == SHORT(patch->width) - 1 && !column->topdelta)
cornerCount++;
else if (x == SHORT(patch->width) - 1
&& column->topdelta + column->length >= SHORT(patch->height))
cornerCount++;
if (numPosts++)
hasAHole = 1;
column = (const column_t *)((const byte *)column + column->length + 4);
}
}
if (cornerCount == 4)
return 0;
return hasAHole;
}
void HUlib_initSText(hu_stext_t *s, int x, int y, int h, patch_t **font, int startchar, dboolean *on)
{
s->h = h;
s->on = on;
s->laston = true;
s->cl = 0;
for (int i = 0; i < h; i++)
HUlib_initTextLine(&s->l[i], x, y - i * (SHORT(font[0]->height) + 1), font, startchar);
}
/// get a genotype from a string
inline static C_Int16 getGeno(const char *p, const char *end, int num_allele)
{
const char *start = p;
if ((p < end) && (*p == '.'))
{
p ++;
while ((p < end) && (*p == ' ')) p ++;
if ((p < end) && VCF_RaiseError)
throw ErrSeqArray(ERR_INT_CONV, SHORT(start, end).c_str());
return -1;
}
int val = 0;
while (p < end)
{
char ch = *p ++;
if ('0' <= ch && ch <= '9')
{
val = val*10 + (ch - '0');
if (VCF_RaiseError && (val > 32767))
throw ErrSeqArray(ERR_INT_OUT_RANGE, SHORT(start, end).c_str());
} else {
if (ch == ' ')
{
while ((p < end) && (*p == ' '))
p ++;
if (p >= end) break;
}
if (VCF_RaiseError)
throw ErrSeqArray(ERR_GENO_CONV, SHORT(start, end).c_str());
return -1;
}
}
if (val >= num_allele)
{
if (VCF_RaiseError)
throw ErrSeqArray(ERR_GENO_OUT_RANGE, SHORT(start, end).c_str());
val = -1;
}
return val;
}
void V_DrawPatch(int x, int y, patch_t *patch)
{
#if 1
int count;
int col;
column_t *column;
byte *desttop;
byte *dest;
byte *source;
int w;
y -= SHORT(patch->topoffset);
x -= SHORT(patch->leftoffset);
if(x < 0 || x+SHORT(patch->width) > SCREENWIDTH || y < 0
|| y+SHORT(patch->height) > SCREENHEIGHT)
{
printf("x: %d y: %d\n",x,y);
printf("w: %d h: %d\n",patch->width,patch->height);
//I_Error("Bad V_DrawPatch");
return;
}
col = 0;
desttop = screen+y*SCREENWIDTH+x;
w = SHORT(patch->width);
for(; col < w; x++, col++, desttop++)
{
column = (column_t *)((byte *)patch+LONG(patch->columnofs[col]));
// Step through the posts in a column
while(column->topdelta != 0xff)
{
source = (byte *)column+3;
dest = desttop+column->topdelta*SCREENWIDTH;
count = column->length;
while(count--)
{
*dest = *source++;
dest += SCREENWIDTH;
}
column = (column_t *)((byte *)column+column->length+4);
}
}
#endif
}
static void WriteWAV(char *filename, byte *data,
uint32_t length, int samplerate)
{
FILE *wav;
unsigned int i;
unsigned short s;
wav = fopen(filename, "wb");
// Header
fwrite("RIFF", 1, 4, wav);
i = LONG(36 + samplerate);
fwrite(&i, 4, 1, wav);
fwrite("WAVE", 1, 4, wav);
// Subchunk 1
fwrite("fmt ", 1, 4, wav);
i = LONG(16);
fwrite(&i, 4, 1, wav); // Length
s = SHORT(1);
fwrite(&s, 2, 1, wav); // Format (PCM)
s = SHORT(2);
fwrite(&s, 2, 1, wav); // Channels (2=stereo)
i = LONG(samplerate);
fwrite(&i, 4, 1, wav); // Sample rate
i = LONG(samplerate * 2 * 2);
fwrite(&i, 4, 1, wav); // Byte rate (samplerate * stereo * 16 bit)
s = SHORT(2 * 2);
fwrite(&s, 2, 1, wav); // Block align (stereo * 16 bit)
s = SHORT(16);
fwrite(&s, 2, 1, wav); // Bits per sample (16 bit)
// Data subchunk
fwrite("data", 1, 4, wav);
i = LONG(length);
fwrite(&i, 4, 1, wav); // Data length
fwrite(data, 1, length, wav); // Data
fclose(wav);
}
virtual void visitCodeVar(CodeVar* v)
{
try {
POETCode* _listsep = listsep;
CodeVar* _listelem = listelem;
POETCode* result = v->invoke_output(v->get_args());
if (result != 0 && result != v) {
listsep = 0; listelem=0;
result->visit(this);
listsep = _listsep; listelem=_listelem;
return;
}
CvarSymbolTable::Entry e = v->get_entry();
LvarSymbolTable *local = 0;
POETCode* f = 0;
POETCode *parse = e.get_parse();
if (parse != 0 && parse->get_enum()==SRC_OP) {
POETOperator* op = static_cast<POETOperator*>(parse);
if (op->get_op() == POET_OP_LIST || op->get_op()==POET_OP_LIST1) {
listsep = op->get_arg(1);
listelem=dynamic_cast<CodeVar*>(op->get_arg(0));
f = v->get_args();
}
}
if (f == 0) {
listsep = 0; listelem=0;
f = e.get_code();
if (f == 0) {
if (parse==0) { CODE_SYNTAX_UNDEFINED(v->toString()); }
else f = v->get_args();
}
else {
local = e.get_symTable();
if (local != 0)
local->push_table(false);
POETCode* pars = e.get_param();
if (pars != 0 && !match_parameters(pars, v->get_args(),MATCH_PAR_MOD_CODE))
CVAR_MISMATCH(v,pars, v->get_args());
v->set_attr();
}
}
if (f == 0) { CODE_SYNTAX_UNDEFINED(v->toString()); }
int save = align;
align = start_pos;
f->visit(this);
align = save;
if (local != 0)
local->pop_table();
listsep = _listsep; listelem=_listelem;
}
catch (Error err) {
std::cerr << " From unparsing code template " << SHORT(v->toString(),500) << "\n";
throw err;
}
}
bool NetDemo::readHeader()
{
fseek(demofp, 0, SEEK_SET);
size_t cnt = 0;
cnt += sizeof(header.identifier) *
fread(&header.identifier, sizeof(header.identifier), 1, demofp);
cnt += sizeof(header.version) *
fread(&header.version, sizeof(header.version), 1, demofp);
cnt += sizeof(header.compression) *
fread(&header.compression, sizeof(header.compression), 1, demofp);
cnt += sizeof(header.snapshot_index_size) *
fread(&header.snapshot_index_size, sizeof(header.snapshot_index_size), 1, demofp);
cnt += sizeof(header.snapshot_index_offset)*
fread(&header.snapshot_index_offset, sizeof(header.snapshot_index_offset), 1, demofp);
cnt += sizeof(header.map_index_size) *
fread(&header.map_index_size, sizeof(header.map_index_size), 1, demofp);
cnt += sizeof(header.map_index_offset)*
fread(&header.map_index_offset, sizeof(header.map_index_offset), 1, demofp);
cnt += sizeof(header.snapshot_spacing) *
fread(&header.snapshot_spacing, sizeof(header.snapshot_spacing), 1, demofp);
cnt += sizeof(header.starting_gametic) *
fread(&header.starting_gametic, sizeof(header.starting_gametic), 1, demofp);
cnt += sizeof(header.ending_gametic) *
fread(&header.ending_gametic, sizeof(header.ending_gametic), 1, demofp);
cnt += sizeof(header.reserved) *
fread(&header.reserved, sizeof(header.reserved), 1, demofp);
if (cnt < NetDemo::HEADER_SIZE)
return false;
// convert from little-endian to native byte ordering
header.snapshot_index_size = SHORT(header.snapshot_index_size);
header.snapshot_index_offset = LONG(header.snapshot_index_offset);
header.map_index_size = SHORT(header.map_index_size);
header.map_index_offset = LONG(header.map_index_offset);
header.snapshot_spacing = SHORT(header.snapshot_spacing);
header.starting_gametic = LONG(header.starting_gametic);
header.ending_gametic = LONG(header.ending_gametic);
return true;
}
/// get an integer from a string
inline static int getInt32(const char *p, const char *end)
{
while ((p < end) && (*p == ' '))
p ++;
const char *start = p;
if ((p < end) && (*p == '.'))
{
p ++;
while ((p < end) && (*p == ' ')) p ++;
if ((p < end) && VCF_RaiseError)
throw ErrSeqArray(ERR_INT_CONV, SHORT(start, end).c_str());
return NA_INTEGER;
}
bool sign = ((p < end) && (*p == '-'));
if (sign) p ++;
C_Int64 val = 0;
while (p < end)
{
char ch = *p ++;
if ('0' <= ch && ch <= '9')
{
val = val*10 + (ch - '0');
if (VCF_RaiseError && (val > INT_MAX))
throw ErrSeqArray(ERR_INT_OUT_RANGE, SHORT(start, end).c_str());
} else {
if (ch == ' ')
{
while ((p < end) && (*p == ' '))
p ++;
if (p >= end) break;
}
if (VCF_RaiseError)
throw ErrSeqArray(ERR_INT_CONV, SHORT(start, end).c_str());
return NA_INTEGER;
}
}
return sign ? -val : val;
}
void R_DrawVisSprite(vissprite_t *vis, int x1, int x2)
{
column_t *column;
int texturecolumn;
fixed_t frac;
patch_t *patch = W_CacheLumpNum (vis->patch+firstspritelump, PU_CACHE);
dc_colormap = vis->colormap;
// killough 4/11/98: rearrange and handle translucent sprites
// mixed with translucent/non-translucent 2s normals
// sf: shadow draw now done by mobj flags, not a null colormap
if (vis->mobjflags & MF_SHADOW) // shadow draw
{
colfunc = R_DrawFuzzColumn; // killough 3/14/98
}
else
if (vis->colour)
{
colfunc = R_DrawTranslatedColumn;
dc_translation = translationtables + vis->colour*256 - 256;
}
else
if (vis->mobjflags & MF_TRANSLUCENT && general_translucency) // phares
{
colfunc = R_DrawTLColumn;
tranmap = main_tranmap; // killough 4/11/98
}
else
colfunc = R_DrawColumn; // killough 3/14/98, 4/11/98
dc_iscale = abs(vis->xiscale);
dc_texturemid = vis->texturemid;
frac = vis->startfrac;
spryscale = vis->scale;
sprtopscreen = centeryfrac - FixedMul(dc_texturemid,spryscale);
for (dc_x=vis->x1 ; dc_x<=vis->x2 ; dc_x++, frac += vis->xiscale)
{
texturecolumn = frac>>FRACBITS;
#ifdef RANGECHECK
if (texturecolumn < 0 || texturecolumn >= SHORT(patch->width))
I_Error ("R_DrawSpriteRange: bad texturecolumn");
#endif
column = (column_t *)((byte *) patch +
LONG(patch->columnofs[texturecolumn]));
R_DrawMaskedColumn (column);
}
colfunc = R_DrawColumn; // killough 3/14/98
}
static void DrawAltHUDNumber2(int x, int y, int val, int color)
{
int oldval = val;
patch_t *patch;
if (val > 99)
{
patch = altnum2[val / 100];
althudfunc(x, y, patch, WHITE, color);
x += SHORT(patch->width) + 1;
}
val %= 100;
if (val > 9 || oldval > 99)
{
patch = altnum2[val / 10];
althudfunc(x, y, patch, WHITE, color);
x += SHORT(patch->width) + 1;
}
althudfunc(x, y, altnum2[val % 10], WHITE, color);
}
void
HUlib_drawTextLine
( hu_textline_t* l,
boolean drawcursor )
{
int i;
int w;
int x;
unsigned char c;
// draw the new stuff
x = l->x;
for (i=0;i<l->len;i++)
{
c = toupper((int)l->l[i]);
if (c != ' '
&& c >= l->sc
&& c <= '_')
{
w = SHORT(l->f[c - l->sc]->width);
if (x+w > SCREENWIDTH)
break;
V_DrawPatchDirect(x, l->y, l->f[c - l->sc]);
x += w;
}
else
{
x += 4;
if (x >= SCREENWIDTH)
break;
}
}
// draw the cursor if requested
if (drawcursor
&& x + SHORT(l->f['_' - l->sc]->width) <= SCREENWIDTH)
{
V_DrawPatchDirect(x, l->y, l->f['_' - l->sc]);
}
}
void P_LoadVertexes(int lump)
{
byte *data;
int i;
mapvertex_t *ml;
vertex_t *li;
numvertexes = W_LumpLength(lump) / sizeof(mapvertex_t);
vertexes = Z_Malloc(numvertexes * sizeof(vertex_t), PU_LEVEL, 0);
data = W_CacheLumpNum(lump, PU_STATIC);
ml = (mapvertex_t *) data;
li = vertexes;
for (i = 0; i < numvertexes; i++, li++, ml++)
{
li->x = SHORT(ml->x) << FRACBITS;
li->y = SHORT(ml->y) << FRACBITS;
}
W_ReleaseLumpNum(lump);
}
