#include "system.h"

#include "stratdef.h"

#include "bh_types.h"

#include "linkswitch.h"

#include "pldghost.h"

#include "binaryswitch.h"

#include <assert.h>

#include <stdlib.h>

#include <stdio.h>

extern int RealFrameTime;

static int check_link_switch_states (LINK_SWITCH_BEHAV_BLOCK * lsbb)

{

    int i=0;

    LSWITCH_ITEM * lsi = lsbb->lswitch_list;

//    printf("Checking link states\n");

    if (!lsbb->state)

        return 0;

//    printf("Link switch OK\n");

    while (i < lsbb->num_linked_switches)

    {

        switch(lsi[i].bswitch->type)

        {

            case I_BehaviourBinarySwitch:

            {

                BINARY_SWITCH_BEHAV_BLOCK * bsbb = ((BINARY_SWITCH_BEHAV_BLOCK *)lsi[i].bswitch->dataptr);

                // if it's off return No

                if (!bsbb->state)

                    return 0;

    //            printf("Switch %d OK\n", i);

            }

            break;

            case I_BehaviourLinkSwitch:

            {

                LINK_SWITCH_BEHAV_BLOCK * linked_lsbb = ((LINK_SWITCH_BEHAV_BLOCK *)lsi[i].bswitch->dataptr);

                // if the system state is off return No

                if (!linked_lsbb->system_state)

                    return 0;

            }

            break;

            default:

            {

                assert(0=="Switch should only have links to link switches and binary switches");

            }

        }

        i++;

    }

//    printf("Link switchs activated\n");

return 1;

}

void LinkSwitchBehaveInit(void* bhdata, STRATEGYBLOCK* sbptr)

