Файл SaveLoad.cpp

См. исходные тексты.

Функции
bool	CopyFile (const String &from, const String &to)
void	LoadGame (unsigned int uSlot)
void	SaveGame (bool IsAutoSAve, bool NotSaveWorld)
void	DoSavegame (unsigned int uSlot)
void	SaveNewGame ()

Переменные
struct SavegameList *	pSavegameList = new SavegameList
unsigned int	uNumSavegameFiles
std::array< unsigned int, MAX_SAVE_SLOTS >	pSavegameUsedSlots
std::array< Image *, MAX_SAVE_SLOTS >	pSavegameThumbnails
std::array< SavegameHeader, MAX_SAVE_SLOTS >	pSavegameHeader

Функции

CopyFile()

bool CopyFile	(	const String &	from,
		const String &	to
	)

См. определение в файле SaveLoad.cpp строка 47

                                                    {
    int file_size = -1;
    int bytes_read = 0;
    int bytes_wrote = 0;
 
    FILE *copy_from = fopen(from.c_str(), "rb");
    if (copy_from) {
        FILE *copy_to = fopen(to.c_str(), "wb+");
        if (copy_to) {
            fseek(copy_from, 0, SEEK_END);
            file_size = ftell(copy_from);
            fseek(copy_from, 0, SEEK_SET);
 
            unsigned char *buf = new unsigned char[file_size];
            if (buf) {
                bytes_read = fread(buf, 1, file_size, copy_from);
                if (bytes_read == file_size) {
                    bytes_wrote = fwrite(buf, 1, file_size, copy_to);
                }
 
                delete[] buf;
            }
            fclose(copy_to);
        }
        fclose(copy_from);
    }
 
    return file_size != -1 && bytes_read == bytes_wrote;
}

Используется в DoSavegame(), LoadGame() и SaveGame().

Граф вызова функции:

LoadGame()

void LoadGame

(

unsigned int

uSlot

)

