#include "system.h"

#include "prototyp.h"

#include "stratdef.h"

#include "track.h"

#include "fan.h"

#include "dynamics.h"

#include "weapons.h"

#include <stdlib.h>

#include <assert.h>

static DAMAGE_PROFILE fan_damage = {0,100,0,0,0,0,2,1,1,0,0,AMMO_FAN};

void FanBehaveInit(void* bhdata, STRATEGYBLOCK* sbptr)

{

    assert(sbptr);

    assert(bhdata);

    FAN_BEHAV_BLOCK* f_bhv = malloc(sizeof(FAN_BEHAV_BLOCK));

    sbptr->DynPtr = AllocateDynamicsBlock(DYNAMICS_TEMPLATE_STATIC);

    sbptr->dataptr = f_bhv;

    sbptr->containingModule = ModuleFromPosition(&sbptr->DynPtr->Position, NULL);

    if(!f_bhv || !sbptr->DynPtr)// || (NULL == sbptr->containingModule))

    {

        RemoveBehaviourStrategy(sbptr);

        return;

    }

    sbptr->maintainVisibility = 1;

    f_bhv->bhvr_type = I_BehaviourFan;

    FAN_TOOLS_TEMPLATE* f_tt = (FAN_TOOLS_TEMPLATE*)bhdata;

    //sbptr->shapeIndex = f_tt->shape_num;

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

    sbptr->DynPtr->Position = sbptr->DynPtr->PrevPosition = f_tt->position;

    sbptr->DynPtr->OrientEuler = f_tt->orientation;

    CreateEulerMatrix(&sbptr->DynPtr->OrientEuler, &sbptr->DynPtr->OrientMat);

    TransposeMatrixCH(&sbptr->DynPtr->OrientMat);    

    f_bhv->track = f_tt->track;

    assert(f_bhv->track);

    f_bhv->track->sbptr = sbptr;

    f_bhv->track->use_speed_mult = 1;

    f_bhv->speed_up_mult = f_tt->speed_up_mult;

    f_bhv->slow_down_mult = f_tt->slow_down_mult;

    f_bhv->fan_wind_direction = f_tt->fan_wind_direction;

    f_bhv->fan_wind_strength = f_tt->fan_wind_strength;

    if(f_bhv->track->playing)

    {

        f_bhv->speed_mult = ONE_FIXED;

        f_bhv->track->speed_mult = ONE_FIXED;

         f_bhv->spinning = 1;

    }

    else

    {

        f_bhv->speed_mult = 0;

         f_bhv->spinning = 0;

    }

    f_bhv->wind_speed = MUL_FIXED(f_bhv->speed_mult, f_bhv->fan_wind_strength);

}

void FanBehaveFun(STRATEGYBLOCK* sbptr)

