SceneObject.c

Go to the documentation of this file.

class SceneObject
{
    static const int    COLOR_OBJ_BBOX_NORMAL   = 0x00000000;
    static const int    COLOR_OBJ_BBOX_SELECT   = 0x1f007C00;
    
    protected EntityAI                      m_ObjectPtr;
    protected Shape                             m_DebugShapeBBox;
    protected string                            m_InitScript;
    protected string                            m_ObjectName;
    protected string                            m_ObjectNameOrigin;
    
    protected ref array<SceneObject>        m_LinkedSceneObjects;
    protected ref map<SceneObject, Shape>   m_LinkedSceneObjectsShapes;
    
    ref array<int>                          m_LinkedSceneObjectsIndices;
    
    //========================================
    // SceneObject
    //========================================
    SceneObject Init(string obj_name, vector pos)
    {
        if (obj_name != STRING_EMPTY)
        {
            m_ObjectNameOrigin = obj_name;
            
            bool is_ai = GetGame().IsKindOf(obj_name, "DZ_LightAI");
            
            PluginDeveloper module_dev = PluginDeveloper.Cast(GetPlugin(PluginDeveloper));
            EntityAI e = module_dev.SpawnEntityOnGroundPos(PluginSceneManager.PLAYER, obj_name, 100, 0.0, pos);
            
            if (e != NULL)
            {
                if (e.IsInherited(ItemBase)) 
                {       
                    ItemBase item = ItemBase.Cast(e);
                    if (item.HasQuantity())
                        item.SetQuantity(item.GetQuantityMax());
                }
                
                m_ObjectName = e.GetType();
                LinkEntityAI(e);
            }
            else if (obj_name != "player")
            {
                return NULL;
            }
        }
        
        m_LinkedSceneObjects = new array<SceneObject>;
        m_LinkedSceneObjectsShapes = new map<SceneObject, Shape>;
        m_LinkedSceneObjectsIndices = new array<int>;
    
        return this;
    }
    
    //----------------------------------------
    // GetObject
    //----------------------------------------
    EntityAI GetObject()
    {
        return m_ObjectPtr;
    }
    
    //----------------------------------------
    // GetName
    //----------------------------------------
    string GetName()
    {
        return m_ObjectName;
    }
    
    //----------------------------------------
    // IsPlayer
    //----------------------------------------
    bool IsPlayer()
    {
        return false;
    }
    
    //----------------------------------------
    // GetInitScript
    //----------------------------------------
    string GetInitScript()
    {
        return m_InitScript;
    }
    
    //----------------------------------------
    // SetInitScript
    //----------------------------------------
    void SetInitScript(string init_script)
    {
        m_InitScript = init_script;
    }
    
    //========================================
    // EditorShapeUpdatePos
    //========================================
    void EditorShapeUpdatePos()
    {
        if (m_DebugShapeBBox != NULL)
        {       
            vector mat[4];
            GetObject().GetTransform(mat);
        
            if (m_DebugShapeBBox != NULL)
            {
                m_DebugShapeBBox.SetMatrix(mat);
            }
        }
    }
    
    //========================================
    // EditorShapeSetColor
    //========================================
    void EditorShapeSetColor(int color)
    {
        if (m_DebugShapeBBox)
        {
            m_DebugShapeBBox.SetColor(color);
        }
    }
    
    //========================================
    // EditorShapeSelect
    //========================================
    void EditorShapeSelect()
    {
        EditorShapeSetColor(COLOR_OBJ_BBOX_SELECT);
    }
    
    //========================================
    // EditorShapeDeselect
    //========================================
    void EditorShapeDeselect()
    {
        EditorShapeSetColor(COLOR_OBJ_BBOX_NORMAL);
    }
    