См. определение в файле SaveLoad.cpp строка 77

                                  {
    MapsLongTimers_count = 0;
    if (!pSavegameUsedSlots[uSlot]) {
        pAudioPlayer->PlaySound(SOUND_error, 0, 0, -1, 0, 0);
        logger->Warning(L"LoadGame: slot %u is empty", uSlot);
        return;
    }
 
    pNew_LOD->CloseWriteFile();
 
    String filename = "saves\\" + pSavegameList->pFileList[uSlot];
    filename = MakeDataPath(filename.c_str());
    String to_file_path = MakeDataPath("data\\new.lod");
    remove(to_file_path.c_str());
    if (!CopyFile(filename, to_file_path)) {
        Error("Failed to copy: %s", filename.c_str());
    }
 
    pNew_LOD->LoadFile(to_file_path, 0);
 
    static_assert(sizeof(SavegameHeader) == 100, "Wrong type size");
    SavegameHeader *header = (SavegameHeader*)pNew_LOD->LoadRaw("header.bin");
    if (header == nullptr) {
        logger->Warning(L"%S", localization->FormatString(612, 100).c_str());  // Savegame damaged! Code=%d
    }
 
    {
        Party_Image_MM7 *serialization = (Party_Image_MM7*)pNew_LOD->LoadRaw("party.bin");
        if (serialization == nullptr) {
            logger->Warning(L"%S", localization->FormatString(612, 101).c_str());  // Savegame damaged! Code=%d
        } else {
            serialization->Deserialize(pParty);
            free(serialization);
 
            for (size_t i = 0; i < 4; i++) {
                Player *player = &pParty->pPlayers[i];
                for (size_t j = 0; j < 5; j++) {
                    if (j >= player->vBeacons.size()) {
                        continue;
                    }
                    LloydBeacon &beacon = player->vBeacons[j];
                    String str = StringPrintf("lloyd%d%d.pcx", i + 1, j + 1);
                    beacon.image = Image::Create(new PCX_LOD_File_Loader(pNew_LOD, str));
                    beacon.image->GetWidth();
                }
            }
        }
    }
 
    {
        Timer_Image_MM7 *serialization = (Timer_Image_MM7*)pNew_LOD->LoadRaw("clock.bin");
        if (serialization == nullptr) {
            logger->Warning(L"%S", localization->FormatString(612, 102).c_str());  // Savegame damaged! Code=%d
        } else {
            serialization->Deserialize(pEventTimer);
            free(serialization);
        }
    }
 
    {
        OtherOverlayList_Image_MM7 *serialization = (OtherOverlayList_Image_MM7*)pNew_LOD->LoadRaw("overlay.bin");
        if (serialization == nullptr) {
            logger->Warning(L"%S", localization->FormatString(612, 103).c_str());  // Savegame damaged! Code=%d
        } else {
            serialization->Deserialize(pOtherOverlayList);
            free(serialization);
        }
    }
 
    {
        NPCData_Image_MM7 *serialization = (NPCData_Image_MM7*)pNew_LOD->LoadRaw("npcdata.bin");
        if (serialization == nullptr) {
            logger->Warning(L"%S", localization->FormatString(612, 104).c_str());  // Savegame damaged! Code=%d
        } else {
            for (unsigned int i = 0; i < 501; ++i) {
                serialization[i].Deserialize(pNPCStats->pNewNPCData + i);
            }
            pNPCStats->_476C60_on_load_game();
            free(serialization);
        }
    }
 
    {
        void *npcgroup = pNew_LOD->LoadRaw("npcgroup.bin");
        if (npcgroup == nullptr) {
            logger->Warning(L"%S", localization->FormatString(612, 105).c_str());  // Savegame damaged! Code=%d
            __debugbreak();
        } else if (sizeof(pNPCStats->pGroups_copy) != 102) {
            logger->Warning(L"NPCStats: deserialization warning");
        } else {
            memcpy(pNPCStats->pGroups_copy, npcgroup, sizeof(pNPCStats->pGroups_copy));
        }
        free(npcgroup);
    }
 
    uActiveCharacter = 0;
    for (uint i = 0; i < 4; ++i) {
        if (pParty->pPlayers[i].CanAct()) {
            uActiveCharacter = i + 1;
            break;
        }
    }
/*
    for (uint i = 0; i < 4; ++i) {
        if (pParty->pPlayers[i].uQuickSpell) {
            AA1058_PartyQuickSpellSound[i].AddPartySpellSound(
                pParty->pPlayers[i].uQuickSpell, i + 1);
        }
 
        for (uint j = 0; j < 2; ++j) {
            uint uEquipIdx = pParty->pPlayers[i].pEquipment.pIndices[j];
            if (uEquipIdx) {
                int pItemID = pParty->pPlayers[i]
                                  .pInventoryItemList[uEquipIdx - 1]
                                  .uItemID;
                if (pItemsTable->pItems[pItemID].uEquipType == EQUIP_WAND &&
                    pItemID) {       // жезл
                    __debugbreak();  // looks like offset in player's inventory
                                     // and wand_lut much like case in 0042ECB5
                    stru_A750F8[i].AddPartySpellSound(
                        wand_spell_ids[pItemID - ITEM_WAND_FIRE], i + 9);
                }
            }
        }
    }
*/
    current_screen_type = CURRENT_SCREEN::SCREEN_GAME;
 
    viewparams->bRedrawGameUI = true;
 
    SetUserInterface(pParty->alignment, true);
 
    pEventTimer->Resume();
    pEventTimer->StopGameTime();
 
    if (!pGames_LOD->DoesContainerExist(header->pLocationName)) {
        Error("Unable to find: %s!", header->pLocationName);
    }
 
    pCurrentMapName = header->pLocationName;
    free(header);
 
    dword_6BE364_game_settings_1 |= GAME_SETTINGS_2000 | GAME_SETTINGS_0001;
 
    for (uint i = 0; i < uNumSavegameFiles; ++i) {
        if (pSavegameThumbnails[i] != nullptr) {
            pSavegameThumbnails[i]->Release();
            pSavegameThumbnails[i] = nullptr;
        }
    }
 
    pAudioPlayer->SetMusicVolume(engine->config->music_level);
    pAudioPlayer->SetMasterVolume(engine->config->sound_level);
    if (engine->config->turn_speed > 0) {
        pParty->sRotationY = engine->config->turn_speed * pParty->sRotationY / engine->config->turn_speed;
    }
    MM7Initialization();
    bFlashQuestBook = false;
    viewparams->bRedrawGameUI = true;
}