{

     assert(sbptr);

    LINK_SWITCH_BEHAV_BLOCK *ls_bhv = malloc(sizeof(LINK_SWITCH_BEHAV_BLOCK));

    if(!ls_bhv)

    {

        RemoveBehaviourStrategy(sbptr);

        return;

    }

    sbptr->dataptr = ls_bhv;

    ls_bhv->bhvr_type = I_BehaviourLinkSwitch;

    // from loaders

    // 1 rest_state - on or off

    // 2 mode

    // 3 timer switch - time for reset

    // 4 security clerance to operate

    // 5 copy the target name

    LINK_SWITCH_TOOLS_TEMPLATE *ls_tt = (LINK_SWITCH_TOOLS_TEMPLATE*)bhdata;

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

    if (ls_tt->mode == I_lswitch_SELFDESTRUCT)

    {

        ls_bhv->ls_mode = I_lswitch_timer;

        ls_bhv->IS_SELF_DESTRUCT = 1;

    }

    else

    {

        ls_bhv->ls_mode = ls_tt->mode;

        ls_bhv->IS_SELF_DESTRUCT = 0;

    }

    ls_bhv->num_targets = ls_tt->num_targets;

    if(ls_bhv->num_targets)

    {

        ls_bhv->ls_targets = malloc(sizeof(LINK_SWITCH_TARGET) * ls_tt->num_targets);

        if (!ls_bhv->ls_targets)

        {

            RemoveBehaviourStrategy(sbptr);

            return;

        }

    }

    else

    {

        ls_bhv->ls_targets = NULL;

    }

    {

        int i;

        for (i=0; i<ls_tt->num_targets; i++)

        {

            ls_bhv->ls_targets[i] = ls_tt->targets[i];

            ls_bhv->ls_targets[i].sbptr = 0;

        }

    }

    ls_bhv->time_for_reset = ls_tt->time_for_reset;

    ls_bhv->security_clerance = ls_tt->security_clearance;

    ls_bhv->switch_flags = ls_tt->switch_flags;

    ls_bhv->trigger_volume_min = ls_tt->trigger_volume_min;    

    ls_bhv->trigger_volume_max = ls_tt->trigger_volume_max;    

    ls_bhv->switch_always_on = ls_tt->switch_always_on;

    ls_bhv->switch_off_message_same = ls_tt->switch_off_message_same;    

    ls_bhv->switch_off_message_none = ls_tt->switch_off_message_none;    

    // set up the animation control

    if(sbptr->shapeIndex != -1)

    {

        sbptr->DynPtr = AllocateDynamicsBlock(DYNAMICS_TEMPLATE_STATIC);

        if(NULL == sbptr->DynPtr)

        {

            RemoveBehaviourStrategy(sbptr);

            return;

        }

        else

        {

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

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

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

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

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

            if(NULL == sbptr->containingModule)

            {

                printf("no contaning module for link switch\n");

                RemoveBehaviourStrategy(sbptr);

                return;

            }

            sbptr->maintainVisibility = 1;

        }

        int item_num = 0;

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

        TXACTRLBLK **pptxactrlblk = &ls_bhv->ls_tac;

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

        {

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

            assert(poly);

            if(poly->PolyFlags  & iflag_txanim)

            {

                int num_seq = 0;

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

                if (pnew_txactrlblk)

                {

                    pnew_txactrlblk->tac_flags = 0;

                    pnew_txactrlblk->tac_item = item_num;

                    pnew_txactrlblk->tac_sequence = ls_tt->rest_state;

                    pnew_txactrlblk->tac_node = 0;

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

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

                    while(pnew_txactrlblk->tac_txarray[num_seq+1])

                        num_seq++;

                    // Assert does not work at this point so

                    assert(num_seq == 2);

                    /* set the flags in the animation header */

                    // we only ever have one frame of animation per sequence -

                    // nb this can change talk to richard - one sequence with two frames

                    // or mutliple sequences???

                    //Now two sequences with an arbitrary number of frames - Richard

                    pnew_txactrlblk->tac_txah.txa_flags |= txa_flag_play;

                    /* change the value held in pptxactrlblk

                     which point to the previous structures "next"

                     pointer*/

                    *pptxactrlblk = pnew_txactrlblk;

                    pptxactrlblk = &pnew_txactrlblk->tac_next;

                }

                else

                {

                    memoryInitialisationFailure = 1;

                }

            }

        }

        *pptxactrlblk = 0;

    }

    else

    {

        //no shape - so there won't be any animation

        ls_bhv->ls_tac = 0;

    }

    ls_bhv->ls_dtype = linkswitch_no_display;

    if (ls_bhv->ls_tac)

        ls_bhv->ls_dtype = linkswitch_animate_me;

    ls_bhv->ls_track = ls_tt->track;

    if (ls_bhv->ls_track)

    {

        ls_bhv->ls_track->sbptr = sbptr;

        if (ls_bhv->ls_dtype == linkswitch_animate_me)

            ls_bhv->ls_dtype = linkswitch_animate_and_move_me;

        else

            ls_bhv->ls_dtype = linkswitch_move_me;

    }

    // fill in the rest ourselves

    ls_bhv->request = 0;

    ls_bhv->state = ls_tt->rest_state;

    ls_bhv->timer = 0;    

    ls_bhv->system_state = 0;

    ls_bhv->soundHandle = SOUND_NOACTIVEINDEX;

    ls_bhv->num_linked_switches = ls_tt->num_linked_switches;

    if(ls_tt->num_linked_switches)

    {

        ls_bhv->lswitch_list = malloc(sizeof(LSWITCH_ITEM) * ls_bhv->num_linked_switches);

        if (NULL == ls_bhv->lswitch_list)

        {

            RemoveBehaviourStrategy(sbptr);

            return;

        }

        else

        {

            int i;

            for (i=0; i < ls_tt->num_linked_switches; i++)

            {

                COPY_NAME (ls_bhv->lswitch_list[i].bs_name, ls_tt->switchIDs[i].name);

            }

        }

    }

    else

    {

        ls_bhv->lswitch_list = NULL;

    }

    if(ls_bhv->state)

    {

        ls_bhv->timer = ls_bhv->time_for_reset;    

        if(ls_bhv->ls_track)

        {

            //set the track to the end position

            ls_bhv->ls_track->current_section = (ls_bhv->ls_track->num_sections-1);

            ls_bhv->ls_track->timer = ls_bhv->ls_track->sections[ls_bhv->ls_track->current_section].time_for_section;

            ls_bhv->ls_track->playing = 1;

            Update_Track_Position(ls_bhv->ls_track);

        }

    }

    ls_bhv->TimeUntilNetSynchAllowed = 0;

}

