SaveHandler.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of Penumbra Overture.
 */

#ifndef GAME_SAVE_HANDLER_H
#define GAME_SAVE_HANDLER_H

#include "hpl1/engine/engine.h"

using namespace hpl;

class cInit;

#include "hpl1/penumbra-overture/GameTypes.h"
#include "hpl1/penumbra-overture/SaveTypes.h"

class iGameEntity_SaveData;

//---------------------------------------------

class cMusic_GlobalSave : public iSerializable {
    kSerializableClassInit(cMusic_GlobalSave) public : tString msName;
    float mfVolume;
    bool mbLoop;
};

//---------------------------------------------

class cGameMusic_GlobalSave : public iSerializable {
    kSerializableClassInit(cGameMusic_GlobalSave) public : tString msFile;
    bool mbLoop;
    float mfVolume;
};

class cGameMusicHandler_GlobalSave : public iSerializable {
    kSerializableClassInit(cGameMusicHandler_GlobalSave) public : int mlCurrentMaxPrio;
    bool mbAttackPlaying;
    bool mbEnemyClosePlaying;

    cContainerVec<cGameMusic_GlobalSave> mvGameMusic;
};

//---------------------------------------------

class cNotebookTask_GlobalSave : public iSerializable {
    kSerializableClassInit(cNotebookTask_GlobalSave) public : tString msName;
    tWString msText;
};

class cNotebookNote_GlobalSave : public iSerializable {
    kSerializableClassInit(cNotebookNote_GlobalSave) public : tWString msName;
    bool mbRead;
    tString msTextCat;
    tString msTextEntry;
};

class cNotebook_GlobalSave : public iSerializable {
    kSerializableClassInit(cNotebook_GlobalSave) public :

        cContainerList<cNotebookNote_GlobalSave> mlstNotes;
    cContainerList<cNotebookTask_GlobalSave> mlstTasks;
};

//---------------------------------------------

class cInventorySlot_GlobalSave : public iSerializable {
    kSerializableClassInit(cInventorySlot_GlobalSave) public : tString msItemName;
};

class cInventoryItem_GlobalSave : public iSerializable {
    kSerializableClassInit(cInventoryItem_GlobalSave) public : tString msName;
    tWString msGameName;
    tWString msDescription;

    tString msSubType;

    eGameItemType mItemType;

    tString msEntityFile;
    tString msGfxObjectFile;

    tString msHudModelFile;
    tString msHudModelName;

    bool mbCanBeDropped;
    bool mbHasCount;
    int mlCount;
};

class cInventory_GlobalSave : public iSerializable {
    kSerializableClassInit(cInventory_GlobalSave) public : bool mbNoteBookActive;

    cContainerList<cInventorySlot_GlobalSave> mlstSlots;
    cContainerVec<cInventorySlot_GlobalSave> mvEquipSlots;

    cContainerList<cInventoryItem_GlobalSave> mlstItems;
};

//---------------------------------------------

class cSceneLoadedMap_GlobalSave : public iSerializable {
    kSerializableClassInit(cSceneLoadedMap_GlobalSave) public : tString msName;
};

//---------------------------------------------

class cMapHandlerLoadedMap_GlobalSave : public iSerializable {
    kSerializableClassInit(cMapHandlerLoadedMap_GlobalSave) public : tString msName;
    double mfTime;
};


class cMapHandlerTimer_GlobalSave : public iSerializable {
    kSerializableClassInit(cMapHandlerTimer_GlobalSave) public : tString msName;
    tString msCallback;

    bool mbGlobal;

    float mfTime;

    bool mbDeleteMe;
    bool mbPaused;
};


class cMapHandler_GlobalSave : public iSerializable {
    kSerializableClassInit(cMapHandler_GlobalSave);

public:
    double mfGameTime;
    tString msCurrentMap;

    cContainerVec<cMapHandlerLoadedMap_GlobalSave> mvLoadedMaps;
    cContainerList<cMapHandlerTimer_GlobalSave> mlstTimers;
};

//---------------------------------------------

class cPlayer_GlobalSave_CameraPS : public iSerializable {
    kSerializableClassInit(cPlayer_GlobalSave_CameraPS);

public:
    tString msName;
    tString msFile;
};

class cPlayer_GlobalSave : public iSerializable {
    kSerializableClassInit(cPlayer_GlobalSave);

public:
    // Stats
    int mlStat_NumOfSaves;

    // Global vars
    float mfForwardUpMul;
    float mfForwardRightMul;

    float mfUpMul;
    float mfRightMul;

    bool mbPickAtPoint;
    bool mbRotateWithPlayer;
    bool mbUseNormalMass;

