自学教程：C++ Con_Error函数代码示例

CBuffer* CBuffer_New(uint maxNumLines, uint maxLineLength, int flags){    char name[32+1];    CBuffer* cb;    if(maxNumLines < 1 || maxLineLength < 1)        Con_Error("CBuffer::New: Odd buffer params");    cb = (CBuffer*)malloc(sizeof *cb);    if(!cb) Con_Error("CBuffer::New: Failed on allocation of %lu bytes for new CBuffer.", (unsigned long) sizeof *cb);    dd_snprintf(name, 33, "CBufferMutex%p", cb);    cb->mutex = Sys_CreateMutex(name);    cb->flags = flags;    cb->head = cb->tail = NULL;    cb->used = NULL;    cb->numLines = 0;    cb->maxLineLen = maxLineLength;    cb->writebuf = (char*)calloc(1, cb->maxLineLen+1);    if(!cb->writebuf) Con_Error("CBuffer::New: Failed on allocation of %lu bytes for write buffer.", (unsigned long) (cb->maxLineLen+1));    cb->wbc = 0;    cb->wbFlags = 0;    cb->maxLines = maxNumLines;    // Allocate the index now.    cb->index = (cbnode_t**)malloc(cb->maxLines * sizeof *cb->index);    if(!cb->index) Con_Error("CBuffer::New: Failed on allocation of %lu bytes for line index.", (unsigned long) (cb->maxLines * sizeof *cb->index));    cb->indexSize = cb->maxLines;    cb->indexGood = true; // its empty so...    return cb;}

//===========================================================================// DG_Begin//===========================================================================void DG_Begin(int mode){	if(mode == DGL_SEQUENCE)	{		if(inSequence) return;		inSequence = true;		if(FAILED(hr = dev->BeginScene()))		{#ifdef _DEBUG			DXError("BeginScene");			Con_Error("BeginScene Failed/n");#endif		}		return;	}	// Begin the scene automatically.	if(!inSequence) 	{		if(FAILED(dev->BeginScene()))		{#ifdef _DEBUG			DXError("BeginScene");			Con_Error("BeginScene Failed/n");#endif		}	}	primType = mode;	indexPos = 0;	primOrder = 0;	/*primCount = 0;*/	vertexPos = 0;}

void EmitMarkFace (dleaf_t *leaf_p, face_t *f){	int			i;	int			facenum;	while (f->merged)		f = f->merged;	if (f->split[0])	{		EmitMarkFace (leaf_p, f->split[0]);		EmitMarkFace (leaf_p, f->split[1]);		return;	}	facenum = f->outputnumber;	if (facenum == -1)		return;	// degenerate face	if (facenum < 0 || facenum >= numfaces)		Con_Error("Bad leafface/n");	for (i=leaf_p->firstleafface ; i<numleaffaces ; i++)		if (dleaffaces[i] == facenum)			break;		// merged out face	if (i == numleaffaces)	{		if (numleaffaces >= MAX_MAP_LEAFFACES)			Con_Error("MAX_MAP_LEAFFACES/n");		dleaffaces[numleaffaces] =  facenum;		numleaffaces++;	}}

void W_OpenAuxiliary(char *filename){	int     i;	int     size;	wadinfo_t header;	int     handle;	int     length;	filelump_t *fileinfo;	filelump_t *sourceLump;	lumpinfo_t *destLump;	if(AuxiliaryOpened)	{		W_CloseAuxiliary();	}	if((handle = open(filename, O_RDONLY | O_BINARY)) == -1)	{		Con_Error("W_OpenAuxiliary: %s not found.", filename);		return;	}	AuxiliaryHandle = handle;	read(handle, &header, sizeof(header));	if(strncmp(header.identification, "IWAD", 4))	{		if(strncmp(header.identification, "PWAD", 4))		{						// Bad file id			Con_Error("Wad file %s doesn't have IWAD or PWAD id/n", filename);		}	}	header.numlumps = LONG(header.numlumps);	header.infotableofs = LONG(header.infotableofs);	length = header.numlumps * sizeof(filelump_t);	fileinfo = Z_Malloc(length, PU_STATIC, 0);	lseek(handle, header.infotableofs, SEEK_SET);	read(handle, fileinfo, length);	numlumps = header.numlumps;	// Init the auxiliary lumpinfo array	lumpinfo = Z_Malloc(numlumps * sizeof(lumpinfo_t), PU_STATIC, 0);	sourceLump = fileinfo;	destLump = lumpinfo;	for(i = 0; i < numlumps; i++, destLump++, sourceLump++)	{		destLump->handle = handle;		destLump->position = LONG(sourceLump->filepos);		destLump->size = LONG(sourceLump->size);		strncpy(destLump->name, sourceLump->name, 8);	}	Z_Free(fileinfo);	// Allocate the auxiliary lumpcache array	size = numlumps * sizeof(*lumpcache);	lumpcache = Z_Malloc(size, PU_STATIC, 0);	memset(lumpcache, 0, size);	AuxiliaryLumpInfo = lumpinfo;	AuxiliaryLumpCache = lumpcache;	AuxiliaryNumLumps = numlumps;	AuxiliaryOpened = true;}

void Sys_ConInit(){	char    title[256];	FreeConsole();	if(!AllocConsole())	{		Con_Error("couldn't allocate a console! error %i/n", GetLastError());	}	hcInput = GetStdHandle(STD_INPUT_HANDLE);	if(hcInput == INVALID_HANDLE_VALUE)		Con_Error("bad input handle/n");	// Compose the title.	sprintf(title, "Doomsday " DOOMSDAY_VERSION_TEXT " (Dedicated) : %s",			gx.Get(DD_GAME_ID));	if(!SetConsoleTitle(title))		Con_Error("setting console title: error %i/n", GetLastError());	hcScreen = GetStdHandle(STD_OUTPUT_HANDLE);	if(hcScreen == INVALID_HANDLE_VALUE)		Con_Error("bad output handle/n");	GetConsoleScreenBufferInfo(hcScreen, &cbInfo);	// This is the location of the print cursor.	cx = 0;	cy = cbInfo.dwSize.Y - 2;	Sys_ConUpdateCmdLine("");}

void G_AddEventSequence(const char* sequence, eventsequencehandler_t callback){    if(!inited) Con_Error("G_AddEventSequence: Subsystem not presently initialized.");    if(!sequence || !sequence[0] || !callback) Con_Error("G_AddEventSequence: Invalid argument(s).");    SequenceCompleteHandler* handler = new SequenceCompleteHandler(callback);    sequences.push_back(new EventSequence(sequence, *handler));}

void G_AddEventSequenceCommand(const char* sequence, const char* commandTemplate){    if(!inited) Con_Error("G_AddEventSequenceCommand: Subsystem not presently initialized.");    if(!sequence || !sequence[0] || !commandTemplate || !commandTemplate[0]) Con_Error("G_AddEventSequenceCommand: Invalid argument(s).");    SequenceCompleteCommandHandler* handler = new SequenceCompleteCommandHandler(commandTemplate);    sequences.push_back(new EventSequence(sequence, *handler));}

/*================CalcPHSCalculate the PHS (Potentially Hearable Set)by ORing together all the PVS visible from a leaf================*/void CalcPHS (void){	int		i, j, k, l, index;	int		bitbyte;	long	*dest, *src;	byte	*scan;	int		count;	byte	uncompressed[MAX_MAP_LEAFS/8];	byte	compressed[MAX_MAP_LEAFS/8];	Con_Print("Building PHS.../n");	count = 0;	for (i=0 ; i<portalclusters ; i++)	{		scan = uncompressedvis + i*leafbytes;		memcpy (uncompressed, scan, leafbytes);		for (j=0 ; j<leafbytes ; j++)		{			bitbyte = scan[j];			if (!bitbyte)				continue;			for (k=0 ; k<8 ; k++)			{				if (! (bitbyte & (1<<k)) )					continue;				// OR this pvs row into the phs				index = ((j<<3)+k);				if (index >= portalclusters)					Con_Error("Bad bit in PVS/n");	// pad bits should be 0				src = (long *)(uncompressedvis + index*leafbytes);				dest = (long *)uncompressed;				for (l=0 ; l<leaflongs ; l++)					((long *)uncompressed)[l] |= src[l];			}		}		for (j=0 ; j<portalclusters ; j++)			if (uncompressed[j>>3] & (1<<(j&7)) )				count++;	//	// compress the bit string	//		j = CompressVis (uncompressed, compressed);		dest = (long *)vismap_p;		vismap_p += j;				if (vismap_p > vismap_end)			Con_Error("Vismap expansion overflow/n");		dvis->bitofs[i][DVIS_PHS] = (byte *)dest-vismap;		memcpy (dest, compressed, j);		}	Con_Print("Average clusters hearable: %i/n", count/portalclusters);}

/*===============ClusterMergeMerges the portal visibility for a leaf===============*/void ClusterMerge (int leafnum){	leaf_t		*leaf;	byte		portalvector[MAX_PORTALS/8];	byte		uncompressed[MAX_MAP_LEAFS/8];	byte		compressed[MAX_MAP_LEAFS/8];	int			i, j;	int			numvis;	byte		*dest;	portal_t	*p;	int			pnum;	// OR together all the portalvis bits	memset (portalvector, 0, portalbytes);	leaf = &leafs[leafnum];	for (i=0 ; i<leaf->numportals ; i++)	{		p = leaf->portals[i];		if (p->status != stat_done)			Con_Error("portal not done/n");		for (j=0 ; j<portallongs ; j++)			((long *)portalvector)[j] |= ((long *)p->portalvis)[j];		pnum = p - portals;		portalvector[pnum>>3] |= 1<<(pnum&7);	}	// convert portal bits to leaf bits	numvis = LeafVectorFromPortalVector (portalvector, uncompressed);	if (uncompressed[leafnum>>3] & (1<<(leafnum&7)))		Con_Print("WARNING: Leaf portals saw into leaf/n");			uncompressed[leafnum>>3] |= (1<<(leafnum&7));	numvis++;		// count the leaf itself	// save uncompressed for PHS calculation	memcpy (uncompressedvis + leafnum*leafbytes, uncompressed, leafbytes);//// compress the bit string//	Con_Verbose ("cluster %4i : %4i visible/n", leafnum, numvis);	totalvis += numvis;	i = CompressVis (uncompressed, compressed);	dest = vismap_p;	vismap_p += i;		if (vismap_p > vismap_end)		Con_Error("Vismap expansion overflow/n");	dvis->bitofs[leafnum][DVIS_PVS] = dest-vismap;	memcpy (dest, compressed, i);	}

boolean FI_ScriptSuspended(finaleid_t id){    finale_t* f;    if(!inited)        Con_Error("FI_ScriptSuspended: Not initialized yet!");    f = finalesById(id);    if(!f)        Con_Error("FI_ScriptSuspended: Unknown finaleid %u.", id);    return FinaleInterpreter_IsSuspended(f->_interpreter);}

int FI_ScriptFlags(finaleid_t id){    finale_t* f;    if(!inited)        Con_Error("FI_ScriptFlags: Not initialized yet!");    f = finalesById(id);    if(!f)        Con_Error("FI_ScriptFlags: Unknown finaleid %u.", id);    return f->flags;}

/*============EmitDrawingNode_r============*/int EmitDrawNode_r (node_t *node){	dnode_t	*n;	face_t	*f;	int		i;	if (node->planenum == PLANENUM_LEAF)	{		EmitLeaf (node);		return -numleafs;	}	// emit a node		if (numnodes == MAX_MAP_NODES)		Con_Error("MAX_MAP_NODES/n");	n = &dnodes[numnodes];	numnodes++;	VectorCopy (node->mins, n->mins);	VectorCopy (node->maxs, n->maxs);	if (node->planenum & 1)		Con_Error("WriteDrawNodes_r: odd planenum/n");	n->planenum = node->planenum;	n->firstface = numfaces;	if (!node->faces)		c_nofaces++;	else		c_facenodes++;	for (f=node->faces ; f ; f=f->next)		EmitFace (f);	n->numfaces = numfaces - n->firstface;	//	// recursively output the other nodes	//		for (i=0 ; i<2 ; i++)	{		if (node->children[i]->planenum == PLANENUM_LEAF)		{			n->children[i] = -(numleafs + 1);			EmitLeaf (node->children[i]);		}		else		{			n->children[i] = numnodes;				EmitDrawNode_r (node->children[i]);		}	}	return n - dnodes;}

void FI_ScriptSuspend(finaleid_t id){    finale_t* f;    if(!inited)        Con_Error("FI_ScriptSuspend: Not initialized yet!");    f = finalesById(id);    if(!f)        Con_Error("FI_ScriptSuspend: Unknown finaleid %u.", id);    f->active = false;    FinaleInterpreter_Suspend(f->_interpreter);}

void FI_ScriptResume(finaleid_t id){    finale_t* f;    if(!inited)        Con_Error("FI_ScriptResume: Not initialized yet!");    f = finalesById(id);    if(!f)        Con_Error("FI_ScriptResume: Unknown finaleid %u.", id);    f->active = true;    FinaleInterpreter_Resume(f->_interpreter);}

boolean FI_ScriptIsMenuTrigger(finaleid_t id){    finale_t* f;    if(!inited)        Con_Error("FI_ScriptIsMenuTrigger: Not initialized yet!");    f = finalesById(id);    if(!f)        Con_Error("FI_ScriptIsMenuTrigger: Unknown finaleid %u.", id);    if(f->active)    {        DEBUG_Message(("IsMenuTrigger: %i/n", FinaleInterpreter_IsMenuTrigger(f->_interpreter)));        return FinaleInterpreter_IsMenuTrigger(f->_interpreter);    }    return false;}

static int textFragmentWidth(const char* fragment){    assert(NULL != fragment);    {    size_t i, len;    int width = 0;    const char* ch;    unsigned char c;    if(fr.fontNum == 0)    {        Con_Error("textFragmentHeight: Cannot determine height without a current font.");        exit(1);    }    // Just add them together.    len = strlen(fragment);    i = 0;    ch = fragment;    while(i++ < len && (c = *ch++) != 0 && c != '/n')        width += FR_CharWidth(c);    return (int) (width + currentAttribs()->tracking * (len-1));    }}

static int textFragmentHeight(const char* fragment){    assert(NULL != fragment);    {    const char* ch;    unsigned char c;    int height = 0;    size_t len;    uint i;    if(fr.fontNum == 0)    {        Con_Error("textFragmentHeight: Cannot determine height without a current font.");        exit(1);    }    // Find the greatest height.    i = 0;    height = 0;    len = strlen(fragment);    ch = fragment;    while(i++ < len && (c = *ch++) != 0 && c != '/n')    {        height = MAX_OF(height, FR_CharHeight(c));    }    return topToAscent(Fonts_ToFont(fr.fontNum)) + height;    }}

//===========================================================================// DG_Begin//===========================================================================void DG_Begin(int mode){	if(mode == DGL_SEQUENCE)	{		// We don't need to worry about this.		return;	}	// We enter a Begin/End section.	primLevel++;#ifdef _DEBUG	if(inPrim)		Con_Error("OpenGL: already inPrim");	inPrim = true;	CheckError();#endif	glBegin(mode == DGL_POINTS ? GL_POINTS : mode ==			DGL_LINES ? GL_LINES : mode ==			DGL_TRIANGLES ? GL_TRIANGLES : mode ==			DGL_TRIANGLE_FAN ? GL_TRIANGLE_FAN : mode ==			DGL_TRIANGLE_STRIP ? GL_TRIANGLE_STRIP : mode ==			DGL_QUAD_STRIP ? GL_QUAD_STRIP : GL_QUADS);}

static void errorIfNotInited(const char* callerName){    if(inited) return;    Con_Error("%s: font renderer module is not presently initialized.", callerName);    // Unreachable. Prevents static analysers from getting rather confused, poor things.    exit(1);}

//===========================================================================// P_SetState//  'statenum' must be a valid state (not null!).//===========================================================================void P_SetState(mobj_t *mobj, int statenum){    state_t *st = states + statenum;    boolean spawning = (mobj->state == 0);    ded_ptcgen_t *pg;#if _DEBUG    if(statenum < 0 || statenum >= defs.count.states.num)        Con_Error("P_SetState: statenum %i out of bounds./n", statenum);#endif    mobj->state = st;    mobj->tics = st->tics;    mobj->sprite = st->sprite;    mobj->frame = st->frame;    // Check for a ptcgen trigger.    for(pg = st->ptrigger; statenum && pg; pg = pg->state_next)    {        if(!(pg->flags & PGF_SPAWN_ONLY) || spawning)        {            // We are allowed to spawn the generator.            P_SpawnParticleGen(pg, mobj);        }    }    if(defs.states[statenum].execute)        Con_Execute(defs.states[statenum].execute, true);}

void Sys_ConPostEvents(){	event_t ev;	DWORD   num, read;	INPUT_RECORD rec[MAXRECS], *ptr;	KEY_EVENT_RECORD *key;	if(!GetNumberOfConsoleInputEvents(hcInput, &num))		Con_Error("Sys_ConPostEvents: error %i/n", GetLastError());	if(!num)		return;	ReadConsoleInput(hcInput, rec, MAXRECS, &read);	for(ptr = rec; read > 0; read--, ptr++)	{		if(ptr->EventType != KEY_EVENT)			continue;		key = &ptr->Event.KeyEvent;		ev.type = key->bKeyDown ? ev_keydown : ev_keyup;		if(key->wVirtualKeyCode == VK_UP)			ev.data1 = DDKEY_UPARROW;		else if(key->wVirtualKeyCode == VK_DOWN)			ev.data1 = DDKEY_DOWNARROW;		else			ev.data1 = DD_ScanToKey(key->wVirtualScanCode);		DD_PostEvent(&ev);	}}

int H2_GetFilterColor(int filter){	//int rgba = 0;	// We have to choose the right color and alpha.	if(filter >= STARTREDPALS && filter < STARTREDPALS + NUMREDPALS)		// Red?		return FMAKERGBA(1, 0, 0, filter / 8.0);	// Full red with filter 8.	else if(filter >= STARTBONUSPALS && filter < STARTBONUSPALS + NUMBONUSPALS)		// Light Yellow?		return FMAKERGBA(1, 1, .5, (filter - STARTBONUSPALS + 1) / 16.0);	else if(filter >= STARTPOISONPALS &&			filter < STARTPOISONPALS + NUMPOISONPALS)		// Green?		return FMAKERGBA(0, 1, 0, (filter - STARTPOISONPALS + 1) / 16.0);	else if(filter >= STARTSCOURGEPAL)		// Orange?		return FMAKERGBA(1, .5, 0, (STARTSCOURGEPAL + 3 - filter) / 6.0);	else if(filter >= STARTHOLYPAL)		// White?		return FMAKERGBA(1, 1, 1, (STARTHOLYPAL + 3 - filter) / 6.0);	else if(filter == STARTICEPAL)		// Light blue?		return FMAKERGBA(.5f, .5f, 1, .4f);	else if(filter)		Con_Error("H2_GetFilterColor: Strange filter number: %d./n", filter);	return 0;}

static int SV_ReadGlow(glow_t *glow){/* Original Heretic format:typedef struct {    thinker_t   thinker;        // was 12 bytes    Sector     *sector;    int         minLight;    int         maxLight;    int         direction;} v13_glow_t;*/    // Padding at the start (an old thinker_t struct)    Reader_Read(svReader, NULL, SIZEOF_V13_THINKER_T);    // Start of used data members.    // A 32bit pointer to sector, serialized.    glow->sector = P_ToPtr(DMU_SECTOR, Reader_ReadInt32(svReader));    if(!glow->sector)        Con_Error("tc_glow: bad sector number/n");    glow->minLight = (float) Reader_ReadInt32(svReader) / 255.0f;    glow->maxLight = (float) Reader_ReadInt32(svReader) / 255.0f;    glow->direction = Reader_ReadInt32(svReader);    glow->thinker.function = (thinkfunc_t) T_Glow;    return true; // Add this thinker.}

void   *W_CacheLumpNum(int lump, int tag){	byte   *ptr;	if((unsigned) lump >= (unsigned) numlumps)	{		Con_Error("W_CacheLumpNum: %i >= numlumps", lump);	}	// Return the name instead of data?	if(tag == PU_GETNAME)	{		strncpy(retname, lumpinfo[lump].name, 8);		retname[8] = 0;		return retname;	}	if(!lumpcache[lump])	{							// Need to read the lump in		ptr = Z_Malloc(W_LumpLength(lump), tag, &lumpcache[lump]);		W_ReadLump(lump, lumpcache[lump]);	}	else	{		Z_ChangeTag(lumpcache[lump], tag);	}	return lumpcache[lump];}

static int SV_ReadStrobe(strobe_t *strobe){/* Original Heretic format:typedef struct {    thinker_t   thinker;        // was 12 bytes    Sector     *sector;    int         count;    int         minLight;    int         maxLight;    int         darkTime;    int         brightTime;} v13_strobe_t;*/    // Padding at the start (an old thinker_t struct)    Reader_Read(svReader, NULL, SIZEOF_V13_THINKER_T);    // Start of used data members.    // A 32bit pointer to sector, serialized.    strobe->sector = P_ToPtr(DMU_SECTOR, Reader_ReadInt32(svReader));    if(!strobe->sector)        Con_Error("tc_strobe: bad sector number/n");    strobe->count = Reader_ReadInt32(svReader);    strobe->minLight = (float) Reader_ReadInt32(svReader) / 255.0f;    strobe->maxLight = (float) Reader_ReadInt32(svReader) / 255.0f;    strobe->darkTime = Reader_ReadInt32(svReader);    strobe->brightTime = Reader_ReadInt32(svReader);    strobe->thinker.function = (thinkfunc_t) T_StrobeFlash;    return true; // Add this thinker.}

static void P_v13_UnArchiveThinkers(void){typedef enum{    TC_END,    TC_MOBJ} thinkerclass_t;    byte tclass;    // Remove all the current thinkers.    Thinker_Iterate(NULL, removeThinker, NULL);    Thinker_Init();    // read in saved thinkers    for(;;)    {        tclass = Reader_ReadByte(svReader);        switch(tclass)        {        case TC_END: return; // End of list.        case TC_MOBJ:            SV_v13_ReadMobj();            break;        default:            Con_Error("Unknown tclass %i in savegame", tclass);        }    }}

int W_LumpLength(int lump){	if(lump >= numlumps)	{		Con_Error("W_LumpLength: %i >= numlumps", lump);	}	return lumpinfo[lump].size;}

byte Msg_ReadByte(void){#ifdef _DEBUG	if(Msg_Offset() >= netBuffer.length)		Con_Error("Packet read overflow!/n");#endif	return *netBuffer.cursor++;}