#include "system.h"

#include "prototyp.h"

#include "stratdef.h"

#include "npc_alien.h"

#include "npc_marine.h"

#include "generator.h"

#include "pheromon.h"

#include "bh_far.h"

#include "pldghost.h"

#include <assert.h>

#include <stdlib.h>

#include <stdio.h>

HIVE_DATA NPCHive;

//generator details that are initialised with in setup_generators in the rif load

static struct

{

    int maxGeneratorNPCs;

    int generatorNPCsPerMinute;

    int deltaGeneratorNPCsPerMinute;

    int hiveStateBaseTime;

} LoadedHiveData; 

int NearAliens;

int FarAliens;

int ShowHiveState = 0;

void InitGenerator(void *bhdata, STRATEGYBLOCK *sbPtr)

{

     GENERATOR_BLOCK *genBlock = malloc(sizeof(GENERATOR_BLOCK));

    if (genBlock)

    {

        GENERATOR_BLOCK *toolsData = (GENERATOR_BLOCK *)bhdata;

        *genBlock = *toolsData;

        genBlock->Timer = 0;       

        genBlock->RateIncreaseTimer = 60*ONE_FIXED;

        if(genBlock->GenerationRate <= 0)

            genBlock->GenerationRate = 1;

        sbPtr->dataptr = (void *)genBlock;

        sbPtr->containingModule = ModuleFromPosition(&genBlock->Position, NULL);

        assert(sbPtr->containingModule);

        NPCHive.numGenerators++;            

        /* init generator times to something quite small... 

        so that we get some npcs in the env quickly */

        genBlock->Timer = ONE_FIXED;

        //work out which types of alien can be generated on this level (for multiplayer)

        if(genBlock->Alien_Wt)

            NPCHive.AliensCanBeGenerated = 1;

        if(genBlock->PredAlien_Wt)

            NPCHive.PredAliensCanBeGenerated = 1;

        if(genBlock->Praetorian_Wt)

            NPCHive.PraetoriansCanBeGenerated = 1;

    }

    else

    {

        RemoveBehaviourStrategy(sbPtr);

    }

}

static int NumNPCsFromThisGenerator(STRATEGYBLOCK* gen_sbptr)

{

    int sbIndex = 0;

    int numOfNPCs = 0;

    while(sbIndex < NumActiveStBlocks)

    {    

        STRATEGYBLOCK *sbPtr = ActiveStBlockList[sbIndex++];

        switch(sbPtr->type)

        {

            case I_BehaviourAlien:

            {

                ALIEN_STATUS_BLOCK* status_block = (ALIEN_STATUS_BLOCK*)sbPtr->dataptr;

                if(status_block->generator_sbptr == gen_sbptr)

                    numOfNPCs++;

            }

            break;

            case I_BehaviourMarine:

            {

                MARINE_STATUS_BLOCK* status_block = (MARINE_STATUS_BLOCK*)sbPtr->dataptr;

                if(status_block->generator_sbptr == gen_sbptr)

                    numOfNPCs++;

            }

            default:

            break;

        }

    }

return numOfNPCs;

}

static int NumGeneratorNPCsInEnv()

{

    int sbIndex = 0;

    int numOfNPCs = 0;

    while(sbIndex < NumActiveStBlocks)

    {    

        STRATEGYBLOCK *sbPtr = ActiveStBlockList[sbIndex++];

        switch(sbPtr->type)

        {

            case I_BehaviourAlien:

            case I_BehaviourMarine:

            {

                //All placed bad guys will have the last character of the sbname as 0

                //generated badguys shoud have a non-zero last character.

                if(sbPtr->SBname[SB_NAME_LENGTH-1])

                    numOfNPCs++;

            }

            default:

            break;

        }

    }

return numOfNPCs;

}

void GeneratorBehaviour(STRATEGYBLOCK *sbPtr)

