slcresourcefile.cpp

游戏编程精华02－含有几十个游戏编程例子

// Author:      Bruno Sousa (BS)
// Created in:  21-03-2001 12:18:29
// Version:     1.00.00
// 
// Description: Open an encrypted lump inside a resource.
// Remarks:     None.
//--------------------------------------------------------------------------------------------------
void slCResourceFile::OpenLumpEncrypted (slCLump& rkLump, slSLumpHeader SLumpHeader) 
{
	unsigned char * tpData;
	unsigned long tulPosition;

	// read the data from the resource lump
	tpData = new unsigned char [SLumpHeader.ulSize];
	m_kFile.read ((char*)tpData, SLumpHeader.ulSize);

	// decrypt file
	for (tulPosition = 0; tulPosition < SLumpHeader.ulSize; tulPosition++)
	{
		tpData [tulPosition] ^= SLumpHeader.byCheckSum;
	}

	// set the lump information and data
	rkLump.SetLumpName (SLumpHeader.acName);
	rkLump.SetLumpSize (SLumpHeader.ulSize);
	rkLump.SetDataPointer (tpData);
}


//--------------------------------------------------------------------------------------------------
// Name:	      OpenLumpCompressedEncrypted
// Parent:	    slCResourceFile
// Author:      Bruno Sousa (BS)
// Created in:  21-03-2001 12:25:02
// Version:     1.00.00
// 
// Description: Open a compressed encrypted file inside a resource.
// Remarks:     Compressing algorithm (RLE) doesn't work in all cases, removed until another one can
//              be implement.
//--------------------------------------------------------------------------------------------------
void slCResourceFile::OpenLumpCompressedEncrypted (slCLump& rkLump, slSLumpHeader SLumpHeader) 
{
	unsigned char * tpData;
  unsigned long tulPosition;

	// read the data from the resource lump
	tpData = new unsigned char [SLumpHeader.ulSizeUncompressed];

	m_kFile.read ((char*)tpData, SLumpHeader.ulSize);

	// decrypt lump
	for (tulPosition = 0; tulPosition < SLumpHeader.ulSizeUncompressed; tulPosition++)
	{
		tpData [tulPosition] ^= SLumpHeader.byCheckSum;
	}

	// set the lump information and data
	rkLump.SetLumpName (SLumpHeader.acName);
	rkLump.SetLumpSize (SLumpHeader.ulSizeUncompressed);
	rkLump.SetDataPointer (tpData);

}


//--------------------------------------------------------------------------------------------------
// Name:	      OpenLumpRaw
// Parent:	    slCResourceFile
// Author:      Bruno Sousa (BS)
// Created in:  21-03-2001 12:18:42
// Version:     1.00.00
// 
// Description: Open a raw lump inside a resource.
// Remarks:     None.
//--------------------------------------------------------------------------------------------------
void slCResourceFile::OpenLumpRaw (slCLump& rkLump, slSLumpHeader SLumpHeader) 
{
	unsigned char * tpData = new unsigned char [SLumpHeader.ulSize];
  memset (tpData,0,SLumpHeader.ulSize);

  // read the data from the resource file
	tpData = new unsigned char [SLumpHeader.ulSize];
  memset (tpData, 0, SLumpHeader.ulSize);
	m_kFile.read ((char*)tpData, SLumpHeader.ulSize);

	// set the lump information and data
	rkLump.SetLumpName (SLumpHeader.acName);
	rkLump.SetLumpSize (SLumpHeader.ulSize);
	rkLump.SetDataPointer (tpData);
}