Перекрестные ссылки NPCStats::_476C60_on_load_game(), __debugbreak(), Party::alignment, bFlashQuestBook, ViewingParams::bRedrawGameUI, LOD::WriteableFile::CloseWriteFile(), CopyFile(), Image::Create(), current_screen_type, NPCData_Image_MM7::Deserialize(), Party_Image_MM7::Deserialize(), Timer_Image_MM7::Deserialize(), OtherOverlayList_Image_MM7::Deserialize(), LOD::File::DoesContainerExist(), dword_6BE364_game_settings_1, engine, Localization::FormatString(), Image::GetWidth(), LloydBeacon::image, LOD::WriteableFile::LoadFile(), LOD::File::LoadRaw(), localization, logger, MakeDataPath(), MapsLongTimers_count, MM7Initialization(), pAudioPlayer, pCurrentMapName, pEventTimer, SavegameList::pFileList, pGames_LOD, NPCStats::pGroups_copy, AudioPlayer::PlaySound(), SavegameHeader::pLocationName, pNew_LOD, NPCStats::pNewNPCData, pNPCStats, pOtherOverlayList, pParty, Party::pPlayers, pSavegameList, pSavegameThumbnails, pSavegameUsedSlots, Timer::Resume(), SCREEN_GAME, AudioPlayer::SetMasterVolume(), AudioPlayer::SetMusicVolume(), SetUserInterface(), SOUND_error, Party::sRotationY, Timer::StopGameTime(), StringPrintf(), uActiveCharacter, uNumSavegameFiles, Player::vBeacons, viewparams и Log::Warning().

Используется в Application::Menu::EventLoop() и Application::Game::GameLoop().

Граф вызовов:

Граф вызова функции:

SaveGame()

void SaveGame	(	bool	IsAutoSAve,
		bool	NotSaveWorld
	)

