Пример #1
0
CString TitanicEngine::getSavegameName(int slot) {
	// Try and open up the savegame for access
	Common::InSaveFile *in = g_system->getSavefileManager()->openForLoading(
		generateSaveName(slot));

	if (in) {
		// Read in the savegame header data
		CompressedFile file;
		file.open(in);

		TitanicSavegameHeader header;
		bool isValid = CProjectItem::readSavegameHeader(&file, header);
		if (header._thumbnail) {
			header._thumbnail->free();
			delete header._thumbnail;
		}

		file.close();

		if (isValid)
			// Set the name text
			return header._saveName;
	}

	return CString();
}
Пример #2
0
void CPetLoadSave::resetSlots() {
	for (int idx = 0; idx < SAVEGAME_SLOTS_COUNT; ++idx) {
		_slotNames[idx].setText(EMPTY);
		_slotInUse[idx] = false;

		// Try and open up the savegame for access
		Common::InSaveFile *in = g_system->getSavefileManager()->openForLoading(
			g_vm->generateSaveName(idx));

		if (in) {
			// Read in the savegame header data
			CompressedFile file;
			file.open(in);

			TitanicSavegameHeader header;
			if (CProjectItem::readSavegameHeader(&file, header)) {
				_slotInUse[idx] = true;
				_slotNames[idx].setText(header._saveName);
			}

			if (header._thumbnail) {
				header._thumbnail->free();
				delete header._thumbnail;
			}

			file.close();
		}
	}

	highlightSlot(_savegameSlotNum);
}
Пример #3
0
 MeshVersion getMeshVersion(const std::string& filename)
 {
     CompressedFile file;
     file.open(filename, ios::in | ios::binary);
     if (file.is_open())
     {
         MeshVersion version;
         file.read(reinterpret_cast<char*>(&version), sizeof(MeshVersion));
         file.close();
         return version;
     }
     return MeshVersion{};
 }
Пример #4
0
// Removes specified files from zip
void ZipFile::Remove(String* FileSpec, Boolean RecurseSubdirectories)
{
	ZipFile* tempZipFile;
	OpenFileForUnzip();

	// Just wrapping in a try/catch/finally to make sure temp zip file gets removed
	try
	{
		Regex* filePattern = GetFilePatternRegularExpression(FileSpec, caseSensitive);
		IEnumerator* filesEnum = files->GetEnumerator();
		CompressedFile* file;

		// Create temporary zip file to hold remove results
		tempZipFile = CreateTempZipFile();

		// Loop through compressed file collection
		while (filesEnum->MoveNext())
		{
			file = static_cast<CompressedFile*>(filesEnum->Current);

			// We copy all files into destination zip file except those user requested to be removed...
			if (!filePattern->IsMatch(GetSearchFileName(FileSpec, file->get_FileName(), RecurseSubdirectories)))
				CopyFileInZip(file, this, tempZipFile, S"Remove Zip File");
		}

		// Now make the temp file the new zip file
		Close();
		tempZipFile->Close();
		File::Delete(fileName);
		File::Move(tempZipFile->fileName, fileName);
	}
	catch (CompressionException* ex)		
	{
		// We just rethrow any errors back to user
		throw ex;
	}
	catch (Exception* ex)
	{
		throw ex;
	}
	__finally
	{
		// If everything went well, temp zip will no longer exist, but just in case we tidy up and delete the temp file...
		DeleteTempZipFile(tempZipFile);
	}

	// We'll reload the file list after remove if requested...
	if (autoRefresh) Refresh();
}
Пример #5
0
    void Mesh::saveToMemory(std::vector<char>& mem)
    {
        CompressedFile file;
        file.open(mem, ios::out | ios::binary);
        if (file.is_open())
        {
            file.write(reinterpret_cast<const char*>(&SupportedMeshVersion), sizeof(MeshVersion));
            for (const auto& mesh : m_subMeshes)
            {
                mesh.save(file);
            }

            file.close();
        }
    }