{

     assert(sbptr);

     FAN_BEHAV_BLOCK *f_bhv = (FAN_BEHAV_BLOCK*)sbptr->dataptr;

    assert((f_bhv->bhvr_type == I_BehaviourFan));

    assert(f_bhv->track);

    if(!sbptr->DisplayBlock)

        return;

    //printf("I am a fan\n");

    if(f_bhv->spinning)

    {

        if(!f_bhv->speed_mult)

        {

            //fan just starting

            Start_Track_Playing(f_bhv->track);

        }

        if(f_bhv->speed_mult < ONE_FIXED)

        {

            //fan currently accelerating

            f_bhv->speed_mult += MUL_FIXED(NormalFrameTime,f_bhv->speed_up_mult);

            if(f_bhv->speed_mult >= ONE_FIXED)

                f_bhv->speed_mult = ONE_FIXED;

            f_bhv->track->speed_mult = f_bhv->speed_mult;

            //update wind speed

            f_bhv->wind_speed = MUL_FIXED(f_bhv->speed_mult,f_bhv->fan_wind_strength);

        }

    }

    else

    {

        if(f_bhv->speed_mult > 0)

        {

            //fan currently slowing down

            f_bhv->speed_mult -= MUL_FIXED(NormalFrameTime,f_bhv->slow_down_mult);

            if(f_bhv->speed_mult < 0)

            {

                //fan has come to a stop

                f_bhv->speed_mult = 0;

                Stop_Track_Playing(f_bhv->track);

            }

            f_bhv->track->speed_mult = f_bhv->speed_mult;

            //update wind speed

            f_bhv->wind_speed = MUL_FIXED(f_bhv->speed_mult,f_bhv->fan_wind_strength);

        }    

    }

    if(f_bhv->speed_mult)

        Update_Track_Position(f_bhv->track);

    //see if fan has hit anything

    if(sbptr->DynPtr->CollisionReportPtr)

    {

        //don't cause damage unless fan is going reasonably fast

        if(f_bhv->speed_mult > ONE_FIXED/4)

        {

            COLLISIONREPORT* reportptr = sbptr->DynPtr->CollisionReportPtr;

            fan_damage.Cutting = MUL_FIXED(f_bhv->speed_mult, 200); 

            //go through all the collision reports and damage any creatures found

            while(reportptr)

            {

                if(reportptr->ObstacleSBPtr)

                {

                    STRATEGYBLOCK* hit_sbptr = reportptr->ObstacleSBPtr;

                    switch(hit_sbptr->type)

                    {

                        case I_BehaviourAlien:

                        case I_BehaviourQueenAlien:

                        case I_BehaviourFaceHugger:

                           case I_BehaviourPredator:

                        case I_BehaviourXenoborg:

                        case I_BehaviourMarine:

                        case I_BehaviourMarinePlayer:

                        case I_BehaviourPredatorPlayer:

                        case I_BehaviourAlienPlayer:

                        case I_BehaviourInanimateObject:

                        {

                            hit_sbptr->DamageBlock.Indestructable = 0;

                            if(f_bhv->speed_mult == ONE_FIXED)

                            {

                                //ensure death if fan is going at full speed

                                CauseDamageToObject(hit_sbptr, &fan_damage, 100*ONE_FIXED, &f_bhv->fan_wind_direction);

                            }

                            else

                            {

                                CauseDamageToObject(hit_sbptr, &fan_damage, NormalFrameTime, &f_bhv->fan_wind_direction);

                            }

                        }

                        default:

                        break;

                    }

                }

                reportptr = reportptr->NextCollisionReportPtr;

            }

        }

    }

}

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

** Loading and Saving **

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

#include "savegame.h"

typedef struct fan_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    int spinning:1;

    int speed_mult;    //0 to one_fixed : current speed relative to full speed

    int wind_speed;//fixed point multiplier , taking the fan's current speed into account

} FAN_SAVE_BLOCK;

//defines for load/save macros

#define SAVELOAD_BLOCK block

#define SAVELOAD_BEHAV f_bhv

void LoadStrategy_Fan(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    FAN_SAVE_BLOCK* block = (FAN_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_BehaviourFan)

        return;

    FAN_BEHAV_BLOCK *f_bhv = (FAN_BEHAV_BLOCK*)sbPtr->dataptr;

    //start copying stuff

    COPYELEMENT_LOAD(spinning)

    COPYELEMENT_LOAD(speed_mult)

    COPYELEMENT_LOAD(wind_speed)

    //load the track position

    if(f_bhv->track)

    {

        SAVE_BLOCK_HEADER* track_header = GetNextBlockIfOfType(SaveBlock_Track);

        if(track_header)

            LoadTrackPosition(track_header,f_bhv->track);

    }

}

void SaveStrategy_Fan(STRATEGYBLOCK* sbPtr)

{

    FAN_SAVE_BLOCK* block; 

    FAN_BEHAV_BLOCK *f_bhv = (FAN_BEHAV_BLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    //start copying stuff

    COPYELEMENT_SAVE(spinning)

    COPYELEMENT_SAVE(speed_mult)

    COPYELEMENT_SAVE(wind_speed)

    //save the track position

    if(f_bhv->track)

        SaveTrackPosition(f_bhv->track);

}