См. определение в файле SaveLoad.cpp строка 238

                                                  {
    s_SavedMapName = pCurrentMapName;
    if (pCurrentMapName == "d05.blv") {  // arena
        return;
    }
 
    char *uncompressed_buff = (char *)malloc(1000000);
 
    int pPositionX = pParty->vPosition.x;
    int pPositionY = pParty->vPosition.y;
    int pPositionZ = pParty->vPosition.z;
    int sPRotationY = pParty->sRotationY;
    int sPRotationX = pParty->sRotationX;
    pParty->vPosition.x = pParty->vPrevPosition.x;
    pParty->vPosition.z = pParty->vPrevPosition.z;
    pParty->vPosition.y = pParty->vPrevPosition.y;
 
    pParty->uFallStartY = pParty->vPrevPosition.z;
 
    pParty->sRotationY = pParty->sPrevRotationY;
    pParty->sRotationX = pParty->sPrevRotationX;
    if (uCurrentlyLoadedLevelType == LEVEL_Indoor)
        pIndoor->stru1.last_visit = pParty->GetPlayingTime();
    else
        pOutdoor->loc_time.last_visit = pParty->GetPlayingTime();
 
    unsigned int buf_size = 0;
    render->PackScreenshot(150, 112, uncompressed_buff, 1000000, &buf_size);  // создание скриншота
 
    // saving - please wait
 
    // if (current_screen_type == SCREEN_SAVEGAME) {
    //    render->DrawTextureAlphaNew(8 / 640.0f, 8 / 480.0f,
    //        saveload_ui_loadsave);
    //    render->DrawTextureAlphaNew(18 / 640.0f, 141 / 480.0f,
    //        saveload_ui_loadsave);
    //    int text_pos = pFontSmallnum->AlignText_Center(186, localization->GetString(190));
    //    pGUIWindow_CurrentMenu->DrawText(pFontSmallnum, text_pos + 25, 219, 0,
    //        localization->GetString(190), 0, 0,
    //        0);  // Сохранение
    //    text_pos = pFontSmallnum->AlignText_Center(
    //        186, pSavegameHeader[uLoadGameUI_SelectedSlot].pName);
    //    pGUIWindow_CurrentMenu->DrawTextInRect(
    //        pFontSmallnum, text_pos + 25, 259, 0,
    //        pSavegameHeader[uLoadGameUI_SelectedSlot].pName, 185, 0);
    //    text_pos =
    //        pFontSmallnum->AlignText_Center(186, localization->GetString(165));
    //    pGUIWindow_CurrentMenu->DrawText(pFontSmallnum, text_pos + 25, 299, 0,
    //        localization->GetString(165), 0, 0,
    //        0);  // Пожалуйста, подождите
    //    render->Present();
    //}
 
    if (pNew_LOD->Write("image.pcx", uncompressed_buff, buf_size, 0)) {
        auto error_message = localization->FormatString(612, 200);  // Savegame damaged! Code=%d
        logger->Warning(L"%S", error_message.c_str());
    }
 
    static_assert(sizeof(SavegameHeader) == 100, "Wrong type size");
    SavegameHeader save_header;
    memset(save_header.pName, 0, 20);
    memset(save_header.pLocationName, 0, 20);
    memset(save_header.field_30, 0, 52);
    strcpy(save_header.pLocationName, pCurrentMapName.c_str());
    save_header.playing_time = pParty->GetPlayingTime();
    if (pNew_LOD->Write("header.bin", &save_header, sizeof(SavegameHeader), 0)) {
        auto error_message = localization->FormatString(612, 201);
        logger->Warning(L"%S", error_message.c_str());
    }
 
    {
        Party_Image_MM7 serialization;
        serialization.Serialize(pParty);
 
        if (pNew_LOD->Write("party.bin", &serialization, sizeof(serialization), 0)) {
            auto error_message = localization->FormatString(612, 202);
            logger->Warning(L"%S", error_message.c_str());
        }
    }
 
    {
        Timer_Image_MM7 serialization;
        serialization.Serialize(pEventTimer);
 
        if (pNew_LOD->Write("clock.bin", &serialization, sizeof(serialization), 0)) {
            auto error_message = localization->FormatString(612, 203);
            logger->Warning(L"%S", error_message.c_str());
        }
    }
 
    {
        OtherOverlayList_Image_MM7 serialization;
        serialization.Serialize(pOtherOverlayList);
 
        if (pNew_LOD->Write("overlay.bin", &serialization, sizeof(serialization), 0)) {
            auto error_message = localization->FormatString(612, 204);
            logger->Warning(L"%S", error_message.c_str());
        }
    }
 
    {
        NPCData_Image_MM7 serialization[501];
        for (unsigned int i = 0; i < 501; ++i) {
            serialization[i].Serialize(pNPCStats->pNewNPCData + i);
        }
 
        if (pNew_LOD->Write("npcdata.bin", serialization, sizeof(serialization), 0)) {
            auto error_message = localization->FormatString(612, 205);
            logger->Warning(L"%S", error_message.c_str());
        }
    }
 
    if (pNew_LOD->Write("npcgroup.bin", pNPCStats->pGroups_copy, sizeof(pNPCStats->pGroups_copy), 0)) {
        auto error_message = localization->FormatString(612, 206);
        logger->Warning(L"%S", error_message.c_str());
    }
 
    for (size_t i = 0; i < 4; ++i) {  // 4 - players
        Player *player = &pParty->pPlayers[i];
        for (size_t j = 0; j < 5; ++j) {  // 5 - images
            if (j >= player->vBeacons.size()) {
                continue;
            }
            LloydBeacon *beacon = &player->vBeacons[j];
            Image *image = beacon->image;
            if ((beacon->uBeaconTime != 0) && (image != nullptr)) {
                const void *pixels = image->GetPixels(IMAGE_FORMAT_R5G6B5);
                unsigned int pcx_data_size = 30000;
                void *pcx_data = malloc(pcx_data_size);
                PCX::Encode16(pixels, image->GetWidth(), image->GetHeight(),
                              pcx_data, pcx_data_size, &pcx_data_size);
                String str = StringPrintf("lloyd%d%d.pcx", i + 1, j + 1);
                if (pNew_LOD->Write(str, pcx_data, pcx_data_size, 0)) {
                    auto error_message = localization->FormatString(612, 207);
                    logger->Warning(L"%S", error_message.c_str());
                }
                free(pcx_data);
            }
        }
    }
 
    if (!NotSaveWorld) {  // autosave for change location
        CompactLayingItemsList();
        char *compressed_buf = (char *)malloc(1000000);
        if (compressed_buf == nullptr) {
            logger->Warning(L"Malloc error");
            Error("Malloc");  // is this recoverable
        }
        ODMHeader *odm_data = (ODMHeader*)compressed_buf;
        odm_data->uVersion = 91969;
        odm_data->pMagic[0] = 'm';
        odm_data->pMagic[1] = 'v';
        odm_data->pMagic[2] = 'i';
        odm_data->pMagic[3] = 'i';
        odm_data->uCompressedSize = 0;
        odm_data->uDecompressedSize = 0;
 
        char *data_write_pos = uncompressed_buff;
        if (uCurrentlyLoadedLevelType == LEVEL_Indoor) {
            pIndoor->dlv.uNumFacesInBModels = pIndoor->uNumFaces;
            pIndoor->dlv.uNumBModels = 0;
            pIndoor->dlv.uNumDecorations = uNumLevelDecorations;
            memcpy(data_write_pos, &pIndoor->dlv, sizeof(DDM_DLV_Header));  // 0x28
            data_write_pos += sizeof(DDM_DLV_Header);
            memcpy(data_write_pos, pIndoor->_visible_outlines, 0x36B);
            data_write_pos += 875;
            for (int i = 0; i < (signed int)pIndoor->uNumFaces; ++i) {
                memcpy(data_write_pos, &pIndoor->pFaces[i].uAttributes, 4);
                data_write_pos += 4;
            }
 
            for (int i = 0; i < (signed int)uNumLevelDecorations; ++i) {
                memcpy(data_write_pos, &pLevelDecorations[i].uFlags, 2);
                data_write_pos += 2;
            }
            memcpy(data_write_pos, &uNumActors, 4);
            data_write_pos += 4;
            memcpy(data_write_pos, &pActors, uNumActors * sizeof(Actor));
            data_write_pos += uNumActors * sizeof(Actor);
            memcpy(data_write_pos, &uNumSpriteObjects, 4);
            data_write_pos += 4;
            memcpy(data_write_pos, pSpriteObjects.data(),
                   112 * uNumSpriteObjects);
            data_write_pos += 112 * uNumSpriteObjects;
 
            data_write_pos = ChestsSerialize(data_write_pos);
 
            memcpy(data_write_pos, pIndoor->pDoors, sizeof(BLVDoor) * 200);
            data_write_pos += 16000;
            memcpy(data_write_pos, pIndoor->ptr_0002B4_doors_ddata,
                   pIndoor->blv.uDoors_ddata_Size);
            data_write_pos += pIndoor->blv.uDoors_ddata_Size;
            memcpy(data_write_pos, &stru_5E4C90_MapPersistVars, 0xC8);
            data_write_pos += 200;
            memcpy(data_write_pos, &pIndoor->stru1, 0x38);
            data_write_pos += 56;
 
        } else {  // for Outdoor
            pOutdoor->ddm.uNumFacesInBModels = 0;
            for (BSPModel &model : pOutdoor->pBModels) {
                pOutdoor->ddm.uNumFacesInBModels += model.pFaces.size();
            }
            pOutdoor->ddm.uNumBModels = pOutdoor->pBModels.size();
            pOutdoor->ddm.uNumDecorations = uNumLevelDecorations;
            memcpy(data_write_pos, &pOutdoor->ddm,
                   sizeof(DDM_DLV_Header));  // 0x28
            data_write_pos += sizeof(DDM_DLV_Header);
            memcpy(data_write_pos, pOutdoor->uFullyRevealedCellOnMap, 0x3C8);
            data_write_pos += 968;
            memcpy(data_write_pos, pOutdoor->uPartiallyRevealedCellOnMap,
                   0x3C8);
            data_write_pos += 968;
            for (BSPModel &model : pOutdoor->pBModels) {
                for (ODMFace &face : model.pFaces) {
                    memcpy(data_write_pos, &(face.uAttributes), 4);
                    data_write_pos += 4;
                }
            }
 
            for (size_t i = 0; i < uNumLevelDecorations; ++i) {
                memcpy(data_write_pos, &pLevelDecorations[i].uFlags, 2);
                data_write_pos += 2;
            }
            memcpy(data_write_pos, &uNumActors, 4);
            data_write_pos += 4;
            memcpy(data_write_pos, &pActors, uNumActors * sizeof(Actor));
            data_write_pos += uNumActors * sizeof(Actor);
            memcpy(data_write_pos, &uNumSpriteObjects, 4);
            data_write_pos += 4;
            memcpy(data_write_pos, &pSpriteObjects,
                   uNumSpriteObjects * sizeof(SpriteObject));
            data_write_pos += uNumSpriteObjects * sizeof(SpriteObject);
 
            data_write_pos = ChestsSerialize(data_write_pos);
 
            memcpy(data_write_pos, &stru_5E4C90_MapPersistVars, 0xC8);
            data_write_pos += 200;
            memcpy(data_write_pos, &pOutdoor->loc_time, 0x38);
            data_write_pos += 56;
        }
 
        unsigned int compressed_block_size = 1000000 - sizeof(ODMHeader);
        size_t Size = data_write_pos - uncompressed_buff;
        int res = zlib::Compress(compressed_buf + sizeof(ODMHeader), &compressed_block_size, uncompressed_buff, Size);
        if (res || (compressed_block_size > Size)) {
            memcpy((void *)(compressed_buf + sizeof(ODMHeader)), uncompressed_buff, Size);
            compressed_block_size = Size;
        }
 
        odm_data->uCompressedSize = compressed_block_size;
        odm_data->uDecompressedSize = Size;
 
        String file_name = pCurrentMapName;
        size_t pos = file_name.find_last_of(".");
        file_name[pos + 1] = 'd';
        if (pNew_LOD->Write(file_name, compressed_buf, compressed_block_size + sizeof(ODMHeader), 0)) {
            auto error_message = localization->FormatString(612, 208);
            logger->Warning(L"%S", error_message.c_str());
        }
        free(compressed_buf);
    }
    free(uncompressed_buff);
    if (IsAutoSAve) {
        if (!CopyFile(MakeDataPath("data\\new.lod"),
                      MakeDataPath("saves\\autosave.mm7"))) {
            logger->Warning(L"Copy autosave.mm7 failed");
        }
    }
    pParty->vPosition.x = pPositionX;
    pParty->vPosition.y = pPositionY;
    pParty->vPosition.z = pPositionZ;
    pParty->uFallStartY = pPositionZ;
    pParty->sRotationY = sPRotationY;
    pParty->sRotationX = sPRotationX;
}