    float mfGrabMassMul;

    // Private
    bool mbActive;

    float mfHeightAdd;

    float mfSpeedMul;
    float mfHealthSpeedMul;

    float mfHeadMoveSizeMul;
    float mfHeadMoveSpeedMul;

    ePlayerState mState;

    ePlayerMoveState mMoveState;

    eCrossHairState mCrossHairState;

    bool mbItemFlash;

    float mfHealth;

    float mfPower;

    float mfMass;

    cContainerVec<cPlayer_GlobalSave_CameraPS> mvOnCameraPS;

    // Lights
    bool mbFlashlightActive;
    bool mbFlashlightDisabled;
    bool mbGlowstickActive;
    bool mbFlareActive;
    float mfFlareTime;

    // Body and Camera Specific
    cVector3f mvPosition;
    float mfYaw;
    float mfPitch;
};

//---------------------------------------------

class cSavedWorld : public iSerializable {
    kSerializableClassInit_nodestructor(cSavedWorld) public : ~cSavedWorld();

    void Reset();

    tString msName;
    tWString msGameName;

    // Ambient color
    cColor mAmbientColor;

    // Fog
    bool mbFogActive;
    float mfFogStartDist;
    float mfFogEndDist;
    cColor mFogColor;
    bool mbFogCulling;

    // Skybox
    bool mbSkyboxActive;
    cColor mSkyboxColor;
    tString msSkyboxFile;

    // Script variables
    cContainerList<cScriptVar> mlstVars;

    // Inventory variables
    cContainerList<cInventoryUseCallback> mlstUseCallbacks;
    cContainerList<cInventoryPickupCallback> mlstPickupCallbacks;
    cContainerList<cInventoryCombineCallback> mlstCombineCallbacks;

    // Player collider callbacks
    cContainerList<cSaveGame_cGameCollideScript> mlstCollideCallbacks;

    // Local Timers
    cContainerList<cGameTimer> mlstTimers;

    // Entities
    cContainerList<iGameEntity_SaveData *> mlstEntities;

    // Engine types
    cContainerList<cEngineLight_SaveData> mlstLights;
    cContainerList<cEnginePS_SaveData> mlstPS;
    cContainerList<cEngineBeam_SaveData> mlstBeams;
    cContainerList<cEngineSound_SaveData> mlstSounds;

    cContainerList<cEngineJoint_SaveData> mlstJoints;

    bool PSExists(cParticleSystem3D *apPS);
    bool BeamExists(cBeam *apPS);
    bool SoundExists(cSoundEntity *apSound);
    bool JointExists(iPhysicsJoint *apJoint);
};

//----------------------------

class cSavedGame : public iSerializable {
    kSerializableClassInit_nodestructor(cSavedGame) public : ~cSavedGame();

    void Reset();
    void ResetWorlds();
    void ResetGlobalData();
    cSavedWorld *GetSavedWorld(const tString &asName);

    // Variables:
    eGameDifficulty mDifficulty;

    tString msOnRadioEndCallback;

    cPlayer_GlobalSave mPlayer;
    cMapHandler_GlobalSave mMapHandler;
    cInventory_GlobalSave mInventory;
    cNotebook_GlobalSave mNotebook;
    cGameMusicHandler_GlobalSave mGameMusicHandler;
    cMusic_GlobalSave mMusic;

    cContainerList<cSceneLoadedMap_GlobalSave> mvSceneLoadedMap;
    cContainerList<cScriptVar> mlstScriptVars;

    cContainerList<cSavedWorld *> mlstWorlds;
};

//----------------------------

class cSaveHandler : public iUpdateable {
public:
    cSaveHandler(cInit *apInit);
    ~cSaveHandler();

    static cDate parseDate(const Common::String &saveFile);

    void SaveData(const tString &asName);
    void LoadData(const tString &asName);

    void SaveGameToFile(const tWString &asFile);
    void LoadGameFromFile(const tWString &asFile, bool drawLoadingScreen = true);

    void AutoSave(const tWString &asDir, int alMaxSaves);
    void AutoLoad(const tWString &asDir);

    void ClearSavedMaps();

    void OnWorldLoad();
    void OnStart();
    void Reset();

    void OnExit();

    const tWString &GetSaveDir() { return msSaveDir; }

    void DeleteOldestIfMax(const tWString &asDir, const tWString &asMask, int alMaxFiles);
    tWString GetLatest(const tWString &asMask);

private:
    cInit *mpInit;

    cSavedGame *mpSavedGame;
    tWString msSaveDir;
};

#endif // GAME_SAVE_HANDLER_H