{

    GENERATOR_BLOCK *genBlock = (GENERATOR_BLOCK *)sbPtr->dataptr;

    /* don't do this for a net game */

    switch(AvP.PlayMode)

    {

        case NetworkHost:

        case NetworkPeer:

            return;

        default:

        break;

    }

    /* if our number of generators/minute is not > 0, the generator system is

    effectively turned off... */

    if(!(NPCHive.generatorNPCsPerMinute > 0) || !genBlock->Active)

        return;

    /* if generator is visible, do not create a new NPC */

    if(ModuleCurrVisArray[sbPtr->containingModule->m_index]) 

            return;

    /*if generator is using its own rate values , check for rate increase */

    if(genBlock->use_own_rate_values)

    {

        genBlock->RateIncreaseTimer -= NormalFrameTime;

        if(genBlock->RateIncreaseTimer < 0)

        {

            genBlock->RateIncreaseTimer = ONE_FIXED*60;

            genBlock->GenerationRate += genBlock->GenerationRateIncrease;

            genBlock->GenerationRate = min(genBlock->GenerationRate, GENSPERMINUTE_MAX*100);

            genBlock->GenerationRate = max(genBlock->GenerationRate, GENSPERMINUTE_MIN*100);

        }

    }

    /* if there are too many npcs in the env, do not create a new one */

    if(genBlock->use_own_max_npc)

    {

        //check npcs from this generator

        if (NumNPCsFromThisGenerator(sbPtr) > genBlock->MaxGenNPCs) 

            return;

    }

    else if (NumGeneratorNPCsInEnv() > NPCHive.maxGeneratorNPCs) 

    {

        return;

    }

    genBlock->Timer -= NormalFrameTime;

    if(genBlock->Timer > 0)

        return;

    if(genBlock->use_own_rate_values)

    {

        assert(genBlock->GenerationRate);

        genBlock->Timer    = (60 * ONE_FIXED *100)/genBlock->GenerationRate;

    }

    else

    {

        /* if we get here, there must be at least one generator, and some kind of generator rate */

        assert(NPCHive.numGenerators > 0);     

        assert(NPCHive.generatorNPCsPerMinute > 0);

        /* set the timer */        

        genBlock->Timer    = ((60 * ONE_FIXED) / NPCHive.generatorNPCsPerMinute) * NPCHive.numGenerators;

    }

    /* randomise +- an eighth */

    genBlock->Timer = ((genBlock->Timer * 7) / 8) + (FastRandom() % (genBlock->Timer / 4)); 

    if(genBlock->Timer > GENERATORTIME_MAX)

        genBlock->Timer = GENERATORTIME_MAX;

    else if(genBlock->Timer < GENERATORTIME_MIN)

        genBlock->Timer = GENERATORTIME_MIN;    

    /* at this point, we have reset the timer, and are set to 

    generate a new npc: however, some things can still 

    prevent this: eg if the module is visible, or there are too 

    many generator npcs in the environment */

    /*If in a network game , must also make sure the module isn't visible by other players*/

/*

    if(AvP.Network != I_No_Network)

    {

        // go through the strategy blocks looking for players

        int sbIndex = 0;

        for(; sbIndex < NumActiveStBlocks; sbIndex++)

        {

            STRATEGYBLOCK *playerSbPtr = ActiveStBlockList[sbIndex];

            if(I_BehaviourNetGhost == playerSbPtr->type)

            {

                NETGHOSTDATABLOCK *ghostData = (NETGHOSTDATABLOCK *)playerSbPtr->dataptr;

                switch(ghostData->type)

                {

                    case I_BehaviourAlienPlayer:

                    case I_BehaviourMarinePlayer:

                    case I_BehaviourPredatorPlayer:

                    {

                        //this is another player

                        if(playerSbPtr->containingModule && IsModuleVisibleFromModule(playerSbPtr->containingModule, sbPtr->containingModule))

                                return; //Another player can see this generator's module

                    }

                    default:

                    break;

                }

            }

        }

    }

*/

    /* ok... create an NPC, then */

    assert(genBlock->WeightingTotal);

    {

        int random = FastRandom() % genBlock->WeightingTotal;

        if(random < 0)

            random = -random;

        if(random < genBlock->Alien_Wt)

        {

            CreateAlienDynamic(sbPtr, Standard);

        return;

        }

        random -= genBlock->Alien_Wt;

        if(random < genBlock->PredAlien_Wt)

        {

            CreateAlienDynamic(sbPtr, Predalien);

        return;

        }

        random -= genBlock->PredAlien_Wt;

        if(random < genBlock->Praetorian_Wt)

        {

            CreateAlienDynamic(sbPtr, Praetorian);

        return;

        }

        random -= genBlock->Praetorian_Wt;

        if(random < genBlock->PulseMarine_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_PulseRifle);

        return;

        }

        random -= genBlock->PulseMarine_Wt;

        if(random < genBlock->PistolMarine_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_PistolMarine);

        return;

        }

        random -= genBlock->PistolMarine_Wt;

        if(random < genBlock->FlameMarine_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_Flamethrower);

        return;

        }

        random -= genBlock->FlameMarine_Wt;

        if(random < genBlock->SmartMarine_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_Smartgun);

        return;

        }

        random -= genBlock->SmartMarine_Wt;

        if(random < genBlock->SadarMarine_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_SADAR);

        return;

        }

        random -= genBlock->SadarMarine_Wt;

        if(random < genBlock->GrenadeMarine_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_GrenadeLauncher);

        return;

        }

        random -= genBlock->GrenadeMarine_Wt;

        if(random < genBlock->MinigunMarine_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_Minigun);

        return;

        }

        random -= genBlock->MinigunMarine_Wt;

        if(random < genBlock->ShotgunCiv_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_MShotgun);

        return;

        }

        random -= genBlock->ShotgunCiv_Wt;

        if(random < genBlock->PistolCiv_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_MPistol);

        return;

        }

        random -= genBlock->PistolCiv_Wt;

        if(random < genBlock->FlameCiv_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_MFlamer);

        return;

        }

        random -= genBlock->FlameCiv_Wt;

        if(random < genBlock->UnarmedCiv_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_MUnarmed);

        return;

        }

        random -= genBlock->UnarmedCiv_Wt;

        if(random < genBlock->MolotovCiv_Wt)

        {

            CreateMarineDynamic(sbPtr, MNPCW_MMolotov);

        return;

        }

        random -= genBlock->MolotovCiv_Wt;

        assert(0=="Failed to select generator badguy");

    }

}