    //========================================
    // GetSize
    //========================================
    vector GetSize()
    {
        vector size = Vector(1,1,1);
        vector min_max[2];
        
        if (GetObject())
        {   
            GetObject().GetCollisionBox(min_max);
            
            size[0] = min_max[1][0] - min_max[0][0];
            size[2] = min_max[1][2] - min_max[0][2];
            size[1] = min_max[1][1] - min_max[0][1];
            
            return size;
        }
        else
        {
            Print("Error: SceneObject "+ m_ObjectNameOrigin +" dont has game object.");
        }
 
        return size;
    }
    
    //========================================
    // EditorShapeAdd
    //========================================
    void EditorShapeAdd()
    {   
        if (m_DebugShapeBBox != NULL)
            return;
        
        vector min      = "0 0 0";
        vector max      = "0 0 0";
    
        vector size = GetSize();
        
        float width     = size[0];
        float height    = size[1];
        float length    = size[2];      
        
        float width_h = width*0.5;
        float lenght_h = length*0.5;
        
        min[0] = -width_h;
        min[1] = 0;
        min[2] = -lenght_h;
        
        max[0] = width_h;
        max[1] = height;
        max[2] = lenght_h;
        
        //Log("EditorShapeAdd -> "+m_ObjectPtr.Ptr().GetType());
        
        m_DebugShapeBBox = Debug.DrawBox(min, max);
        EditorShapeUpdatePos();
        EditorShapeDeselect();
    }
    
    //========================================
    // EditorShapeRemove
    //========================================
    void EditorShapeRemove()
    {
        if (m_DebugShapeBBox != NULL)
        {
            m_DebugShapeBBox.Destroy();
            m_DebugShapeBBox = NULL;
        }
    }
    
    //========================================
    // EditorLineRemove
    //========================================
    void EditorLineRemove(SceneObject obj)
    {
        for (int i = 0; i < m_LinkedSceneObjectsShapes.Count(); i++)
        {
            if (m_LinkedSceneObjectsShapes.GetKey(i) == obj)
            {
                m_LinkedSceneObjectsShapes.GetElement(i).Destroy();
                m_LinkedSceneObjectsShapes.Remove(obj);
                break;
            }
        }
    }
    
    //========================================
    // EditorLineAdd
    //========================================
    void EditorLineAdd(SceneObject obj)
    {
        if (obj.GetObject() != NULL && GetObject() != NULL)
        {
            if (m_LinkedSceneObjectsShapes.Contains(obj))
            {
                EditorLineRemove(obj);
            }
            
            vector pos1 = obj.GetSize();
            pos1[0] = 0; pos1[1] = pos1[1] / 2; pos1[2] = 0;
            pos1 = pos1 + obj.GetObject().GetPosition();
            
            vector pos2 = GetSize();
            pos2[0] = 0; pos2[1] = pos2[1] / 2; pos2[2] = 0;
            pos2 = pos2 + GetObject().GetPosition();
            
            m_LinkedSceneObjectsShapes.Insert(obj, Debug.DrawArrow(pos1, pos2));
        }
    }
    
    //========================================
    // LinkEntityAI
    //========================================
    void LinkEntityAI(EntityAI e)
    {
        m_ObjectPtr = e;
    }
    