Перекрестные ссылки IndoorLocation::_visible_outlines, IndoorLocation::blv, ChestsSerialize(), CompactLayingItemsList(), zlib::Compress(), CopyFile(), OutdoorLocation::ddm, IndoorLocation::dlv, PCX::Encode16(), SavegameHeader::field_30, Localization::FormatString(), Image::GetPixels(), Party::GetPlayingTime(), LloydBeacon::image, IMAGE_FORMAT_R5G6B5, LocationTime_stru1::last_visit, LEVEL_Indoor, OutdoorLocation::loc_time, localization, logger, MakeDataPath(), pActors, OutdoorLocation::pBModels, pCurrentMapName, IndoorLocation::pDoors, pEventTimer, BSPModel::pFaces, IndoorLocation::pFaces, NPCStats::pGroups_copy, pIndoor, SavegameHeader::playing_time, pLevelDecorations, SavegameHeader::pLocationName, ODMHeader::pMagic, SavegameHeader::pName, pNew_LOD, NPCStats::pNewNPCData, pNPCStats, pOtherOverlayList, pOutdoor, pParty, Party::pPlayers, pSpriteObjects, IndoorLocation::ptr_0002B4_doors_ddata, render, s_SavedMapName, NPCData_Image_MM7::Serialize(), Party_Image_MM7::Serialize(), Timer_Image_MM7::Serialize(), OtherOverlayList_Image_MM7::Serialize(), Party::sPrevRotationX, Party::sPrevRotationY, Party::sRotationX, Party::sRotationY, StringPrintf(), IndoorLocation::stru1, stru_5E4C90_MapPersistVars, BLVFace::uAttributes, LloydBeacon::uBeaconTime, ODMHeader::uCompressedSize, uCurrentlyLoadedLevelType, ODMHeader::uDecompressedSize, BLVHeader::uDoors_ddata_Size, Party::uFallStartY, OutdoorLocation::uFullyRevealedCellOnMap, uNumActors, DDM_DLV_Header::uNumBModels, DDM_DLV_Header::uNumDecorations, IndoorLocation::uNumFaces, DDM_DLV_Header::uNumFacesInBModels, uNumLevelDecorations, uNumSpriteObjects, OutdoorLocation::uPartiallyRevealedCellOnMap, ODMHeader::uVersion, Player::vBeacons, Party::vPosition, Party::vPrevPosition, Log::Warning() и LOD::WriteableFile::Write().