static void ResetHiveStateTime()

{

    /* set the timer, +- an eighth */    

    int baseTime = LoadedHiveData.hiveStateBaseTime;

    NPCHive.hiveStateTimer = ((baseTime * 7)/8) + (FastRandom() % (baseTime / 4));

}

void DeActivateHive()

{

    NPCHive.genRateTimer = 0;

    NPCHive.maxGeneratorNPCs = 0;

    NPCHive.generatorNPCsPerMinute = 0;

    NPCHive.deltaGeneratorNPCsPerMinute = 0;

}

void ActivateHive()

{

    /* Placed in for Jules's level... CDF 1/12/97, Deadline day! */

    NPCHive.maxGeneratorNPCs = LoadedHiveData.maxGeneratorNPCs;

    NPCHive.generatorNPCsPerMinute = LoadedHiveData.generatorNPCsPerMinute;

    NPCHive.deltaGeneratorNPCsPerMinute = LoadedHiveData.deltaGeneratorNPCsPerMinute;

    NPCHive.genRateTimer = 60 * ONE_FIXED;

    /* validate these parameters */

    if(NPCHive.maxGeneratorNPCs > MAXGENNPCS_MAX) 

        NPCHive.maxGeneratorNPCs = MAXGENNPCS_MAX;

    if(NPCHive.maxGeneratorNPCs < MAXGENNPCS_MIN) 

        NPCHive.maxGeneratorNPCs = MAXGENNPCS_MIN;

    if(NPCHive.generatorNPCsPerMinute > GENSPERMINUTE_MAX) 

        NPCHive.generatorNPCsPerMinute = GENSPERMINUTE_MAX;

    if(NPCHive.generatorNPCsPerMinute < GENSPERMINUTE_MIN) 

        NPCHive.generatorNPCsPerMinute = GENSPERMINUTE_MIN;

    if(NPCHive.deltaGeneratorNPCsPerMinute > INCREASEGENSPERMINUTE_MAX) 

        NPCHive.deltaGeneratorNPCsPerMinute = INCREASEGENSPERMINUTE_MAX;

    if(NPCHive.deltaGeneratorNPCsPerMinute < INCREASEGENSPERMINUTE_MIN) 

        NPCHive.deltaGeneratorNPCsPerMinute = INCREASEGENSPERMINUTE_MIN;

    ResetHiveStateTime();

}

