#include "system.h"

#include "prototyp.h"

#include "stratdef.h"

#include "bh_types.h"

#include "videoscreen.h"

#include "dynamics.h"

#include "debris.h"

#include "npc_facehugger.h"

#include "pvisible.h"

#include <assert.h>

#include <stdlib.h>

#include <stdio.h>

int FmvColourRed;

int FmvColourGreen;

int FmvColourBlue;

void InitVideoScreen(void* bhdata, STRATEGYBLOCK *sbPtr)

{

    TOOLS_DATA_VIDEO_SCREEN *toolsData = (TOOLS_DATA_VIDEO_SCREEN *)bhdata;

    VIDEO_SCREEN_BEHAV_BLOCK* videoScreen = sbPtr->dataptr = malloc(sizeof(VIDEO_SCREEN_BEHAV_BLOCK));

    int i;

    sbPtr->DynPtr = AllocateDynamicsBlock(DYNAMICS_TEMPLATE_STATIC);

    if((NULL == videoScreen) || (NULL == sbPtr->DynPtr))

    {

        RemoveBehaviourStrategy(sbPtr);

        return;

    }

    videoScreen->bhvr_type = I_BehaviourVideoScreen;

    sbPtr->maintainVisibility = 1;

    videoScreen->hidingfacehugger = !(random () % 15);

    videoScreen->inan_tac = NULL;

    {

        const NPC_DATA *NpcData = &NpcDataList[I_NPC_DefaultInanimate];

        sbPtr->DamageBlock = NpcData->StartingStats;

        sbPtr->DamageBlock.Health = NpcData->StartingStats.Health << ONE_FIXED_SHIFT;

        sbPtr->DamageBlock.Armour = NpcData->StartingStats.Armour << ONE_FIXED_SHIFT;

    }

    sbPtr->DamageBlock.Health *= toolsData->integrity;

    sbPtr->DamageBlock.Indestructable = (toolsData->integrity > 20);

    {

        DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

        dynPtr->IsStatic = 0;

        dynPtr->GravityOn = 0;

        dynPtr->PrevPosition = dynPtr->Position = toolsData->position;

        dynPtr->OrientEuler = toolsData->orientation;

        CreateEulerMatrix(&dynPtr->OrientEuler, &dynPtr->OrientMat);

        TransposeMatrixCH(&dynPtr->OrientMat);      

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

        if(NULL == sbPtr->containingModule)

        {

            printf("no containing module for videoscreen\n");

            RemoveBehaviourStrategy(sbPtr);

            return;

        }

    }

    for(i=0; i < SB_NAME_LENGTH; i++)

        sbPtr->SBname[i] = toolsData->nameID[i];

    /*check to see if object is animated.*/

    {

        int item_num = 0;

        struct shapeheader* shptr = mainshapelist[sbPtr->shapeIndex];

        TXACTRLBLK **pptxactrlblk = &videoScreen->inan_tac;

        for(; item_num < shptr->numitems; item_num++)

        {

            POLYHEADER *poly = (POLYHEADER*)(shptr->items[item_num]);

            if(poly->PolyFlags & iflag_txanim)

            {

                TXACTRLBLK *pnew_txactrlblk = malloc(sizeof(TXACTRLBLK));

                if(pnew_txactrlblk)

                {

                    pnew_txactrlblk->tac_flags = 0;                                        

                    pnew_txactrlblk->tac_item = item_num;                                        

                    pnew_txactrlblk->tac_sequence = 0;                                        

                    pnew_txactrlblk->tac_node = 0;                                        

                    pnew_txactrlblk->tac_txarray = GetTxAnimArrayZ(sbPtr->shapeIndex, item_num);                                        

                    pnew_txactrlblk->tac_txah_s = GetTxAnimHeaderFromShape(pnew_txactrlblk, sbPtr->shapeIndex);

                    *pptxactrlblk = pnew_txactrlblk;

                    pptxactrlblk = &pnew_txactrlblk->tac_next;

                }

                else

                    *pptxactrlblk = NULL; 

            }

        }

        *pptxactrlblk = NULL;

    }

    //copy destruction target stuff

    videoScreen->destruct_target_request = toolsData->destruct_target_request;

    for(i=0;i < SB_NAME_LENGTH; i++)

        videoScreen->destruct_target_ID[i] = toolsData->destruct_target_ID[i];

    videoScreen->destruct_target_sbptr = 0;

}

extern void update_static();

void VideoScreenBehaviour(STRATEGYBLOCK *sbPtr)

{

    if(sbPtr->DisplayBlock)

      {

        DISPLAYBLOCK* dptr = sbPtr->DisplayBlock;

        VIDEO_SCREEN_BEHAV_BLOCK* videoScreen = sbPtr->dataptr;

        LIGHTBLOCK *lightPtr = dptr->ObLights[0];

        update_static();

        if ((NULL != lightPtr)  && (dptr->ObNumLights == 1))

        {

            lightPtr->LightBright = ONE_FIXED/2;

            //lightPtr->LightFlags;

            lightPtr->LightRange = 3500; 

            //lightPtr->RedScale=   FmvColourRed;

            //lightPtr->GreenScale= FmvColourGreen;

            //lightPtr->BlueScale=  FmvColourBlue;

            lightPtr->RedScale = 256 * 256;

            lightPtr->GreenScale = 256 * 256;

            lightPtr->BlueScale = 256 * 256;

        }

        //deal with texture animation if near

        if(videoScreen->inan_tac && !dptr->ObTxAnimCtrlBlks)

            dptr->ObTxAnimCtrlBlks = videoScreen->inan_tac;

        if(sbPtr->containingModule == PlayerStatus.sbptr->containingModule)

        {

            if (videoScreen->hidingfacehugger && (AvP.PlayerType != I_Alien) && !(random() % 300))

            {

                CreateFacehuggerBot(&sbPtr->DisplayBlock->ObWorld);

                MakeFragments(sbPtr);

                sbPtr->please_destroy_me = 1;

            }

        }

    }

}

void VideoScreenIsDamaged(STRATEGYBLOCK *sbPtr, const DAMAGE_PROFILE *damage, int multiple)

{

    if(sbPtr->DamageBlock.Health <= 0) 

    {

        VIDEO_SCREEN_BEHAV_BLOCK* videoScreen = sbPtr->dataptr;

        //notify target of destruction

        if(videoScreen->destruct_target_sbptr)

            RequestState(videoScreen->destruct_target_sbptr,videoScreen->destruct_target_request,0);

        MakeFragments(sbPtr);

        sbPtr->please_destroy_me = 1;

    }

}

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

** Loading and Saving **

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

#include "savegame.h"

typedef struct video_screen_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    //strategyblock stuff

    DAMAGEBLOCK DamageBlock;

} VIDEO_SCREEN_SAVE_BLOCK;

void LoadStrategy_VideoScreen(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    VIDEO_SCREEN_SAVE_BLOCK* block = (VIDEO_SCREEN_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_BehaviourVideoScreen)

        return;

    VIDEO_SCREEN_BEHAV_BLOCK* videoScreen = (VIDEO_SCREEN_BEHAV_BLOCK*)sbPtr->dataptr;

    sbPtr->DamageBlock = block->DamageBlock;

}

void SaveStrategy_VideoScreen(STRATEGYBLOCK* sbPtr)

{

    VIDEO_SCREEN_SAVE_BLOCK *block;

    VIDEO_SCREEN_BEHAV_BLOCK* videoScreen = (VIDEO_SCREEN_BEHAV_BLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block, sbPtr);

    block->DamageBlock = sbPtr->DamageBlock;

}