Пример #6
0
void CProjectItem::loadGame(int slotId) {
    CompressedFile file;

    // Clear any existing project contents and call preload code
    preLoad();
    clear();

    // Open either an existing savegame slot or the new game template
    if (slotId >= 0) {
        Common::InSaveFile *saveFile = g_system->getSavefileManager()->openForLoading(
                                           g_vm->generateSaveName(slotId));
        file.open(saveFile);
    } else {
        Common::File *newFile = new Common::File();
        if (!newFile->open("newgame.st"))
            error("Could not open newgame.st");
        file.open(newFile);
    }

    // Load the savegame header in
    TitanicSavegameHeader header;
    readSavegameHeader(&file, header);
    delete header._thumbnail;

    // Load the contents in
    CProjectItem *newProject = loadData(&file);
    file.IsClassStart();
    getGameManager()->load(&file);

    file.close();

    // Clear existing project
    clear();

    // Detach each item under the loaded project, and re-attach them
    // to the existing project instance (this)
    CTreeItem *item;
    while ((item = newProject->getFirstChild()) != nullptr) {
        item->detach();
        item->addUnder(this);
    }

    // Loaded project instance is no longer needed
    newProject->destroyAll();

    // Post-load processing
    postLoad();
}
Пример #7
0
void CProjectItem::saveGame(int slotId, const CString &desc) {
    CompressedFile file;
    Common::OutSaveFile *saveFile = g_system->getSavefileManager()->openForSaving(
                                        g_vm->generateSaveName(slotId), false);
    file.open(saveFile);

    // Signal the game is being saved
    preSave();

    // Write out the savegame header
    TitanicSavegameHeader header;
    header._saveName = desc;
    writeSavegameHeader(&file, header);

    // Save the contents out
    saveData(&file, this);

    // Save the game manager data
    _gameManager->save(&file);

    // Close the file and signal that the saving has finished
    file.close();
    postSave();
}
Пример #8
0
    void Mesh::load(ModelResources& modelResources)
    {
        CompressedFile file;
        file.open(m_filename, ios::in | ios::binary);
        if (file.is_open())
        {
            MeshVersion version;
            file.read(reinterpret_cast<char*>(&version), sizeof(MeshVersion));

            while (!file.eof())
            {
                m_subMeshes.emplace_back(SubMesh());
                if (!m_subMeshes.back().load(modelResources, file))
                {
                    m_subMeshes.pop_back();
                }
            }

            file.close();
        }
    }
