#include "system.h"

#include "prototyp.h"

#include "stratdef.h"

#include "mission.h"

#include <assert.h>

#include <string.h>

#include <stdlib.h>

extern void MissionObjectiveTriggered(void* mission_objective);

extern void MakeMissionVisible(void* mission_objective);

extern void MakeMissionPossible(void* mission_objective);

void MissionCompleteBehaveInit(void* bhdata, STRATEGYBLOCK* sbptr)

{

     assert(sbptr);

    MISSION_COMPLETE_BEHAV_BLOCK* m_bhv = malloc(sizeof(MISSION_COMPLETE_BEHAV_BLOCK));

    if(NULL == m_bhv)

    {

        RemoveBehaviourStrategy(sbptr);

        return;

    }

    sbptr->dataptr = m_bhv;

    MISSION_COMPLETE_TOOLS_TEMPLATE* mc_tt = (MISSION_COMPLETE_TOOLS_TEMPLATE*) bhdata;

    m_bhv->bhvr_type = I_BehaviourMissionComplete;

    sbptr->shapeIndex = 0;

    COPY_NAME(sbptr->SBname, mc_tt->nameID);

    m_bhv->mission_objective_ptr=mc_tt->mission_objective_ptr;

}

#define MissionTrigger_MakeVisible 0x00000001

#define MissionTrigger_MakePossible 0x00000002

#define MissionTrigger_DontComplete 0x00000004

void SendRequestToMissionStrategy(STRATEGYBLOCK* sbptr, int state,int extended_data)

{

    assert(sbptr);

    assert(sbptr->dataptr);

    MISSION_COMPLETE_BEHAV_BLOCK *mc_bhv = (MISSION_COMPLETE_BEHAV_BLOCK*)sbptr->dataptr;

    assert((mc_bhv->bhvr_type == I_BehaviourMissionComplete));

    if(!state)

        return;

    if(extended_data & MissionTrigger_MakeVisible)

        MakeMissionVisible(mc_bhv->mission_objective_ptr);

    if(extended_data & MissionTrigger_MakePossible)

        MakeMissionPossible(mc_bhv->mission_objective_ptr);

    if(!(extended_data & MissionTrigger_DontComplete))

        MissionObjectiveTriggered(mc_bhv->mission_objective_ptr);

}

typedef struct message_behav_block

{

    AVP_BEHAVIOUR_TYPE bhvr_type;

    int string_no;

    int active;

} MESSAGE_BEHAV_BLOCK;

void MessageBehaveInit(void* bhdata,STRATEGYBLOCK* sbptr)

{

     assert(sbptr);

    MESSAGE_BEHAV_BLOCK* m_bhv = malloc(sizeof(MESSAGE_BEHAV_BLOCK));

    if(!m_bhv)

    {

        RemoveBehaviourStrategy(sbptr);

        return;

    }

    sbptr->dataptr = m_bhv;

    MESSAGE_TOOLS_TEMPLATE* m_tt = (MESSAGE_TOOLS_TEMPLATE*) bhdata;

    m_bhv->bhvr_type = I_BehaviourMessage;

    sbptr->shapeIndex = 0;

    COPY_NAME(sbptr->SBname, m_tt->nameID);

    m_bhv->string_no = m_tt->string_no;

    m_bhv->active = m_tt->active;

}

extern const char * missionlevel_messages[];

void SendRequestToMessageStrategy(STRATEGYBLOCK* sbptr, int state,int extended_data)

{

    assert(sbptr);

    assert(sbptr->dataptr);

    MESSAGE_BEHAV_BLOCK *m_bhv = (MESSAGE_BEHAV_BLOCK*)sbptr->dataptr;

    assert((m_bhv->bhvr_type == I_BehaviourMessage));

    extern unsigned int mission_messages_timer;

    switch(extended_data)

    {

        case 1:

            m_bhv->active = state;

        break;

        case 2:

            m_bhv->active = state;

            if(m_bhv->active)

            {

                PrintStringTableEntryInConsole(missionlevel_messages[m_bhv->string_no]);

                mission_messages_timer = timeGetTime() + strlen(missionlevel_messages[m_bhv->string_no]) * 80;

            }

        break;

        default: 

            if(m_bhv->active && state)

            {

                PrintStringTableEntryInConsole(missionlevel_messages[m_bhv->string_no]);

                mission_messages_timer = timeGetTime() + strlen(missionlevel_messages[m_bhv->string_no]) * 80;

            }

    }

}

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

** Loading and Saving **

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

#include "savegame.h"

typedef struct message_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    int active;

} MESSAGE_SAVE_BLOCK;

void LoadStrategy_Message(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    MESSAGE_SAVE_BLOCK* block = (MESSAGE_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)

        return;

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

    if(sbPtr->type != I_BehaviourMessage)

        return;

    MESSAGE_BEHAV_BLOCK* m_bhv = (MESSAGE_BEHAV_BLOCK *)sbPtr->dataptr;

    //start copying stuff

    m_bhv->active = block->active;

}

void SaveStrategy_Message(STRATEGYBLOCK* sbPtr)

{

    MESSAGE_SAVE_BLOCK* block; 

    MESSAGE_BEHAV_BLOCK* m_bhv = (MESSAGE_BEHAV_BLOCK *)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    //start copying stuff

    block->active = m_bhv->active;

}

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

** Loading/Saving mission state **

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

extern int GetMissionStateForSave(void* mission_objective);

extern void SetMissionStateFromLoad(void* mission_objective,int state);

typedef struct mission_complete_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    int state;

} MISSION_COMPLETE_SAVE_BLOCK;

void LoadStrategy_MissionComplete(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    MISSION_COMPLETE_SAVE_BLOCK* block = (MISSION_COMPLETE_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)

        return;

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

    if(sbPtr->type != I_BehaviourMissionComplete)

        return;

    MISSION_COMPLETE_BEHAV_BLOCK* m_bhv = (MISSION_COMPLETE_BEHAV_BLOCK *)sbPtr->dataptr;

    //start copying stuff

       SetMissionStateFromLoad(m_bhv->mission_objective_ptr , block->state);

}

void SaveStrategy_MissionComplete(STRATEGYBLOCK* sbPtr)

{

    MISSION_COMPLETE_SAVE_BLOCK* block; 

    MISSION_COMPLETE_BEHAV_BLOCK* m_bhv = (MISSION_COMPLETE_BEHAV_BLOCK *)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    //start copying stuff

    block->state = GetMissionStateForSave(m_bhv->mission_objective_ptr);

}