示例#1
0
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
DatabaseHandle::~DatabaseHandle()
{
	Check_Object(this);

	//
	//---------------------------------------------------------------
	// If we are closing a read only file, release the memmap handle,
	// otherwise delete the database object
	//---------------------------------------------------------------
	//
	if (m_readOnly)
		gos_CloseMemoryMappedFile(m_handle);
	else
	{
		Save();
		Check_Object(m_dataBase);

		//
		//---------------------------------------------------------------------
		// Now we need to go through and delete all the records in the database
		//---------------------------------------------------------------------
		//
		for (DWORD i=0; i<Database::e_DataBlockSize; ++i)
		{
			Record* record = reinterpret_cast<Record*>(m_dataBase->m_idOffsets[i]);
			if (record)
			{
				while (record)
				{
					record = reinterpret_cast<Record*>((DWORD)record + m_baseAddress);
					Check_Object(record);
					Record* this_record = record;

					record = reinterpret_cast<Record*>(record->m_nextIDRecord);
					if (this_record->m_mustFree)
						delete this_record;
				}
			}
		}

		//
		//--------------------------------
		// Now free up the database itself
		//--------------------------------
		//
		gos_Free(m_dataBase);
	}

	//
	//----------------------------------------------------
	// Delete the memory heap if this is the last database
	//----------------------------------------------------
	//
	if (--Database::FilesOpened == 0)
		gos_DestroyMemoryHeap(Database_Heap);
}
示例#2
0
//------------------------------------------------------------------------------------------
long Radio::playMessage (RadioMessageType msgType)
{
long i, roll, callsign, fragmentNum, dropOut = 0;

	if (!useSound)
		return(NO_PLAY);
	
	if (!enabled)
		return(NO_PLAY);

	if (!owner)
		return(NO_PLAY);

	if (!soundSystem->checkMessage(owner, messageInfo[msgType].priority, msgType))
		return(NO_PLAY);

	if ((msgType == RADIO_AMMO_OUT) && ammoOutPlayed)
		return(NO_PLAY);
	
	if (messageInfo[msgType].styleCount > 1)
	{
		roll = RandomNumber(100);	// choose which style of message to play
		for (i=0; i<messageInfo[msgType].styleCount; i++)
		{
			dropOut += messageInfo[msgType].styleChance[i];
			if (roll < dropOut)
				break;
		}
		
		if (i != 0 && i == messageInfo[msgType].styleCount)
			return NO_PLAY;
			
		if (messageInfo[msgType].messageMapping + i == owner->getLastMessage())
			i++;
			
		if (i >= messageInfo[msgType].styleCount)
			i = 0;
	}
	else
		i = 0;

	//RadioData *msgData = (RadioData *)radioHeap->Malloc(sizeof(RadioData));
	RadioData *msgData = new RadioData; //magic 02102011
	if (!msgData)
	{
		return(NO_PLAY);
	}
	
	memset(msgData,0,sizeof(RadioData));	
			
	msgData->noiseId = SHORT_STATIC;
	msgData->msgType = msgType;
	msgData->msgId = messageInfo[msgType].messageMapping + i;
	msgData->movieCode = messageInfo[msgType].movieCode;
	msgData->msgHeap = NULL ; //radioHeap; //magic 02102011 
	msgData->turnQueued = turn;
			
	msgData->priority = messageInfo[msgType].priority;
	msgData->pilot = owner;
	msgData->expirationDate = scenarioTime + messageInfo[msgType].shelfLife;
	
	//-----------------------------------------------------------------------
	// Load the pieces need for playback.
	callsign = 0;
	fragmentNum = 0;
	if (messageInfo[msgType].pilotIdentifiesSelf)
	{
		if (messageInfo[RADIO_CALLSIGN].styleCount > 1)
		{
			roll = RandomNumber(100);	// choose which style of message to play
			for (i=0; i<messageInfo[RADIO_CALLSIGN].styleCount; i++)
			{
				dropOut += messageInfo[RADIO_CALLSIGN].styleChance[i];
				if (roll < dropOut)
					break;
			}
			
			if (i != 0 && i == messageInfo[RADIO_CALLSIGN].styleCount)
				callsign = 0;
				
			if (i >= messageInfo[RADIO_CALLSIGN].styleCount)
				callsign = 0;
		}
		else
			callsign = 0;

		callsign += messageInfo[RADIO_CALLSIGN].messageMapping;
	}
	
	if (callsign)
	{
		if (messagesFile[radioID]->seekPacket(callsign) == NO_ERR)
		{

			unsigned long messageSize = messagesFile[radioID]->getPacketSize();
			//msgData->data[fragmentNum] = (MemoryPtr)radioHeap->Malloc(messageSize);
			msgData->data[fragmentNum] = (MemoryPtr)gos_Malloc(messageSize); //magic 02102011
			if (!msgData->data[fragmentNum]) 
			{
				//radioHeap->Free(msgData);
				delete msgData; //magic 02102011
				return(NO_PLAY);
			}
			messagesFile[radioID]->readPacket(callsign,msgData->data[fragmentNum]);
			msgData->dataSize[fragmentNum] = messageSize;
			fragmentNum++;
		}
	}

	if (messagesFile[radioID]->seekPacket(msgData->msgId) == NO_ERR)
	{
		unsigned long messageSize = messagesFile[radioID]->getPacketSize();
		//magic 31032011 begin
		if (messageSize > 0)
		{
		//magic 31032011 end
			//msgData->data[fragmentNum] = (MemoryPtr)radioHeap->Malloc(messageSize);
			msgData->data[fragmentNum] = (MemoryPtr)gos_Malloc(messageSize); //magic 02102011
			if (!msgData->data[fragmentNum]) 
			{
				while (fragmentNum >= 0)
				{
					//radioHeap->Free(msgData->data[fragmentNum]);
					gos_Free(msgData->data[fragmentNum]); //magic 02102011
					fragmentNum--;
				}
				//radioHeap->Free(msgData);
				delete msgData; //magic 02102011
				return(NO_PLAY);
			}
		
			messagesFile[radioID]->readPacket(msgData->msgId,msgData->data[fragmentNum]);
			msgData->dataSize[fragmentNum] = messageSize;
		//magic 31032011 begin
		}
		//magic 31032011 end
		
		if (noiseFile->seekPacket(msgData->noiseId) == NO_ERR)
		{
			unsigned long messageSize = noiseFile->getPacketSize();
			//msgData->noise[0] = (MemoryPtr)radioHeap->Malloc(messageSize);
			msgData->noise[0] = (MemoryPtr)gos_Malloc(messageSize); //magic 02102011
			if (!msgData->noise[0])
			{
				//radioHeap->Free(msgData);
				delete msgData; //magic 02102011
				if (fragmentNum > 0)
					//radioHeap->Free(msgData->data[0]);
					gos_Free(msgData->data[0]); //magic 02102011

				return(NO_PLAY);
			}
		
			noiseFile->readPacket(msgData->noiseId,msgData->noise[0]);
			msgData->noiseSize[fragmentNum] = messageSize;
		}
	}
	
	//------------------------------------------------------
	// Big ol bug here.  We weren't checking to see if the
	// queue was full.  If it was, memory would leak from
	// the smacker window.  It wouldn't leak from the RadioHeap
	// because we clear the radio heap every mission!!
	if (soundSystem->queueRadioMessage(msgData) != NO_ERR)
	{
		if (msgData)
		{
			for (long j=0;j<MAX_FRAGMENTS;j++)
			{
				//radioHeap->Free(msgData->data[j]);
				gos_Free(msgData->data[j]); //magic 02102011
				msgData->data[j] = NULL;
				//radioHeap->Free(msgData->noise[j]);
				gos_Free(msgData->noise[j]); //magic 02102011
				msgData->noise[j] = NULL;
			}
			
			//radioHeap->Free(msgData);
			delete msgData;
			msgData = NULL;
		}
		return (NO_PLAY);
	}
	
	if (msgType == RADIO_AMMO_OUT)
		ammoOutPlayed = true;

	return(msgData->msgId);
}
示例#3
0
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
DatabaseHandle::DatabaseHandle(
	const char* filename,
	bool read_only
)
{
	//
	//-----------------------------------------------------
	// Create the database heap if it doesn't already exist
	//-----------------------------------------------------
	//
	m_fileName = filename;
	if (!Database::FilesOpened++)
		Database_Heap = gos_CreateMemoryHeap("Database", 0);
	gos_PushCurrentHeap(Database_Heap);
	m_currentRecord = 0;
	m_currentPointer = NULL;
	m_dirtyFlag = false;

	//
	//--------------------------------------------
	// If the file is read only, our job is simple
	//--------------------------------------------
	//
	m_readOnly = read_only;
	if (m_readOnly)
	{
		if (gos_DoesFileExist(filename))
		{
			FileStream::IsRedirected = false;
			DWORD size;
			m_handle =
				gos_OpenMemoryMappedFile(
					filename,
					reinterpret_cast<BYTE**>(&m_dataBase),
					&size
				);
			if (m_dataBase->m_tag != Database::e_Tag)
				STOP(("Invalid database file \"%s\"", filename));
			if (m_dataBase->m_version > Database::e_Version)
				STOP(("Application must be recompiled to use database \"%s\"", filename));
			m_baseAddress = reinterpret_cast<DWORD>(m_dataBase);
			Check_Object(m_dataBase);
		}
		else
			STOP(("Database \"%s\" does not exist", filename));
	}

	//
	//-------------------------------------------------------------
	// The file is not read only, so see if we load it or create it
	//-------------------------------------------------------------
	//
	else
	{
		m_handle = NULL;
		if (gos_DoesFileExist(filename))
		{
			DWORD size;
			gos_GetFile(
				filename,
				reinterpret_cast<BYTE**>(&m_dataBase),
				&size
			);
			FileStream::IsRedirected = false;
			Check_Pointer(m_dataBase);
			if (m_dataBase->m_tag != Database::e_Tag || m_dataBase->m_version > Database::e_Version || m_dataBase->m_version == 1)
			{
				gos_Free(m_dataBase);
				PAUSE(("Bad database file!  Press 'Continue' to rebuild", filename));
				m_dataBase = new(gos_Malloc(sizeof(Database), Database_Heap)) Database;
				m_baseAddress = 0;
			}
			else
			{
				m_baseAddress = reinterpret_cast<DWORD>(m_dataBase);
				Check_Object(m_dataBase);
			}
		}

		//
		//------------------------------------------
		// The file doesn't exist, so create it here
		//------------------------------------------
		//
		else
		{
			m_dataBase = new(gos_Malloc(sizeof(Database), Database_Heap)) Database;
			m_baseAddress = 0;
		}
	}
	gos_PopCurrentHeap();
}
示例#4
0
	void operator delete[](PVOID ptr)
	{
		gos_Free(ptr);
	}