#pragma once

#include "hud_item_object.h"

class CCustomDetector :        public CHudItemObject {
private:
    typedef            CHudItemObject    inherited;
public:
                    CCustomDetector        ();
    virtual            ~CCustomDetector    ();

    virtual void                    Load                            (LPCSTR section);
    
    virtual BOOL                    net_Spawn                        (CSE_Abstract* DC);
    virtual void                    net_Destroy                        ();

    virtual void                    OnH_A_Chield                    ();
    virtual void                    OnH_B_Independent                (bool just_before_destroy);
    
    virtual void                    UpdateCL                        ();
    virtual void                    shedule_Update                    (u32 dt);    

    virtual void                    Hide                ();
    virtual void                    Show                ();
    //инициализация если вещь в активном слоте или спрятана на OnH_B_Chield
    virtual void            OnActiveItem();
    virtual void            OnHiddenItem();
    virtual void                    renderable_Render();
    virtual void                    OnStateSwitch        (u32 S);
    virtual void                    OnAnimationEnd        (u32 state);

    virtual    void                    UpdateXForm            ();

        enum EDETHudStates {
        eIdle        = 0,
        eShowing,
        eHiding,
        eHidden,
    };

protected:
    
    MotionSVec                        m_anim_idle;
    MotionSVec                        m_anim_show;
    MotionSVec                        m_anim_hide;
};

#include "stdafx.h"
#include "customdetector.h"
#include "hudmanager.h"
#include "inventory.h"

CCustomDetector::CCustomDetector()
{
    SetSlot (DETECTOR_SLOT);
}

CCustomDetector::~CCustomDetector()
{

}

void CCustomDetector::Load(LPCSTR section)
{
    inherited::Load            (section);
    
    R_ASSERT            (m_pHUD);
    animGet                (m_anim_idle,                    pSettings->r_string(*hud_sect,"anim_idle"));
    animGet                (m_anim_hide,                    pSettings->r_string(*hud_sect,"anim_hide"));
    animGet                (m_anim_show,                    pSettings->r_string(*hud_sect,"anim_show"));
}

BOOL CCustomDetector::net_Spawn(CSE_Abstract* DC)
{
    BOOL result = inherited::net_Spawn(DC);
    SetState                    (eHidden);
    return result;    
}

void CCustomDetector::net_Destroy()
{
    inherited::net_Destroy        ();
}

void CCustomDetector::OnH_A_Chield()
{
    inherited::OnH_A_Chield        ();
}

void CCustomDetector::OnH_B_Independent(bool just_before_destroy)
{
    inherited::OnH_B_Independent(just_before_destroy);

    if (m_pHUD)
        m_pHUD->Hide();
}

void CCustomDetector::OnActiveItem()
{
    inherited::OnActiveItem();
    //если мы занружаемся и оружие было в руках
    SetState(eIdle);
    SetNextState(eIdle);
    if (m_pHUD) m_pHUD->Show();
}

void CCustomDetector::OnHiddenItem()
{
    inherited::OnHiddenItem();
    if (m_pHUD)    m_pHUD->Hide();
    SetState(eHidden);
    SetNextState(eHidden);
}

void CCustomDetector::UpdateCL()
{
    inherited::UpdateCL            ();
}

void CCustomDetector::shedule_Update        (u32 dt)
{
    inherited::shedule_Update        (dt);
}

#include "inventoryOwner.h"
#include "Entity_alive.h"

void CCustomDetector::UpdateXForm()
{
    if (Device.dwFrame!=dwXF_Frame)
    {
        dwXF_Frame            = Device.dwFrame;

        if (0==H_Parent())    return;

        // Get access to entity and its visual
        CEntityAlive*        E        = smart_cast<CEntityAlive*>(H_Parent());
        
        if(!E)                return;

        const CInventoryOwner    *parent = smart_cast<const CInventoryOwner*>(E);
        if (parent && parent->use_simplified_visual())
            return;

        VERIFY                (E);
        CKinematics*        V        = smart_cast<CKinematics*>    (E->Visual());
        VERIFY                (V);

        // Get matrices
        int                    boneL,boneR,boneR2;
        E->g_WeaponBones    (boneL,boneR,boneR2);

        boneL = boneR2;

        V->CalculateBones    ();
        Fmatrix& mL            = V->LL_GetTransform(u16(boneL));
        Fmatrix& mR            = V->LL_GetTransform(u16(boneR));

        // Calculate
        Fmatrix                mRes;
        Fvector                R,D,N;
        D.sub                (mL.c,mR.c);    D.normalize_safe();
        R.crossproduct        (mR.j,D);        R.normalize_safe();
        N.crossproduct        (D,R);            N.normalize_safe();
        mRes.set            (R,N,D,mR.c);
        mRes.mulA_43        (E->XFORM());
//        UpdatePosition        (mRes);
        XFORM().mul            (mRes,offset());
    }
}

void CCustomDetector::Hide()
{
    SwitchState(eHiding);
}

void CCustomDetector::Show()
{
    SwitchState(eShowing);
}

void CCustomDetector::OnStateSwitch(u32 S)
{
    inherited::OnStateSwitch    (S);
    switch(S){
    case eShowing:
        {
             m_pHUD->animPlay(random_anim(m_anim_show),        FALSE, this, S);
             Msg("Достаем детектор");
        }break;
    case eHiding:
        {
             m_pHUD->animPlay(random_anim(m_anim_hide),        FALSE, this, S);
             Msg("Прячем детектор");
        }break;
    case eIdle:
        {
        if (m_anim_idle.size())
             m_pHUD->animPlay(random_anim(m_anim_idle),        FALSE, NULL, eIdle);
             Msg("Держим в руке детектор");
        }break;
    };
}

void CCustomDetector::renderable_Render()
{
    inherited::renderable_Render();
}

void CCustomDetector::OnAnimationEnd(u32 state)
{
    inherited::OnAnimationEnd    (state);
    switch(state)
    {
    case eShowing:
        {
            SwitchState                    (eIdle);
        } break;
    }
}