//--------------------------------------------------------------------------------------------------
// Name:	      CompressLump
// Parent:	    slCResourceFile
// Author:      Bruno Sousa (BS)
// Created in:  15-04-2001 5:54:23
// Version:     1.00.00
// 
// Description: Compresses a lump.
// Remarks:     Compressing algorithm (RLE) doesn't work in all cases, removed until another one can
//              be implement.
//--------------------------------------------------------------------------------------------------
unsigned char* slCResourceFile::CompressLump (slSLumpWritingHeader kWritingHeader, 
                                               slSLumpHeader& rkLumpHeader)
{
  unsigned char* pOriginalData;

  pOriginalData = new unsigned char [kWritingHeader.ulSize];

  // read original data
  ifstream fInput;
  fInput.open (kWritingHeader.acFileName, ios::in | ios::binary);
  fInput.read (pOriginalData,kWritingHeader.ulSize);
  fInput.close ();

  // set lump header information
  strcpy (rkLumpHeader.acName, kWritingHeader.acName);
  rkLumpHeader.byCheckSum = kWritingHeader.byCheckSum;
  rkLumpHeader.ulFlags = kWritingHeader.ulFlags;
  rkLumpHeader.ulSize = kWritingHeader.ulSize;
  rkLumpHeader.ulSizeUncompressed = kWritingHeader.ulSize;

  return pOriginalData;
}


//--------------------------------------------------------------------------------------------------
// Name:	      EncryptLump
// Parent:	    slCResourceFile
// Author:      Bruno Sousa (BS)
// Created in:  15-04-2001 8:15:02
// Version:     1.00.00
// 
// Description: Encrypts a file
// Remarks:     None.
//--------------------------------------------------------------------------------------------------
unsigned char* slCResourceFile::EncryptLump (slSLumpWritingHeader kWritingHeader, slSLumpHeader& rkLumpHeader)
{
  unsigned char* pOriginalData;
  unsigned char* pEncryptedData;

  pOriginalData = new unsigned char [kWritingHeader.ulSize];
  pEncryptedData = new unsigned char [kWritingHeader.ulSize];
  
  // read original data
  ifstream fInput;
  fInput.open (kWritingHeader.acFileName, ios::in | ios::binary);
  fInput.read (pOriginalData,kWritingHeader.ulSize);
  fInput.close ();

  memcpy (pEncryptedData, pOriginalData, kWritingHeader.ulSize);

	unsigned long tulPosition;

	// encrypt file
	for (tulPosition = 0; tulPosition < kWritingHeader.ulSize; tulPosition++)
	{
		pEncryptedData [tulPosition] ^= kWritingHeader.byCheckSum;
	}

  delete [] pOriginalData;

 	// set the lump information and data
  strcpy (rkLumpHeader.acName, kWritingHeader.acName);
  rkLumpHeader.byCheckSum = kWritingHeader.byCheckSum;
  rkLumpHeader.ulFlags = kWritingHeader.ulFlags;
  rkLumpHeader.ulSize = kWritingHeader.ulSize;
  rkLumpHeader.ulSizeUncompressed = kWritingHeader.ulSize;

  return pEncryptedData;
}


//--------------------------------------------------------------------------------------------------
// Name:	      CompressEncryptLump
// Parent:	    slCResourceFile
// Author:      Bruno Sousa (BS)
// Created in:  15-04-2001 8:22:02
// Version:     1.00.00
// 
// Description: Encrypts and compressed a file.
// Remarks:     Compressing algorithm (RLE) doesn't work in all cases, removed until another one can
//              be implement.
//--------------------------------------------------------------------------------------------------
unsigned char* slCResourceFile::CompressEncryptLump (slSLumpWritingHeader kWritingHeader, slSLumpHeader& rkLumpHeader)
{
  unsigned char* pOriginalData;
  unsigned long   tulPosition;

  pOriginalData = new unsigned char [kWritingHeader.ulSize];
  
  // read original data
  ifstream fInput;
  fInput.open (kWritingHeader.acFileName, ios::in | ios::binary);
  fInput.read (pOriginalData,kWritingHeader.ulSize);
  fInput.close ();

	for (tulPosition = 0; tulPosition < kWritingHeader.ulSize; tulPosition++)
	{
		pOriginalData [tulPosition] = pOriginalData [tulPosition] ^ kWritingHeader.byCheckSum;
	}
  
  // set the lump information and data
  strcpy (rkLumpHeader.acName, kWritingHeader.acName);
  rkLumpHeader.byCheckSum = kWritingHeader.byCheckSum;
  rkLumpHeader.ulFlags = kWritingHeader.ulFlags;
  rkLumpHeader.ulSize = kWritingHeader.ulSize;
  rkLumpHeader.ulSizeUncompressed = kWritingHeader.ulSize;

  return pOriginalData;

}