Используется в DoSavegame(), Application::Game::EventLoop(), Application::Game::GameLoop(), SaveNewGame(), Transition_StopSound_Autosave() и TravelByTransport().

Граф вызовов:

Граф вызова функции:

DoSavegame()

void DoSavegame

(

unsigned int

uSlot

)

См. определение в файле SaveLoad.cpp строка 514

                                    {
    if (pCurrentMapName != "d05.blv") {  // Not Arena(не Арена)
        SaveGame(0, 0);
        strcpy(pSavegameHeader[uSlot].pLocationName, pCurrentMapName.c_str());
        pSavegameHeader[uSlot].playing_time = pParty->GetPlayingTime();
        pNew_LOD->Write("header.bin", &pSavegameHeader[uSlot], sizeof(SavegameHeader), 0);
        pNew_LOD->CloseWriteFile();  //закрыть
        String file_path = StringPrintf("saves\\save%03d.mm7", uSlot);
        file_path = MakeDataPath(file_path.c_str());
        CopyFile(MakeDataPath("data\\new.lod"), file_path);
    }
    GUI_UpdateWindows();
    pGUIWindow_CurrentMenu->Release();
    current_screen_type = CURRENT_SCREEN::SCREEN_GAME;
 
    viewparams->bRedrawGameUI = true;
    for (uint i = 0; i < MAX_SAVE_SLOTS; i++) {
        if (pSavegameThumbnails[i] != nullptr) {
            pSavegameThumbnails[i]->Release();
            pSavegameThumbnails[i] = nullptr;
        }
    }
 
    if (pCurrentMapName != "d05.blv")
        pNew_LOD->_4621A7();
    else
        GameUI_StatusBar_OnEvent(localization->GetString(583), 2);  // "No saving in the Arena"
 
    pEventTimer->Resume();
    GameUI_StatusBar_OnEvent(localization->GetString(656), 2);  // "Game Saved!"
    viewparams->bRedrawGameUI = true;
}

