#include "files.h"

#include "stratdef.h"

#include "system.h"

#include "bh_types.h"

#include "pvisible.h"

#include "dynamics.h"

#include "userprofile.h"

#include "savegame.h"

#include "weapons.h"

#include "weaponbehaviour.h"

#include "npc_sentrygun.h"

#include <assert.h>

extern void *OpenGameDirectory(const char *dirname, const char *pattern, int type);

extern GameDirectoryFile *ScanGameDirectory(void *dir);

extern const SECTION * GetNamedHierarchyFromLibrary(const char * rif_name, const char *);

extern SAVE_SLOT_HEADER SaveGameSlot[];

static struct

{

    char* BufferStart;

    char* BufferPos;

    int BufferSize;

    int BufferSpaceLeft;

    int BufferSpaceUsed;

} SaveInfo = {0,0,0,0,0};

static struct

{

    char* BufferStart;

    char* BufferPos;

    int BufferSize;

    int BufferSpaceLeft;

} LoadInfo = {0,0,0,0};

/*---------------------------------------------**

** externs for all the load and save functions **

**---------------------------------------------*/

extern void LoadStrategy_LiftDoor(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_LiftDoor(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_SwitchDoor(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_SwitchDoor(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_PlatformLift(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_PlatformLift(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_BinarySwitch(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_BinarySwitch(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_LinkSwitch(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_LinkSwitch(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Generator(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Generator(STRATEGYBLOCK* sbPtr);

extern void LoadHiveSettings(SAVE_BLOCK_HEADER* header);

extern void SaveHiveSettings();

extern void LoadStrategy_LightFx(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_LightFx(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_PlacedSound(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_PlacedSound(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Message(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Message(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_MissionComplete(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_MissionComplete(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_TrackObject(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_TrackObject(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Fan(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Fan(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_PlacedLight(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_PlacedLight(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_VideoScreen(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_VideoScreen(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_DeathVolume(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_DeathVolume(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_ParticleGenerator(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_ParticleGenerator(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_SelfDestruct(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_SelfDestruct(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Alien(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Alien(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_FaceHugger(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_FaceHugger(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Marine(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Marine(STRATEGYBLOCK* sbPtr);

extern void LoadMarineSquadState(SAVE_BLOCK_HEADER* header);

extern void SaveMarineSquadState();

extern void LoadStrategy_PlacedHierarchy(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_PlacedHierarchy(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Predator(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Predator(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Xenoborg(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Xenoborg(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Queen(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Queen(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Player(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Player(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_Autogun(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Autogun(STRATEGYBLOCK* sbPtr);

extern void Load_Decals(SAVE_BLOCK_HEADER* header);

extern void Save_Decals();

extern void Load_Particles(SAVE_BLOCK_HEADER* header);

extern void Save_Particles();

extern void Load_VolumetricExplosions(SAVE_BLOCK_HEADER* header);

extern void Save_VolumetricExplosions();

extern void Load_PheromoneTrails(SAVE_BLOCK_HEADER* header);

extern void Save_PheromoneTrails();

extern void Load_LightElements(SAVE_BLOCK_HEADER* header);

extern void Save_LightElements();

extern void LoadStrategy_Flare(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_Flare(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_ProxGrenade(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_ProxGrenade(STRATEGYBLOCK* sbPtr);

extern void LoadStrategy_SpearBolt(SAVE_BLOCK_STRATEGY_HEADER* header);

extern void SaveStrategy_SpearBolt(STRATEGYBLOCK* sbPtr);

extern void Load_WeaponsCGlobals(SAVE_BLOCK_HEADER* header);

extern void Save_WeaponsCGlobals();

extern void Load_SoundState_NoRef(SAVE_BLOCK_HEADER* header);

extern void Save_SoundsWithNoReference();

#include "projload.hpp"

static STRATEGYBLOCK* Create_Pred_Disc_Pickup_For_Load()

{

    TOOLS_DATA_INANIMATEOBJECT toolsData;

    int discShapeIndex;

    {

        /*

        We need to find the shape index of the disc object. To do this , we need to

        get the disc head-up-display hierarchy , and search for the disc section

        */

        const SECTION* section = GetNamedHierarchyFromLibrary("pred_HUD", "disk");

        if(!section)

            return NULL;

        section = GetThisSection(section, "disk");

        if(!section)

            return NULL;

        //found the disc section

        discShapeIndex = section->ShapeNum;

    }

    //fill in a tools data for the disc

    memset(&toolsData, 0, sizeof(toolsData));

    toolsData.typeId = IOT_Ammo;

    toolsData.subType = (int)AMMO_PRED_DISC;

    STRATEGYBLOCK* sbPtr = CreateActiveStrategyBlock(I_BehaviourInanimateObject);

    if(!sbPtr)

        return NULL;

    sbPtr->shapeIndex = discShapeIndex;

    EnableBehaviourType(sbPtr, &toolsData);

    sbPtr->maintainVisibility = 1;

return sbPtr;

}

/*--------------------**

** Loading and Saving **

**--------------------*/

#include "savegame.h"

typedef struct inanimate_object_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    INANIMATEOBJECT_TYPE typeId;

    int subType; /* weapon id, security level or other relevant enumerated type... */

    int explosionTimer; //slight time delay after destruction for explosion

    DAMAGEBLOCK DamageBlock;

    DYNAMICSBLOCK dynamics;

} INANIMATE_OBJECT_SAVE_BLOCK;

//defines for load/save macros

#define SAVELOAD_BLOCK block

#define SAVELOAD_BEHAV objectstatusptr

static void LoadStrategy_InanimateObject(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    INANIMATE_OBJECT_SAVE_BLOCK* block = (INANIMATE_OBJECT_SAVE_BLOCK*) header; 

    //check the size of the save block

    if(header->size != sizeof(*block))

        return;

    //find the existing strategy block

    STRATEGYBLOCK* sbPtr = FindSBWithName(header->SBname);

    if(!sbPtr)

    {

        //Didn't find the object already existing.

        //Might be a predator disc pickup however.

        if(block->typeId == IOT_Weapon && block->subType == (int)WEAPON_PRED_DISC)

        {

            //okay we need to create a disc then

            sbPtr = Create_Pred_Disc_Pickup_For_Load();

        }

        if(!sbPtr)

            return;

    }

    //make sure the strategy found is of the right type

    if(sbPtr->type != I_BehaviourInanimateObject)

        return;

    INANIMATEOBJECT_STATUSBLOCK* objectstatusptr = (INANIMATEOBJECT_STATUSBLOCK*)sbPtr->dataptr;

    //start copying stuff

    COPYELEMENT_LOAD(explosionTimer)

    COPYELEMENT_LOAD(typeId)

    COPYELEMENT_LOAD(subType)

    *sbPtr->DynPtr = block->dynamics;

    sbPtr->DamageBlock = block->DamageBlock;

}

static void SaveStrategy_InanimateObject(STRATEGYBLOCK* sbPtr)

{

    INANIMATE_OBJECT_SAVE_BLOCK *block;

    INANIMATEOBJECT_STATUSBLOCK* objectstatusptr = (INANIMATEOBJECT_STATUSBLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    //start copying stuff

    COPYELEMENT_SAVE(explosionTimer)

    COPYELEMENT_SAVE(typeId)

    COPYELEMENT_SAVE(subType)

    block->dynamics = *sbPtr->DynPtr;

    block->dynamics.CollisionReportPtr=0;

    block->DamageBlock = sbPtr->DamageBlock;

}

/*--------------------**

** Loading and Saving **

**--------------------*/

typedef struct prox_door_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    int door_state;

    int door_locked;

    //from the morph control

    int ObMorphCurrFrame;

    int ObMorphFlags;

    int ObMorphSpeed;

    int marineTrigger;

} PROX_DOOR_SAVE_BLOCK;

static void LoadStrategy_ProxDoor(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    PROX_DOOR_SAVE_BLOCK* block = (PROX_DOOR_SAVE_BLOCK*) header; 

    if(header->size != sizeof(*block))

        return;

    //find the existing strategy block

    STRATEGYBLOCK* sbPtr = FindSBWithName(block->header.SBname);

    if(!sbPtr)

        return;

    //make sure the strategy found is of the right type

    if(sbPtr->type != I_BehaviourProximityDoor)

        return;

    PROXDOOR_BEHAV_BLOCK *doorbhv = (PROXDOOR_BEHAV_BLOCK*)sbPtr->dataptr;

    doorbhv->door_state = block->door_state;

    doorbhv->door_locked = block->door_locked;

    doorbhv->marineTrigger = block->marineTrigger;

    doorbhv->PDmctrl->ObMorphCurrFrame = block->ObMorphCurrFrame;

    doorbhv->PDmctrl->ObMorphFlags = block->ObMorphFlags;

    doorbhv->PDmctrl->ObMorphSpeed = block->ObMorphSpeed;

    Load_SoundState(&doorbhv->SoundHandle);

}

static void SaveStrategy_ProxDoor(STRATEGYBLOCK* sbPtr)

{

    PROX_DOOR_SAVE_BLOCK *block;

    PROXDOOR_BEHAV_BLOCK *doorbhv  = (PROXDOOR_BEHAV_BLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    block->door_state = doorbhv->door_state;

    block->door_locked = doorbhv->door_locked;

    block->marineTrigger = doorbhv->marineTrigger;

    block->ObMorphCurrFrame = doorbhv->PDmctrl->ObMorphCurrFrame;

    block->ObMorphFlags = doorbhv->PDmctrl->ObMorphFlags;

    block->ObMorphSpeed = doorbhv->PDmctrl->ObMorphSpeed;

    Save_SoundState(&doorbhv->SoundHandle);

}

/*-----------------------------------------------------**

** end of externs for all the load and save functions  **

**-----------------------------------------------------*/

/*

Functions for converting between ai modules and their indeces.

They don't really belong here , but they are only used by loading/saving at 

the moment.

*/

struct aimodule * GetPointerFromAIModuleIndex(int index)

{

    return (index >= 0 && index < AIModuleArraySize) ? &AIModuleArray[index] : NULL ;

}

int GetIndexFromAIModulePointer(struct aimodule* module)

{

    return (module ? module->m_index : -1);

}

void* GetPointerForSaveBlock(unsigned int size)

{

    //see if we need to enlarge the buffer to allow for this block

    if(size > SaveInfo.BufferSpaceLeft)

    {

        //need more space

        int spaceNeeded = SaveInfo.BufferSpaceUsed + size;

        //buffer incremented in lots of 100000 bytes (more or less)

        int newBufferSize = ((spaceNeeded / 100000) + 1) * 100000;

        char *ptr = (char*) realloc(SaveInfo.BufferStart, newBufferSize);

        if(NULL != ptr)

        {

            SaveInfo.BufferStart = ptr;

            //correct the position etc.

            SaveInfo.BufferPos = SaveInfo.BufferStart + SaveInfo.BufferSpaceUsed;

            SaveInfo.BufferSpaceLeft += (newBufferSize - SaveInfo.BufferSize);

            SaveInfo.BufferSize = newBufferSize;

        }

        // else pretend everything is OK? exit(EXIT_FAILURE);? return NULL;?

    }

    //get the pointer to the next part of the save buffer

    void* retPointer = (void*)SaveInfo.BufferPos;

    SaveInfo.BufferSpaceUsed += size;

    SaveInfo.BufferSpaceLeft -= size;

    SaveInfo.BufferPos += size;

return retPointer;

}

static void SaveStrategies()

{

    int i=0;

    for(; i < NumActiveStBlocks; i++)

    {

        STRATEGYBLOCK* sbPtr = ActiveStBlockList[i];

        switch(sbPtr->type)

        {

            case I_BehaviourMarinePlayer:

            case I_BehaviourPredatorPlayer:

            case I_BehaviourAlienPlayer:

                SaveStrategy_Player(sbPtr);

            break;

            case I_BehaviourLiftDoor:

                SaveStrategy_LiftDoor(sbPtr);

            break;

            case I_BehaviourProximityDoor:

                SaveStrategy_ProxDoor(sbPtr);

            break;

            case I_BehaviourSwitchDoor:

                SaveStrategy_SwitchDoor(sbPtr);

            break;

            case I_BehaviourPlatform:

                SaveStrategy_PlatformLift(sbPtr);

            break;

            case I_BehaviourBinarySwitch:

                SaveStrategy_BinarySwitch(sbPtr);

            break;

            case I_BehaviourLinkSwitch:

                SaveStrategy_LinkSwitch(sbPtr);

            break;

            case I_BehaviourGenerator:

                SaveStrategy_Generator(sbPtr);

            break;

            case I_BehaviourInanimateObject:

                SaveStrategy_InanimateObject(sbPtr);

            break;

            case I_BehaviourLightFX:

                SaveStrategy_LightFx(sbPtr);

            break;

            case I_BehaviourPlacedSound:

                SaveStrategy_PlacedSound(sbPtr);

            break;

            case I_BehaviourMessage:

                SaveStrategy_Message(sbPtr);

            break;

            case I_BehaviourMissionComplete:

                SaveStrategy_MissionComplete(sbPtr);

            break;

            case I_BehaviourTrackObject:

                SaveStrategy_TrackObject(sbPtr);

            break;

            case I_BehaviourFan:

                SaveStrategy_Fan(sbPtr);

            break;

            case I_BehaviourPlacedLight:

                SaveStrategy_PlacedLight(sbPtr);

            break;

            case I_BehaviourVideoScreen:

                SaveStrategy_VideoScreen(sbPtr);

            break;

            case I_BehaviourSelfDestruct:

                SaveStrategy_SelfDestruct(sbPtr);

            break;

            case I_BehaviourParticleGenerator:

                SaveStrategy_ParticleGenerator(sbPtr);

            break;

            case I_BehaviourDeathVolume:

                SaveStrategy_DeathVolume(sbPtr);

            break;

            case I_BehaviourAlien:

                   SaveStrategy_Alien(sbPtr);

            break;

            case I_BehaviourFaceHugger:

                   SaveStrategy_FaceHugger(sbPtr);

            break;

            case I_BehaviourMarine:

                   SaveStrategy_Marine(sbPtr);

            break;

            case I_BehaviourPlacedHierarchy:

                   SaveStrategy_PlacedHierarchy(sbPtr);

            break;

            case I_BehaviourPredator:

                   SaveStrategy_Predator(sbPtr);

            break;

            case I_BehaviourXenoborg:

                   SaveStrategy_Xenoborg(sbPtr);

            break;

            case I_BehaviourQueenAlien:

                   SaveStrategy_Queen(sbPtr);

            break;

            case I_BehaviourAutoGun:

                   SaveStrategy_Autogun(sbPtr);

            break;

            case I_BehaviourFlare:

                SaveStrategy_Flare(sbPtr);

            break;

            case I_BehaviourProximityGrenade:

                SaveStrategy_ProxGrenade(sbPtr);

            break;

            case I_BehaviourSpeargunBolt:

                SaveStrategy_SpearBolt(sbPtr);

            break;

            default:

            break;

        }

    }

}

static void EndLoadGame()

{

    if(LoadInfo.BufferStart)

        free(LoadInfo.BufferStart);

    LoadInfo.BufferStart = NULL;

    LoadInfo.BufferPos = NULL;

    LoadInfo.BufferSize = 0;

    LoadInfo.BufferSpaceLeft = 0;

}

static void LoadStrategy(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    switch(header->bhvr_type)

    {

        case I_BehaviourMarinePlayer:

        case I_BehaviourPredatorPlayer:

        case I_BehaviourAlienPlayer:

            LoadStrategy_Player(header);

        break;

        case I_BehaviourLiftDoor:

            LoadStrategy_LiftDoor(header);

        break;

        case I_BehaviourProximityDoor:

            LoadStrategy_ProxDoor(header);

        break;

        case I_BehaviourSwitchDoor:

            LoadStrategy_SwitchDoor(header);

        break;

        case I_BehaviourPlatform:

            LoadStrategy_PlatformLift(header);

        break;

        case I_BehaviourBinarySwitch:

            LoadStrategy_BinarySwitch(header);

        break;

        case I_BehaviourLinkSwitch:

            LoadStrategy_LinkSwitch(header);

        break;

        case I_BehaviourGenerator:

            LoadStrategy_Generator(header);

        break;

        case I_BehaviourInanimateObject:

            LoadStrategy_InanimateObject(header);

        break;

        case I_BehaviourLightFX:

            LoadStrategy_LightFx(header);

        break;

        case I_BehaviourPlacedSound:

            LoadStrategy_PlacedSound(header);

        break;

        case I_BehaviourMessage:

            LoadStrategy_Message(header);

        break;

        case I_BehaviourMissionComplete:

            LoadStrategy_MissionComplete(header);

        break;

        case I_BehaviourTrackObject:

            LoadStrategy_TrackObject(header);

        break;

        case I_BehaviourFan:

            LoadStrategy_Fan(header);

        break;

        case I_BehaviourPlacedLight:

            LoadStrategy_PlacedLight(header);

        break;

        case I_BehaviourVideoScreen:

            LoadStrategy_VideoScreen(header);

        break;

        case I_BehaviourSelfDestruct:

            LoadStrategy_SelfDestruct(header);

        break;

        case I_BehaviourParticleGenerator:

            LoadStrategy_ParticleGenerator(header);

        break;

        case I_BehaviourDeathVolume:

            LoadStrategy_DeathVolume(header);

        break;

        case I_BehaviourAlien:

            LoadStrategy_Alien(header);

        break;

        case I_BehaviourFaceHugger:

               LoadStrategy_FaceHugger(header);

        break;

        case I_BehaviourMarine:

               LoadStrategy_Marine(header);

        break;

        case I_BehaviourPlacedHierarchy:

               LoadStrategy_PlacedHierarchy(header);

        break;

        case I_BehaviourPredator:

               LoadStrategy_Predator(header);

        break;

        case I_BehaviourXenoborg:

               LoadStrategy_Xenoborg(header);

        break;

        case I_BehaviourQueenAlien:

               LoadStrategy_Queen(header);

        break;

        case I_BehaviourAutoGun:

               LoadStrategy_Autogun(header);

        break;

        case I_BehaviourFlare:

            LoadStrategy_Flare(header);

        break;

        case I_BehaviourProximityGrenade:

            LoadStrategy_ProxGrenade(header);

        break;

        case I_BehaviourSpeargunBolt:

            LoadStrategy_SpearBolt(header);

        break;

        default:

        break;

    }

}

SAVE_BLOCK_HEADER* GetNextBlockIfOfType(SAVE_BLOCK_TYPE type)

{

    assert(LoadInfo.BufferPos);

    if(!LoadInfo.BufferSpaceLeft)

        return 0;

    //look at the next header in the buffer

    SAVE_BLOCK_HEADER* header = (SAVE_BLOCK_HEADER*) LoadInfo.BufferPos;

    if(header->size > LoadInfo.BufferSpaceLeft)

    {

        //oh dear, dodgy file

        assert("Invalid save game header size"==0);

        return 0;

    }

    //see if the header is of the type that we are after

    if(header->type == type)

    {

        //okay , advance the buffer position , and return this header

        LoadInfo.BufferPos += header->size;

        LoadInfo.BufferSpaceLeft -= header->size;

    return header;

    }

return 0;

}

/*------------------------------------**

** Loading and saving dead strategies **

**------------------------------------*/

typedef struct dead_strategy_save_block

{

    SAVE_BLOCK_HEADER header;

    char SBname[SB_NAME_LENGTH];

} DEAD_STRATEGY_SAVE_BLOCK;

static void SaveDeadStrategies()

{

    extern STRATEGYBLOCK FreeStBlockData[];

    int i;

    STRATEGYBLOCK* sbPtr = &FreeStBlockData[0];

    //search for all the strategies that existed at the start , and have been destroyed

    for(i=0; i < maxstblocks; i++ , sbPtr++)

    {

        if(sbPtr->destroyed_but_preserved)

        {

            DEAD_STRATEGY_SAVE_BLOCK* block;    

            GET_SAVE_BLOCK_POINTER(block);

            block->header.type = SaveBlock_DeadStrategy;

            block->header.size = sizeof(*block);

            COPY_NAME(block->SBname, sbPtr->SBname);

        }    

    }

}

static void LoadDeadStrategy(SAVE_BLOCK_HEADER* header)

{

    DEAD_STRATEGY_SAVE_BLOCK* block = (DEAD_STRATEGY_SAVE_BLOCK*) header;

    STRATEGYBLOCK* sbPtr = FindSBWithName(block->SBname);

    if(sbPtr)

        sbPtr->please_destroy_me = 1;

}

/*--------------------------------------------------------------------------------**

** Loading and saving miscellaneos global rubbish that  has nowhere else to live **

**--------------------------------------------------------------------------------*/

extern unsigned int IncrementalSBname;

extern int PlayersMaxHeightWhilstNotInContactWithGround;

typedef struct misc_global_save_block

{

    SAVE_BLOCK_HEADER header;

    unsigned int IncrementalSBname;

    AvP_GameStats CurrentGameStatistics;

    int PlayersMaxHeightWhilstNotInContactWithGround;

} MISC_GLOBAL_SAVE_BLOCK;

static void LoadMiscGlobalStuff(SAVE_BLOCK_HEADER* header)

{

    MISC_GLOBAL_SAVE_BLOCK* block = (MISC_GLOBAL_SAVE_BLOCK*) header;

    if(block->header.size == sizeof(*block))

    {

        IncrementalSBname = block->IncrementalSBname;

        CurrentGameStatistics = block->CurrentGameStatistics;

        PlayersMaxHeightWhilstNotInContactWithGround = block->PlayersMaxHeightWhilstNotInContactWithGround;

    }

}

static void SaveMiscGlobalStuff()

{

    MISC_GLOBAL_SAVE_BLOCK* block = GetPointerForSaveBlock(sizeof(*block));

    //fill in the header

    block->header.type = SaveBlock_MiscGlobal;

    block->header.size = sizeof(*block);

    block->IncrementalSBname = IncrementalSBname;

    block->CurrentGameStatistics = CurrentGameStatistics;

    block->PlayersMaxHeightWhilstNotInContactWithGround = PlayersMaxHeightWhilstNotInContactWithGround;

}

void LoadLevelHeader(SAVE_BLOCK_HEADER* header)

{

    LEVEL_SAVE_BLOCK* block =(LEVEL_SAVE_BLOCK*) header;

    if(block->header.size == sizeof(*block))

    {

        AvP.ElapsedHours = block->ElapsedTime_Hours;

        AvP.ElapsedMinutes = block->ElapsedTime_Minutes;

        AvP.ElapsedSeconds = block->ElapsedTime_Seconds;

        PlayerStatus.saves_left = block->NumberOfSavesLeft;

    }

}

static void GetHeaderInfoForSaveSlot(SAVE_SLOT_HEADER* save_slot, const GameDirectoryFile *gdf)

{

    LEVEL_SAVE_BLOCK block;

    unsigned int file_size;

    char filename[100];

    save_slot->SlotUsed = 0;

    sprintf(filename, "%s", gdf->filename);

    FILE *file = OpenGameFile(filename, 1, FILETYPE_CONFIG);

    if (file == NULL)

    {

        //failed to load (probably doesn't exist)

        return;

    }

    fseek(file, 0, SEEK_END);

    file_size = ftell(file);

    rewind(file);

    if(file_size < sizeof(LEVEL_SAVE_BLOCK))

    {

        //obviously not much of a save file then...

        fclose(file);

        return;

    }

    save_slot->TimeStamp = gdf->timestamp;

    //load the level header

    fread(&block, sizeof(block), 1, file);

    fclose(file);

    //a few checks

    if(block.header.type != SaveBlock_MainHeader || block.header.size != sizeof(block) || strncmp(block.AvP_Save_String,"AVPSAVE0",8))

    {

        //no good.

        return;

    }

    //appears to be a reasonable file

    save_slot->SlotUsed = 1;

    save_slot->player_type = block.player_type;

    save_slot->Episode = block.Episode;

    save_slot->ElapsedTime_Hours = block.ElapsedTime_Hours;

    save_slot->ElapsedTime_Minutes = block.ElapsedTime_Minutes;

    save_slot->ElapsedTime_Seconds = (block.ElapsedTime_Seconds >> 16);

    save_slot->Difficulty = block.Difficulty;

    save_slot->SavesLeft = block.NumberOfSavesLeft;

}

void ScanSaveSlots()

{

    char pattern[100];

    sprintf(pattern, "%s_?.sav", UserProfile.PlayerName);

    void *gd = OpenGameDirectory(".", pattern, FILETYPE_CONFIG);

    if (NULL != gd)

    {

        while (1)

        {

            GameDirectoryFile *gdf = ScanGameDirectory(gd);

            if(NULL == gdf)

                break;

            if ((gdf->attr & FILEATTR_DIRECTORY) || !(gdf->attr & FILEATTR_READABLE))

                continue;

            char *ptr = strrchr(gdf->filename, '.');

            if (ptr == NULL)

                continue;

            ptr--;

            int i = *ptr - '1';

            if (i >= 0 && (i < NUMBER_OF_SAVE_SLOTS))

                GetHeaderInfoForSaveSlot(&SaveGameSlot[i], gdf);

        }

    }

}

int LoadGameRequest = SAVELOAD_REQUEST_NONE; //slot number of game to be loaded

int LoadSavedGame()

{

    char filename[100];

    int terminal_error = 0;

        if(SAVELOAD_REQUEST_NONE == LoadGameRequest)

        return 0;

    sprintf(filename, "%s_%d.sav", UserProfile.PlayerName, LoadGameRequest+1);

    LoadGameRequest = SAVELOAD_REQUEST_NONE;

{

    FILE *file = OpenGameFile(filename, 1, FILETYPE_CONFIG);

    if(file == NULL)

    {

        EndLoadGame();

        return 1;

    }

    fseek(file, 0, SEEK_END);

    LoadInfo.BufferSize = ftell(file);

    rewind(file);

       if(!LoadInfo.BufferSize)

    {

        fclose(file);

        EndLoadGame();

        return 1;

    }

    //allocate buffer , and read file into memory

    LoadInfo.BufferStart = malloc(LoadInfo.BufferSize);

    fread(LoadInfo.BufferStart, LoadInfo.BufferSize, 1, file);

    fclose(file);

}

    LoadInfo.BufferPos = LoadInfo.BufferStart;

    LoadInfo.BufferSpaceLeft = LoadInfo.BufferSize;

    // attempt to access level header    

    {

        //read the next header

        SAVE_BLOCK_HEADER* header = (SAVE_BLOCK_HEADER*) LoadInfo.BufferPos;

        if(header->size > LoadInfo.BufferSpaceLeft)

        {