void InitHive()

{

    NPCHive.currentState = HS_Attack;

    NPCHive.numGenerators = 0;

    NPCHive.hiveStateTimer = 0;

    NPCHive.genRateTimer = 0;

    NPCHive.maxGeneratorNPCs = 0;

    NPCHive.generatorNPCsPerMinute = 0;

    NPCHive.deltaGeneratorNPCsPerMinute = 0;

    NPCHive.AliensCanBeGenerated = 0;

    NPCHive.PredAliensCanBeGenerated = 0;

    NPCHive.PraetoriansCanBeGenerated = 0;

    NearAliens = FarAliens = 0;

}

/*---------------------Patrick 21/1/97------------------------

 Do hive management:

 generator time is decreased at the start of an attack phase  

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

void DoHive()

{

    NPCHive.hiveStateTimer -= NormalFrameTime;

    if(NPCHive.hiveStateTimer <= 0)

    {

        NPCHive.currentState = (NPCHive.currentState == HS_Attack) ? HS_Regroup : HS_Attack;

        ResetHiveStateTime();

    }

    NPCHive.genRateTimer -= NormalFrameTime;

    if(NPCHive.genRateTimer <= 0)

    {

        /* increase frequency */

        NPCHive.generatorNPCsPerMinute += NPCHive.deltaGeneratorNPCsPerMinute;

        if(NPCHive.generatorNPCsPerMinute > GENSPERMINUTE_MAX) 

            NPCHive.generatorNPCsPerMinute = GENSPERMINUTE_MAX;                

        else if(NPCHive.generatorNPCsPerMinute < GENSPERMINUTE_MIN) 

            NPCHive.generatorNPCsPerMinute = GENSPERMINUTE_MIN;

        NPCHive.genRateTimer = ONE_FIXED * 60;

    }

    if (ShowHiveState)

    {

        if(NPCHive.currentState == HS_Attack)

            printf("Hive Attacking %d...\n", NPCHive.hiveStateTimer);

        else

            printf("Hive Retreating %d...\n", NPCHive.hiveStateTimer);

        printf("Near Aliens = %d\nFar Aliens = %d\n", NearAliens,FarAliens);

        NearAliens = FarAliens = 0;

    }

}

int NumGeneratorNPCsVisible()

{

    int sbIndex = 0;

    int numOfVisNPCs = 0;

    while(sbIndex < NumActiveStBlocks)

    {    

        STRATEGYBLOCK *sbPtr = ActiveStBlockList[sbIndex++];

        switch(sbPtr->type)

        {

            case I_BehaviourAlien:

            case I_BehaviourMarine:

                if(sbPtr->DisplayBlock)

                    numOfVisNPCs++;

            default:

            break;

        }

    }

return numOfVisNPCs;

}