Перекрестные ссылки LOD::WriteableFile::_4621A7(), ViewingParams::bRedrawGameUI, LOD::WriteableFile::CloseWriteFile(), CopyFile(), current_screen_type, GameUI_StatusBar_OnEvent(), Party::GetPlayingTime(), Localization::GetString(), GUI_UpdateWindows(), localization, MakeDataPath(), MAX_SAVE_SLOTS, pCurrentMapName, pEventTimer, pGUIWindow_CurrentMenu, pNew_LOD, pParty, pSavegameHeader, pSavegameThumbnails, GUIWindow::Release(), Timer::Resume(), SaveGame(), SCREEN_GAME, StringPrintf(), viewparams и LOD::WriteableFile::Write().

Используется в Application::Menu::EventLoop().

Граф вызовов:

Граф вызова функции:

SaveNewGame()

void SaveNewGame

(

)

См. определение в файле SaveLoad.cpp строка 566

                   {
    if (pNew_LOD != nullptr) {
        pNew_LOD->CloseWriteFile();
    }
 
    String file_path = MakeDataPath("data\\new.lod");
    remove(file_path.c_str());  // удалить new.lod
 
    LOD::FileHeader header;  // заголовок
    strcpy(header.LodVersion, "MMVII");
    strcpy(header.LodDescription, "newmaps for MMVII");
    header.LODSize = 100;
    header.dword_0000A8 = 0;
 
    pNew_LOD->CreateNewLod(&header, "current", file_path);  // создаётся new.lod в дирректории
    if (pNew_LOD->LoadFile(file_path, false)) {  // загрузить файл new.lod(isFileOpened = true)
        pNew_LOD->CreateTempFile();  // создаётся временный файл OutputFileHandle
        pNew_LOD->ClearSubNodes();
 
        for (size_t i = pGames_LOD->GetSubNodesCount() / 2; i < pGames_LOD->GetSubNodesCount(); ++i) {  // копирование файлов с 76 по 151
            String name = pGames_LOD->GetSubNodeName(i);
            size_t size = 0;
            void *data = pGames_LOD->LoadRaw(name, &size);
            pNew_LOD->AppendDirectory(name, data, size);
            free(data);
        }
 
        strcpy(pSavegameHeader[0].pLocationName, "out01.odm");
        pNew_LOD->AppendDirectory("header.bin", &pSavegameHeader[0], sizeof(SavegameHeader));
 
        pNew_LOD->FixDirectoryOffsets();
 
        pParty->vPrevPosition.x = 12552;
        pParty->vPrevPosition.y = 1816;
        pParty->vPrevPosition.z = 0;
 
        pParty->vPosition.x = 12552;
        pParty->vPosition.y = 1816;
        pParty->vPosition.z = 0;
 
        pParty->uFallStartY = 0;
 
        pParty->sPrevRotationX = 0;
        pParty->sPrevRotationY = 512;
 
        pParty->sRotationX = 0;
        pParty->sRotationY = 512;
 
        SaveGame(1, 1);
    }
}