Пример #9
0
// This internal function copies each file into a temporary zip that matches file specification, then does this for each subdirectory if requested
void ZipFile::UpdateFilesInZip(ZipFile* TempZipFile, String* FileSpec, String* CurrDirectory, int RootPathLength, UpdateOption UpdateWhen, Boolean AddNewFiles, Boolean RecurseSubdirectories, PathInclusion AddPathMethod, char* Password)
{
	IEnumerator* filesEnum = Directory::GetFiles(CurrDirectory, FileSpec)->GetEnumerator();
	String* fullFileName;
	String* adjustedFileName;
	CompressedFile* file;
	DateTime lastUpdate;
	bool updateFile;

	while (filesEnum->MoveNext())
	{
		fullFileName = filesEnum->Current->ToString();
		adjustedFileName = GetAdjustedFileName(fullFileName, RootPathLength, AddPathMethod);

		if (file = files->get_Item(adjustedFileName))
		{
			lastUpdate = File::GetLastWriteTime(fullFileName);

			switch (UpdateWhen)
			{
				case UpdateOption::Never:
					updateFile = false;
					break;
				case UpdateOption::Always:
					updateFile = true;
					break;
				case UpdateOption::ZipFileIsNewer:
					updateFile = (DateTime::Compare(file->get_FileDateTime(), lastUpdate) > 0);
					break;
				case UpdateOption::DiskFileIsNewer:
					updateFile = (DateTime::Compare(file->get_FileDateTime(), lastUpdate) < 0);
					break;
				default:
					updateFile = false;
					break;
			}

			if (updateFile)
			{
				// Need to update compressed file from disk, so we add the it the new temporary archive
				AddFileToZip(TempZipFile, this, fullFileName, adjustedFileName, Password, S"Update Zip File");
			}
			else
			{
				// Otherwise we just copy the compressed file from the original archive
				CopyFileInZip(file, this, TempZipFile, S"Update Zip File");
			}
		}
		else if (AddNewFiles)
		{
			// This was a new file so we just add it the new zip, if requested...
			AddFileToZip(TempZipFile, this, fullFileName, adjustedFileName, Password, S"Update Zip File");
		}
	}

	if (RecurseSubdirectories)
	{
		IEnumerator* dirsEnum = Directory::GetDirectories(CurrDirectory, "*")->GetEnumerator();

		while (dirsEnum->MoveNext())
			UpdateFilesInZip(TempZipFile, FileSpec, dirsEnum->Current->ToString(), RootPathLength, UpdateWhen, AddNewFiles, RecurseSubdirectories, AddPathMethod, Password);
	}
}
Пример #10
0
// Extracts specified files from zip
void ZipFile::Extract(String* FileSpec, String* DestPath, UpdateOption OverwriteWhen, Boolean RecurseSubdirectories, PathInclusion CreatePathMethod)
{
	// Any file spec in destination path will be ignored
	DestPath = JustPath(DestPath);

	char* pszPassword = NULL;
	char* pszFileName = NULL;
	OpenFileForUnzip();

	// Just wrapping in a try/catch/finally to make sure unmanaged code allocations always get released
	try
	{
		Regex* filePattern = GetFilePatternRegularExpression(FileSpec, caseSensitive);
		IEnumerator* filesEnum = files->GetEnumerator();
		CompressedFile* file;
		String* sourceFileName;
		String* destFileName;
		bool writeFile;
 		int err;

		// Get ANSI password, if one was provided
		if (password)
			if (password->get_Length())
				pszPassword = StringToCharBuffer(password);

		// Loop through compressed file collection
		while (filesEnum->MoveNext())
		{
			file = static_cast<CompressedFile*>(filesEnum->Current);
			sourceFileName = file->get_FileName();

			if (filePattern->IsMatch(GetSearchFileName(FileSpec, sourceFileName, RecurseSubdirectories)))
			{
				pszFileName = StringToCharBuffer(sourceFileName);
				err = unzLocateFile(hUnzipFile, pszFileName, (caseSensitive ? 1 : 2));
				free(pszFileName);
				pszFileName = NULL;

				// We should find file in zip file if it was in our compressed file collection
				if (err != Z_OK) throw new CompressionException(String::Concat(S"Extract Zip File Error: Compressed file \"", sourceFileName, "\" cannot be found in zip file!"));

				// Open compressed file for unzipping
				if (pszPassword)
					err = unzOpenCurrentFilePassword(hUnzipFile, pszPassword);
				else
					err = unzOpenCurrentFile(hUnzipFile);

				if (err != Z_OK) throw new CompressionException(S"Extract Zip File", err);

				// Get full destination file name
				switch (CreatePathMethod)
				{
					case PathInclusion::FullPath:
						destFileName = sourceFileName;
						break;
					case PathInclusion::NoPath:
						destFileName = String::Concat(DestPath, Path::GetFileName(sourceFileName));
						break;
					case PathInclusion::RelativePath:
						destFileName = String::Concat(DestPath, sourceFileName);
						break;
				}

				// Make sure destination directory exists
				Directory::CreateDirectory(JustPath(destFileName));

				// See if destination file already exists
				if (File::Exists(destFileName))
				{
					DateTime lastUpdate = File::GetLastWriteTime(destFileName);

					switch (OverwriteWhen)
					{
						case UpdateOption::Never:
							writeFile = false;
							break;
						case UpdateOption::Always:
							writeFile = true;
							break;
						case UpdateOption::ZipFileIsNewer:
							writeFile = (DateTime::Compare(file->get_FileDateTime(), lastUpdate) > 0);
							break;
						case UpdateOption::DiskFileIsNewer:
							writeFile = (DateTime::Compare(file->get_FileDateTime(), lastUpdate) < 0);
							break;
						default:
							writeFile = false;
							break;
					}
				}
				else
					writeFile = true;

				if (writeFile)
				{
					System::Byte buffer[] = new System::Byte[BufferSize];
					System::Byte __pin * destBuff = &buffer[0];	// pin buffer so it can be safely passed into unmanaged code...
					FileStream* fileStream = File::Create(destFileName);
					int read;
					__int64 total = 0, len = -1;

					// Send initial progress event
					len = file->get_UncompressedSize();
					CurrentFile(destFileName, sourceFileName);
					FileProgress(0, len);					

					// Read initial buffer
					read = unzReadCurrentFile(hUnzipFile, destBuff, buffer->get_Length());
					if (read < 0) throw new CompressionException(S"Extract Zip File", read);

					while (read)
					{
						// Write data to file stream,
						fileStream->Write(buffer, 0, read);

						// Raise progress event
						total += read;
						FileProgress(total, len);

						// Read next buffer from source file stream
						read = unzReadCurrentFile(hUnzipFile, destBuff, buffer->get_Length());
						if (read < 0) throw new CompressionException(S"Extract Zip File", read);
					}

					fileStream->Close();
				}

				// Close compressed file
				unzCloseCurrentFile(hUnzipFile);
			}
		}
	}
	catch (CompressionException* ex)		
	{
		// We just rethrow any errors back to user
		throw ex;
	}
	catch (Exception* ex)
	{
		throw ex;
	}
	__finally
	{
		if (pszPassword)
			free(pszPassword);

		if (pszFileName)
			free(pszFileName);
	}
}
Пример #11
0
CompressionTest::CompressionTest(const std::string& testFile, CompressionTypes type)
{
    ifstream in;
    in.open(testFile, ios::binary);
    std::vector<char> inBuf;
    in.seekg(0, ios::end);
    size_t inSize = static_cast<size_t>(in.tellg());
    inBuf.resize(inSize);
    in.seekg(0, ios::beg);
    in.read(&inBuf[0], static_cast<streamsize>(inSize));
    in.close();

    CompressedFile outCompress;
    outCompress.open(testFile + ".compressed", ios::out | ios::binary, type);
    outCompress.write(&inBuf[0], static_cast<streamsize>(inSize));
    outCompress.close();

    CompressedFile inCompress;
    inCompress.open(testFile + ".compressed", ios::in | ios::binary);
    std::vector<char> resInBuf;
    inCompress.seekg(0, ios::end);
    size_t inCompressSize = inCompress.tellg();
    inCompress.seekg(0, ios::beg);
    resInBuf.resize(inCompressSize);
    inCompress.read(&resInBuf[0], static_cast<streamsize>(inCompressSize));
    inCompress.close();

    ofstream out;
    out.open(testFile + ".result", ios::binary);
    out.write(&resInBuf[0], static_cast<streamsize>(inCompressSize));
    out.close();

    // is the original file the same size as the resulting file
    ASSERT(inSize == inCompressSize);

    // is the content identical
    for (size_t i = 0; i < inSize; ++i)
    {
        ASSERT(inBuf[i] == resInBuf[i]);
    }
}