cs_register(object_factory, "CNewObjectTest",  "se_item.se_newobj", ("E_NEWOBJ"), "new_obj_s")

class "se_newobj" (cse_alife_item_custom_newobj)
function se_newobj:__init(section) super(section)
end
..... далее все как у других классов

function init(obj)
    local new_binder = newobj_binder(obj)
    obj:bind_object(new_binder)
end

class "newobj_binder" (object_binder)
function newobj_binder:__init(obj) super(obj)
     ......
end
..... далее все как у других классов

[newobj_base]
GroupControlSection    = spawn_group
discovery_dependency    =
class            = E_NEWOBJ
cform            = skeleton
full_icon_name        = npc_icon_newobj
slot            = 11
script_binding        = bind_newobj.init

additional_inventory_weight    = 0
additional_inventory_weight2 = 0

;----------------------------
[newobj_test1]:newobj_base
.... далее все как обычно

# include "NewObjectTest.h"
....
ADD(CNewObjectTest, CSE_ALifeItemNewObjectTest, CLSID_E_NEWOBJ, "new_obj");
....
ADD(CNewObjectTest, CSE_ALifeItemNewObjectTest, TEXT2CLSID("E_NEWOBJ"), "new_obj_s");

#define CLSID_E_NEWOBJ MK_CLSID('E','Q','_','N','E','W','O','B')

SERVER_ENTITY_DECLARE_BEGIN( CSE_ALifeItemNewObjectTest, CSE_ALifeItem)
    u32        m_ef_equipment_type;
             CSE_ALifeItemNewObjectTest(LPCSTR caSection);
    virtual        ~ CSE_ALifeItemNewObjectTest();
    virtual u32    ef_equipment_type() const;
    virtual BOOL    Net_Relevant();
SERVER_ENTITY_DECLARE_END
add_to_type_list( CSE_ALifeItemNewObjectTest)
#define script_type_list save_type_list( CSE_ALifeItemNewObjectTest)

CSE_ALifeItemNewObjectTest::CSE_ALifeItemNewObjectTest(LPCSTR caSection) : CSE_ALifeItem(caSection)
{
    m_ef_equipment_type = pSettings->r_u32(caSection, "ef_equipment_type");
}
CSE_ALifeItemNewObjectTest::~CSE_ALifeItemNewObjectTest()
{
}
.... далее все как у других классов

void CSE_ALifeItemNewObjectTest::script_register(lua_State *L)
{
    module(L)[
        luabind_class_item1(
            CSE_ALifeItemNewObjectTest,
            "cse_alife_item_custom_newobj",
            CSE_ALifeItem
            )
    ];
}

#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;
    }
}