Перекрестные ссылки LOD::WriteableFile::AppendDirectory(), LOD::WriteableFile::ClearSubNodes(), LOD::WriteableFile::CloseWriteFile(), LOD::WriteableFile::CreateNewLod(), LOD::WriteableFile::CreateTempFile(), LOD::FileHeader::dword_0000A8, LOD::WriteableFile::FixDirectoryOffsets(), LOD::File::GetSubNodeName(), LOD::File::GetSubNodesCount(), LOD::WriteableFile::LoadFile(), LOD::File::LoadRaw(), LOD::FileHeader::LodDescription, LOD::FileHeader::LODSize, LOD::FileHeader::LodVersion, MakeDataPath(), pGames_LOD, pNew_LOD, pParty, pSavegameHeader, SaveGame(), Party::sPrevRotationX, Party::sPrevRotationY, Party::sRotationX, Party::sRotationY, Party::uFallStartY, Party::vPosition и Party::vPrevPosition.

Используется в Application::Game::Loop().

Граф вызовов:

Граф вызова функции:

Переменные

pSavegameList

struct SavegameList* pSavegameList = new SavegameList

См. определение в файле SaveLoad.cpp строка 41

Используется в GUIWindow_Load::GUIWindow_Load(), GUIWindow_Save::GUIWindow_Save(), SavegameList::Initialize() и LoadGame().

uNumSavegameFiles

unsigned int uNumSavegameFiles

См. определение в файле SaveLoad.cpp строка 42

Используется в GUIWindow_Load::GUIWindow_Load(), SavegameList::Initialize(), LoadGame() и UI_DrawSaveLoad().

pSavegameUsedSlots

std::array<unsigned int, MAX_SAVE_SLOTS> pSavegameUsedSlots

См. определение в файле SaveLoad.cpp строка 43

Используется в Application::Menu::EventLoop(), GUIWindow_Load::GUIWindow_Load(), GUIWindow_Save::GUIWindow_Save(), LoadGame(), MainMenuLoad_EventLoop() и UI_DrawSaveLoad().

pSavegameThumbnails

std::array<Image *, MAX_SAVE_SLOTS> pSavegameThumbnails

См. определение в файле SaveLoad.cpp строка 44

Используется в DoSavegame(), GUIWindow_Load::GUIWindow_Load(), GUIWindow_Save::GUIWindow_Save(), LoadGame() и UI_DrawSaveLoad().

pSavegameHeader

std::array<SavegameHeader, MAX_SAVE_SLOTS> pSavegameHeader

См. определение в файле SaveLoad.cpp строка 45

Используется в DoSavegame(), Application::Menu::EventLoop(), GUIWindow_Load::GUIWindow_Load(), GUIWindow_Save::GUIWindow_Save(), MainMenuLoad_EventLoop(), SaveNewGame() и UI_DrawSaveLoad().