void LinkSwitchBehaveFun(STRATEGYBLOCK* sbptr)

{

     assert(sbptr);

    LINK_SWITCH_BEHAV_BLOCK *ls_bhv = (LINK_SWITCH_BEHAV_BLOCK*)sbptr->dataptr;

    assert((ls_bhv->bhvr_type == I_BehaviourLinkSwitch));

    DISPLAYBLOCK* dptr = sbptr->DisplayBlock;

    /****** 

        What I need to do - check to see if we have

        a request - requests have different effects depending on 

        the mode - so we have to switch on the mode

    *****/

    switch(ls_bhv->ls_dtype)

    {

        case linkswitch_animate_me:

        case linkswitch_animate_and_move_me:

            if(dptr)

                dptr->ObTxAnimCtrlBlks = ls_bhv->ls_tac;

        default:

        break;

    }

    if (!ReturnPlayerSecurityClearance(ls_bhv->security_clerance) && ls_bhv->security_clerance)

    {

        ls_bhv->request = I_no_request;

        return;

    }

    if(ls_bhv->switch_flags && SwitchFlag_UseTriggerVolume)

    {

        /*See if switch has been set off*/

        int i;

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

        {

            int needToTest = 0;

            STRATEGYBLOCK *sbPtr = ActiveStBlockList[i];

            if (sbPtr->DynPtr)

            {

                if (sbPtr->DisplayBlock == PlayerStatus.DisplayBlock)

                {

                    needToTest = 1;

                }

                else if (sbPtr->type == I_BehaviourNetGhost)

                {

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

                    switch(ghostData->type)

                    {

                        case I_BehaviourMarinePlayer:

                        case I_BehaviourAlienPlayer:

                        case I_BehaviourPredatorPlayer:

                            needToTest = 1;

                        default:

                        break;

                    }

                }

            }

            if(needToTest&&

                sbPtr->DynPtr->Position.vx > ls_bhv->trigger_volume_min.vx &&    

                sbPtr->DynPtr->Position.vx < ls_bhv->trigger_volume_max.vx &&

                sbPtr->DynPtr->Position.vy > ls_bhv->trigger_volume_min.vy &&

                sbPtr->DynPtr->Position.vy < ls_bhv->trigger_volume_max.vy &&

                sbPtr->DynPtr->Position.vz > ls_bhv->trigger_volume_min.vz &&

                sbPtr->DynPtr->Position.vz < ls_bhv->trigger_volume_max.vz)

            {

                ls_bhv->request=I_request_on;

                    break;

            }

        }

    }

    if (ls_bhv->request == I_request_on)

    {

        if (ls_bhv->triggered_last)

            ls_bhv->request = I_no_request;

        else

            ls_bhv->triggered_last = 1;

    }

    else

    {

        ls_bhv->triggered_last = 0;

    }

    if(ls_bhv->switch_always_on)

    {

        ls_bhv->request = I_no_request;

        ls_bhv->state = 1;

    }

    if(SinglePlayer != AvP.PlayMode)

    {

        /*

        Every time a switch is updated there is a time delay of 5 seconds before the

        switch can next be changed by the host sending synch messages.

        This prevents the host machine from resetting a switch before it learns that

        it has been pressed

        */

        if(ls_bhv->request == I_no_request)

        {

            ls_bhv->TimeUntilNetSynchAllowed-=RealFrameTime;

            if(ls_bhv->TimeUntilNetSynchAllowed < 0)

                ls_bhv->TimeUntilNetSynchAllowed = 0;

        }

        else

        {

            ls_bhv->TimeUntilNetSynchAllowed = 5 * ONE_FIXED;

        }

    }

        switch(ls_bhv->ls_mode)

        {

                case I_lswitch_timer:

                {

                    if(ls_bhv->request == I_request_on && !ls_bhv->state) 

                    {

                         ls_bhv->timer = ls_bhv->time_for_reset;

                        switch(ls_bhv->ls_dtype)

                        {

                            case binswitch_move_me:

                            case binswitch_animate_and_move_me:

                            {

                                // moving switch

                                ls_bhv->new_state = 1;

                                ls_bhv->new_request = -1;

                                ls_bhv->ls_track->reverse=0;

                                Start_Track_Playing(ls_bhv->ls_track);

                                ls_bhv->mode_store = ls_bhv->ls_mode;

                                ls_bhv->ls_mode = I_lswitch_moving;

                            }

                            break;

                            default:

                                ls_bhv->state = 1;

                        }

                        if(ls_bhv->ls_tac)

                        {

                            ls_bhv->ls_tac->tac_sequence = 1;

                            ls_bhv->ls_tac->tac_txah_s = GetTxAnimHeaderFromShape(ls_bhv->ls_tac, (sbptr->shapeIndex));

                        }

                    }

                    else if(ls_bhv->timer > 0)

                    {

                         ls_bhv->timer -= NormalFrameTime;

                        if(ls_bhv->timer <= 0)

                        {

                            ls_bhv->state = 0;

                            switch(ls_bhv->ls_dtype)

                            {

                                case binswitch_move_me:

                                case binswitch_animate_and_move_me:

                                {

                                    // moving switch

                                    ls_bhv->new_state = 0;

                                    ls_bhv->new_request = -1;

                                    ls_bhv->ls_track->reverse=1;

                                    Start_Track_Playing(ls_bhv->ls_track);

                                    ls_bhv->mode_store = ls_bhv->ls_mode;

                                    ls_bhv->ls_mode = I_lswitch_moving;

                                }

                                default:

                                break;

                            }

                            if(ls_bhv->ls_tac)

                            {

                                ls_bhv->ls_tac->tac_sequence = 0;

                                ls_bhv->ls_tac->tac_txah_s = GetTxAnimHeaderFromShape(ls_bhv->ls_tac, (sbptr->shapeIndex));

                            }

                        }

                    }

                }

                break;                

                case I_lswitch_toggle:

                {

                    // if it's off and no request then we can return

                    if (!ls_bhv->state && (ls_bhv->request == I_no_request))

                            return;

                    /* change the state and request the new state in the target */

                    if(ls_bhv->request != I_no_request)

                    {

                        switch(ls_bhv->ls_dtype)

                        {

                            case binswitch_move_me:

                            case binswitch_animate_and_move_me:

                            {

                                // moving switch

                                ls_bhv->new_state = !ls_bhv->state;

                                ls_bhv->new_request = -1;

                                ls_bhv->mode_store = ls_bhv->ls_mode;

                                ls_bhv->ls_mode = I_lswitch_moving;

                                ls_bhv->ls_track->reverse=ls_bhv->state;

                                Start_Track_Playing(ls_bhv->ls_track);

                            }

                            break;

                            default:

                                ls_bhv->state = !ls_bhv->state;

                        }

                        if(ls_bhv->ls_tac)

                        {

                            ls_bhv->ls_tac->tac_sequence = ls_bhv->state ? 1 : 0;

                            ls_bhv->ls_tac->tac_txah_s = GetTxAnimHeaderFromShape(ls_bhv->ls_tac, (sbptr->shapeIndex));

                        }

                    }

                }

                break;                

                case I_lswitch_wait:

                {

                    if (!ls_bhv->state)

                    {

                        switch(ls_bhv->request)

                        {

                            case I_no_request:

                                return; // if it's off and no request then we can return

                            case I_request_on:

                            {

                                switch(ls_bhv->ls_dtype)

                                {

                                    case binswitch_move_me:

                                    case binswitch_animate_and_move_me:

                                    {

                                        // moving switch

                                        ls_bhv->new_state = 1;

                                        ls_bhv->new_request = -1;

                                        ls_bhv->ls_track->reverse = 0;

                                        Start_Track_Playing(ls_bhv->ls_track);

                                        ls_bhv->mode_store = ls_bhv->ls_mode;

                                        ls_bhv->ls_mode = I_lswitch_moving;

                                    }

                                    break;

                                    default:

                                        ls_bhv->state = 1;

                                }

                            }

                            default:

                            break;

                        }

                    }

                    else

                    {

                        if (ls_bhv->request == I_request_off)

                        {

                            switch(ls_bhv->ls_dtype)

                            {

                                case binswitch_move_me:

                                case binswitch_animate_and_move_me:

                                {

                                    // moving switch

                                    ls_bhv->new_state = 0;

                                    ls_bhv->new_request = -1;

                                    ls_bhv->ls_track->reverse = 1;

                                    Start_Track_Playing(ls_bhv->ls_track);

                                    ls_bhv->mode_store = ls_bhv->ls_mode;

                                    ls_bhv->ls_mode = I_lswitch_moving;

                                }

                                break;

                                default:

                                    ls_bhv->state = 0;

                            }

                        }

                    }

                    if(ls_bhv->ls_tac)

                    {

                        ls_bhv->ls_tac->tac_sequence = ls_bhv->state ? 1 : 0;

                        ls_bhv->ls_tac->tac_txah_s = GetTxAnimHeaderFromShape(ls_bhv->ls_tac, (sbptr->shapeIndex));

                    }

                }

                break;

                case I_lswitch_moving:

                {

                    //printf("moving\n");

                    Update_Track_Position(ls_bhv->ls_track);

                    if (!ls_bhv->ls_track->playing)

                    {

                        ls_bhv->ls_mode = ls_bhv->mode_store;

                        ls_bhv->state = ls_bhv->new_state;

                        if(ls_bhv->ls_tac)

                        {

                            ls_bhv->ls_tac->tac_sequence = ls_bhv->state ? 1 : 0;

                            ls_bhv->ls_tac->tac_txah_s = GetTxAnimHeaderFromShape(ls_bhv->ls_tac, (sbptr->shapeIndex));

                        }

                    }

                }

                break;

            default:

                assert(2<1);

        }

    ls_bhv->request = I_no_request;

    //check to see if the system state has changed

    if (ls_bhv->system_state)

    {

        if (!check_link_switch_states(ls_bhv))

        {

            ls_bhv->system_state = 0;

            //link switch system state is turning off

            if(!ls_bhv->switch_off_message_none)

            {

                int i;

                for(i=0; i < ls_bhv->num_targets; i++)

                    RequestState(ls_bhv->ls_targets[i].sbptr,ls_bhv->ls_targets[i].request_message^(!ls_bhv->switch_off_message_same), sbptr);

            }

        }

    }

    else

    {

        if (check_link_switch_states(ls_bhv))

        {

            int i;

            ls_bhv->system_state = 1;

            //link switch system state is turning on

            for(i=0; i < ls_bhv->num_targets; i++)

                RequestState(ls_bhv->ls_targets[i].sbptr,ls_bhv->ls_targets[i].request_message, sbptr);

        }

    }

}