void ForceAGenerator()

{

    int sbIndex = 0;

    while(sbIndex < NumActiveStBlocks)

    {    

        STRATEGYBLOCK *sbPtr = ActiveStBlockList[sbIndex++];

        if(sbPtr->type == I_BehaviourGenerator)

        {    

            GENERATOR_BLOCK *genBlock = (GENERATOR_BLOCK *)sbPtr->dataptr;

            if(genBlock->Timer > 0) 

            {    

                /* found a generator with timer > 0, so set it to zero and return */

                genBlock->Timer = 0;

                return;

            }

        }

    }

}

void SetHiveParamaters(int max,int genpermin,int deltagenpermin,int time)

{

    LoadedHiveData.maxGeneratorNPCs = max;

    LoadedHiveData.generatorNPCsPerMinute = genpermin;

    LoadedHiveData.deltaGeneratorNPCsPerMinute = deltagenpermin;

    LoadedHiveData.hiveStateBaseTime = time;

}

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

** Loading and Saving **

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

#include "savegame.h"

typedef struct generator_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    int Timer;

    int Active; 

    int GenerationRate;        //scaled up by 100

    int RateIncreaseTimer;

} GENERATOR_SAVE_BLOCK;

//defines for load/save macros

#define SAVELOAD_BLOCK block

#define SAVELOAD_BEHAV genBlock

void LoadStrategy_Generator(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    GENERATOR_SAVE_BLOCK* block = (GENERATOR_SAVE_BLOCK*) header; 

    //check the size of the save block

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

    {

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

        if(NULL != sbPtr)

        {

            if(I_BehaviourGenerator == sbPtr->type)

            {

                GENERATOR_BLOCK *genBlock = (GENERATOR_BLOCK*)sbPtr->dataptr;

                COPYELEMENT_LOAD(Timer)

                COPYELEMENT_LOAD(Active)

                COPYELEMENT_LOAD(GenerationRate)

                COPYELEMENT_LOAD(RateIncreaseTimer)

            }

        }

    }

}

void SaveStrategy_Generator(STRATEGYBLOCK* sbPtr)

{

    GENERATOR_SAVE_BLOCK *block;

    GENERATOR_BLOCK *genBlock = (GENERATOR_BLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    //start copying stuff

    COPYELEMENT_SAVE(Timer)

    COPYELEMENT_SAVE(Active)

    COPYELEMENT_SAVE(GenerationRate)

    COPYELEMENT_SAVE(RateIncreaseTimer)

}

typedef struct hive_save_block

{

    SAVE_BLOCK_HEADER header;

    HIVE_STATE currentState;

    int hiveStateTimer;

    int genRateTimer;

    int generatorNPCsPerMinute;

} HIVE_SAVE_BLOCK;

#undef  SAVELOAD_BLOCK

#undef  SAVELOAD_BEHAV

//defines for load/save macros

#define SAVELOAD_BLOCK block

#define SAVELOAD_BEHAV (&NPCHive)

void LoadHiveSettings(SAVE_BLOCK_HEADER* header)

{

    HIVE_SAVE_BLOCK* block = (HIVE_SAVE_BLOCK*) header; 

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

    {

        COPYELEMENT_LOAD(currentState)

        COPYELEMENT_LOAD(hiveStateTimer)

        COPYELEMENT_LOAD(genRateTimer)

        COPYELEMENT_LOAD(generatorNPCsPerMinute)

    }

}

void SaveHiveSettings()

{

    HIVE_SAVE_BLOCK* block;

    GET_SAVE_BLOCK_POINTER(block);

    //fill in the header

    block->header.type = SaveBlock_GlobalHive;

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

    COPYELEMENT_SAVE(currentState)

    COPYELEMENT_SAVE(hiveStateTimer)

    COPYELEMENT_SAVE(genRateTimer)

    COPYELEMENT_SAVE(generatorNPCsPerMinute)

}