    //========================================
    // IsLinkedWithSceneObject
    //========================================
    bool IsLinkedWithSceneObject(SceneObject scene_object)
    {
        int index = m_LinkedSceneObjects.Find(scene_object);
        if (index >= 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    //========================================
    // LinkEntityAI
    //========================================
    void LinkSceneObject(SceneObject scene_object, bool draw_line = true)
    {
        if (!IsLinkedWithSceneObject(scene_object))
        {
            if (draw_line)
            {
                EditorLineAdd(scene_object);
            }
            m_LinkedSceneObjects.Insert(scene_object);
        }
    }
    
    //========================================
    // UnlinkSceneObject
    //========================================
    void UnlinkSceneObject(SceneObject scene_object)
    {
        int index = m_LinkedSceneObjects.Find(scene_object);
        if (index >= 0 && index < m_LinkedSceneObjects.Count())
        {
            EditorLineRemove(scene_object);
            m_LinkedSceneObjects.Remove(index);
        }
    }
    
    //========================================
    // UnlinkAll
    //========================================
    void UnlinkAll()
    {
        int link_count = GetLinkedSceneObjectsCount();
        
        if (link_count > 0)
        {
            for (int i = 0; i < link_count; ++i)
            {
                PluginSceneManager.GetInstance().UnlinkSceneObjects(this, GetLinkedSceneObject(0));
            }           
        }
    }
        
    //========================================
    // GetLinkedSceneObjects
    //========================================
    array<SceneObject> GetLinkedSceneObjects()
    {
        return m_LinkedSceneObjects;
    }
    
    //========================================
    // GetLinkedSceneObjectsCount
    //========================================
    int GetLinkedSceneObjectsCount()
    {
        return m_LinkedSceneObjects.Count();
    }
    
    //========================================
    // GetLinkedSceneObject
    //========================================
    SceneObject GetLinkedSceneObject(int i)
    {
        return m_LinkedSceneObjects.Get(i);
    }
    
    //========================================
    // GetLinkedObject
    //========================================
    EntityAI GetLinkedObject(int i)
    {
        return GetLinkedSceneObject(i).GetObject();
    }
    
    //========================================
    // Destructor
    //========================================
    void ~SceneObject()
    {
        if (m_ObjectPtr && m_ObjectPtr != GetGame().GetPlayer())
        {
            GetGame().ObjectDelete(m_ObjectPtr);
            m_ObjectPtr = NULL;
        }
        
        for (int i = 0; i < m_LinkedSceneObjects.Count(); i++)
        {
            EditorLineRemove(m_LinkedSceneObjects.Get(i));
        }
        
        EditorShapeRemove();
    }
    
    //========================================
    // GetTypeName
    //========================================
    string GetTypeName()
    {
        return m_ObjectPtr.GetType();
    }
    
    //========================================
    // PlaceOnSurface
    //========================================
    void PlaceOnSurface()
    {
        if (m_ObjectPtr)
        {
            if (GetGame().IsClient() && GetGame().IsMultiplayer())
            {
                Param par = new Param3<string, EntityAI, Param>("PlaceOnSurface" , m_ObjectPtr, NULL);
                SceneObjectSynch(par);          
            }
            else
            {
                m_ObjectPtr.PlaceOnSurface();
            }
        }
    }
    
    //========================================
    // SetPosition
    //========================================
    void SetPosition(vector pos)
    {
        if (m_ObjectPtr) 
        {
            if (GetGame().IsClient() && GetGame().IsMultiplayer())
            {
                Param par = new Param3<string, EntityAI, Param>("SetPosition" , m_ObjectPtr, new Param1<vector>(pos));
                SceneObjectSynch(par);          
            }
            else
            {
                m_ObjectPtr.SetPosition(pos);
            }
        }
        PlaceOnSurface();
        EditorShapeUpdatePos();
    }
    
    //========================================
    // GetPosition
    //========================================
    vector GetPosition()
    {
        if (m_ObjectPtr)
            return m_ObjectPtr.GetPosition();
        return Vector(0,0,0);
    }
    
    //========================================
    // GetHealth
    //========================================
    float GetHealth()
    {
        if (m_ObjectPtr)
            return m_ObjectPtr.GetHealth("", "");
        return 0;
    }
    
    //========================================
    // GetHealth
    //========================================
    float GetMaxHealth()
    {
        if (m_ObjectPtr)
            return m_ObjectPtr.GetMaxHealth("", "");
        return 0;
    }
    
    //========================================
    // SetHealth
    //========================================
    void SetHealth(float value)
    {
        if (m_ObjectPtr)
        {
            if (GetGame().IsClient() && GetGame().IsMultiplayer())
            {
                Param par = new Param3<string, EntityAI, Param>("SetHealth" , m_ObjectPtr, new Param1<float>(value));
                SceneObjectSynch(par);          
            }
            else
            {
                m_ObjectPtr.SetHealth("", "", value);
            }
        }
    }
        
    //========================================
    // GetPositionAsString
    //========================================
    string GetPositionAsString()
    {
        if (m_ObjectPtr)
            return m_ObjectPtr.GetPosition().ToString(false);
        return Vector(0,0,0).ToString(false);
    }
    
    //========================================
    // SetPositionAsString
    //========================================
    void SetPositionAsString(string string_pos)
    {
        SetPosition(string_pos.ToVector());
    }
    
    //========================================
    // GetRotation
    //========================================
    float GetRotation()
    {
        if (m_ObjectPtr)
        {
            vector v = m_ObjectPtr.GetOrientation();
            return v[0];
        }
 
        return 0;
    }
    
    //========================================
    // SetRotation
    //========================================
    void SetRotation(float rot)
    {
        if (m_ObjectPtr)
        {
            vector v = m_ObjectPtr.GetOrientation();
            v[0] = rot;
            m_ObjectPtr.SetOrientation(v);
            EditorShapeUpdatePos();
        }
    }
    
    void SceneObjectSynch(Param p)
    {
        GetGame().RPCSingleParam(GetGame().GetPlayer(), ERPCs.RPC_SYNC_SCENE_OBJECT, p, true, NULL);
    }
    
    //========================================
    // AddRotation
    //========================================
    void AddRotation(float add_rot)
    {
        if (m_ObjectPtr)
        {
            if (GetGame().IsClient() && GetGame().IsMultiplayer())
            {
                Param par = new Param3<string, EntityAI, Param>("AddRotation" , m_ObjectPtr, new Param1<float>(add_rot));
                SceneObjectSynch(par);          
            }
            else
            {
                vector v = m_ObjectPtr.GetOrientation();
                v[0] = v[0] + add_rot;
                m_ObjectPtr.SetOrientation(v);
            
                EditorShapeUpdatePos();
            }
        }       
    }
    
    //========================================
    // AddRotation
    //========================================
    void AddAttachment(string att_name)
    {
        GetObject().GetInventory().CreateAttachment(att_name);
    }
    
    //========================================
    // CanAttachment
    //========================================
    bool CanAttachment(EntityAI e)
    {
        return GetObject().GetInventory().CanAddAttachment(e);
    }
    
    //========================================
    // AddRotation
    //========================================
    void RemoveAttachment(EntityAI e)
    {
        GetGame().ObjectDelete(e);
    }
    
    //========================================
    // GetAttachments
    //========================================
    array<EntityAI> GetAttachments()
    {
        array<EntityAI> ret = new array<EntityAI>;
        
        for (int i = 0; i < GetObject().GetInventory().AttachmentCount(); ++i)
        {
            ret.Insert(GetObject().GetInventory().GetAttachmentFromIndex(i));
        }
        
        return ret;
    }
    
    //========================================
    // GetConfigAttachments
    //========================================
    TStringArray GetConfigAttachments()
    {
        string          type_name = GetTypeName();
        TStringArray    cfg_attachments = new TStringArray;
        
        string cfg_path;
        
        if (GetGame().ConfigIsExisting(CFG_VEHICLESPATH+" "+type_name))
        {
            cfg_path = CFG_VEHICLESPATH+" "+type_name+" attachments";
        }
        else if (GetGame().ConfigIsExisting(CFG_WEAPONSPATH+" "+type_name))
        {
            cfg_path = CFG_WEAPONSPATH+" "+type_name+" attachments";
        }
        else if (GetGame().ConfigIsExisting(CFG_MAGAZINESPATH+" "+type_name))
        {
            cfg_path = CFG_MAGAZINESPATH+" "+type_name+" attachments";
        }
        
        GetGame().ConfigGetTextArray(cfg_path, cfg_attachments);
        
        return cfg_attachments;
    }
}