#define LINKSWITCHSYNCH_ON     0

#define LINKSWITCHSYNCH_OFF     1

#define LINKSWITCHSYNCH_IGNORE 2

int LinkSwitchGetSynchData(STRATEGYBLOCK* sbPtr)

{

     assert(sbPtr);

    LINK_SWITCH_BEHAV_BLOCK *ls_bhv = (LINK_SWITCH_BEHAV_BLOCK*)sbPtr->dataptr;

    assert((ls_bhv->bhvr_type == I_BehaviourLinkSwitch));

    //don't try to synch moving switches

    if(ls_bhv->ls_mode == I_lswitch_moving)

        return LINKSWITCHSYNCH_IGNORE;

return ((ls_bhv->state) ? LINKSWITCHSYNCH_ON : LINKSWITCHSYNCH_OFF);

}

void LinkSwitchSetSynchData(STRATEGYBLOCK* sbPtr,int status)

{

     assert(sbPtr);

    LINK_SWITCH_BEHAV_BLOCK *ls_bhv = (LINK_SWITCH_BEHAV_BLOCK*)sbPtr->dataptr;

    assert((ls_bhv->bhvr_type == I_BehaviourLinkSwitch));

    if(ls_bhv->TimeUntilNetSynchAllowed > 0)

    {

        //ignore this attempt to synch the switch

        return;

    }

    //don't try to synch moving switches

    if(ls_bhv->ls_mode == I_lswitch_moving)

        return;

    switch(status)

    {

        case LINKSWITCHSYNCH_ON :

            if(!ls_bhv->state)

                RequestState(sbPtr,1,0); //this switch should be on

        break;

        case LINKSWITCHSYNCH_OFF :

            if(ls_bhv->state)

                RequestState(sbPtr,0,0); //this switch should be off

    }

}

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