//--------------------------------------------------------------------------------------------------
// Name:	      Build resouce
// Parent:	    slCResourceFile
// Author:      Bruno Sousa (BS)
// Created in:  15-04-2001 8:29:02
// Version:     1.00.00
// 
// Description: Builds a resource file.
// Remarks:     None.
//--------------------------------------------------------------------------------------------------
void slCResourceFile::BuildResource (char* pstrFileName, long iNumberLumps, slSLumpWritingHeader *pkWritingHeader)
{
  ofstream fResource;
  slSResourceHeader kResourceHeader;

  fResource.open (pstrFileName, ios::out | ios::binary);

  strcpy (kResourceHeader.acSignature, "SealRFS");
  kResourceHeader.ulFlags = 0;
  kResourceHeader.ulNumberOfLumps = iNumberLumps;
  kResourceHeader.ulOffset = sizeof (slSResourceHeader);
  kResourceHeader.ulVersion = 1;

  fResource.write ((unsigned char*)&kResourceHeader, sizeof (slSResourceHeader));

  long iLump;

  unsigned char *pData;
  slSLumpHeader kLumpHeader;

  for (iLump=0; iLump < iNumberLumps; iLump++)
  {
			// lump compressed and encrypted
			if (pkWritingHeader [iLump].ulFlags & slLumpCompressedEncrypted)
			{
        pData = CompressEncryptLump (pkWritingHeader [iLump], kLumpHeader);
        fResource.write ((unsigned char*)&kLumpHeader, sizeof (slSLumpHeader));
        fResource.write (pData, kLumpHeader.ulSize);
        delete [] pData;
			}
			// lump compressed
			else if (pkWritingHeader [iLump].ulFlags & slLumpCompressed)
			{
        pData = CompressLump (pkWritingHeader [iLump], kLumpHeader);
        fResource.write ((unsigned char*)&kLumpHeader, sizeof (slSLumpHeader));
        fResource.write (pData, kLumpHeader.ulSize);
        delete [] pData;
			}
			// lump encrypted
			else if (pkWritingHeader [iLump].ulFlags & slLumpEncrypted)
			{
        pData = EncryptLump (pkWritingHeader [iLump], kLumpHeader);
        fResource.write ((unsigned char*)&kLumpHeader, sizeof (slSLumpHeader));
        fResource.write (pData, kLumpHeader.ulSize);
        delete [] pData;
			}
			// raw lump
			else
			{
        pData = new unsigned char [pkWritingHeader [iLump].ulSize];
  
	      // read the data from the file
        ifstream kFileRaw;
        kFileRaw.open (pkWritingHeader [iLump].acFileName, ios::in | ios::binary);
        kFileRaw.read (pData, pkWritingHeader [iLump].ulSize);
        kFileRaw.close ();
        // set the lump information
        strcpy (kLumpHeader.acName, pkWritingHeader [iLump].acName);
        kLumpHeader.byCheckSum = pkWritingHeader [iLump].byCheckSum;
        kLumpHeader.ulFlags = pkWritingHeader [iLump].ulFlags;
        kLumpHeader.ulSize = pkWritingHeader [iLump].ulSize;
        kLumpHeader.ulSizeUncompressed = pkWritingHeader [iLump].ulSize;
  
        // write the data to file
        fResource.write ((unsigned char*)&kLumpHeader, sizeof (slSLumpHeader));
        fResource.write (pData, kLumpHeader.ulSize);

        delete []pData;
			}
  }

  fResource.close ();
}


	//------------------
	// End of file