** Loading and Saving **

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

#include "savegame.h"

typedef struct link_switch_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    BINARY_SWITCH_REQUEST_STATE request;

    int system_state;

    int state;

    LSWITCH_MODE ls_mode;

    int timer;

    int new_state;

    int new_request;

    LSWITCH_MODE mode_store;

    int triggered_last;

    int txanim_sequence;

} LINK_SWITCH_SAVE_BLOCK;

//defines for load/save macros

#define SAVELOAD_BLOCK block

#define SAVELOAD_BEHAV ls_bhv

void LoadStrategy_LinkSwitch(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    LINK_SWITCH_SAVE_BLOCK* block = (LINK_SWITCH_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_BehaviourLinkSwitch)

        return;

    LINK_SWITCH_BEHAV_BLOCK *ls_bhv = (LINK_SWITCH_BEHAV_BLOCK*)sbPtr->dataptr;

    //start copying stuff

    COPYELEMENT_LOAD(request)

    COPYELEMENT_LOAD(system_state)

    COPYELEMENT_LOAD(state)

    COPYELEMENT_LOAD(ls_mode)

    COPYELEMENT_LOAD(timer)

    COPYELEMENT_LOAD(new_state)

    COPYELEMENT_LOAD(new_request)

    COPYELEMENT_LOAD(mode_store)

    COPYELEMENT_LOAD(triggered_last)

    //set the texture animation sequence

    if(ls_bhv->ls_tac)

    {

        ls_bhv->ls_tac->tac_sequence = block->txanim_sequence;

        ls_bhv->ls_tac->tac_txah_s = GetTxAnimHeaderFromShape(ls_bhv->ls_tac, (sbPtr->shapeIndex));

    }

    //load the track position , if the switch has one

    if(ls_bhv->ls_track)

    {

        SAVE_BLOCK_HEADER* track_header = GetNextBlockIfOfType(SaveBlock_Track);

        if(track_header)

            LoadTrackPosition(track_header,ls_bhv->ls_track);

    }

}

void SaveStrategy_LinkSwitch(STRATEGYBLOCK* sbPtr)

{

    LINK_SWITCH_SAVE_BLOCK *block;

    LINK_SWITCH_BEHAV_BLOCK *ls_bhv = (LINK_SWITCH_BEHAV_BLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    //start copying stuff

    COPYELEMENT_SAVE(request)

    COPYELEMENT_SAVE(system_state)

    COPYELEMENT_SAVE(state)

    COPYELEMENT_SAVE(ls_mode)

    COPYELEMENT_SAVE(timer)

    COPYELEMENT_SAVE(new_state)

    COPYELEMENT_SAVE(new_request)

    COPYELEMENT_SAVE(mode_store)

    COPYELEMENT_SAVE(triggered_last)

    //get the animation sequence

    if(ls_bhv->ls_tac)

        block->txanim_sequence = ls_bhv->ls_tac->tac_sequence;

    else

        block->txanim_sequence = 0;

    //save the track position , if the switch has one

    if(ls_bhv->ls_track)

        SaveTrackPosition(ls_bhv->ls_track);

}