SCR_EditableWaypointComponent.c

Go to the documentation of this file.

[ComponentEditorProps(category: "GameScripted/Editor (Editables)", description: "", icon: "WBData/ComponentEditorProps/componentEditor.png")]
class SCR_EditableWaypointComponentClass : SCR_EditableEntityComponentClass
{
}


class SCR_EditableWaypointComponent : SCR_EditableEntityComponent
{
    [RplProp(onRplName: "OnPreWaypointIdRpl")]
    protected RplId m_PrevWaypointId;
 
    [RplProp()]
    protected bool m_bIsCurrent;
 
    [RplProp()]
    protected int m_iIndex;
 
    protected SCR_EditableEntityComponent m_Group;
    protected SCR_EditableEntityComponent m_PrevWaypoint;
 
    protected SCR_AIWaypoint m_AIWaypoint;
    protected SCR_EditableEntityComponent m_AttachedTo;
 
    [RplProp(onRplName: "OnAttachedToId")]
    protected RplId m_AttachedToId;
 
    //------------------------------------------------------------------------------------------------
    override SCR_EditableEntityComponent GetAttachedTo()
    {
        return m_AttachedTo;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void AttachTo(SCR_EditableEntityComponent attachedTo)
    {
        m_AttachedTo = attachedTo;
 
        //++ Remove from the existing parent first
        if (GetOwner().GetParent())
            m_AIWaypoint.GetParent().RemoveChild(m_AIWaypoint, true);
 
        //++ Add to the new parent (when defined)
        if (m_AttachedTo)
        {
            //++ Do not allow to attach if target exceeds attached entities number
            if (m_AttachedTo.GetAttachedEntities().Count() >= EditorConstants.MAX_ATTACHED_ENTITIES)
            {
                SCR_NotificationsComponent.SendLocal(ENotification.EDITOR_PLACING_BLOCKED, SCR_PlayerController.GetLocalPlayerId());
                return;
            }
            
            m_AIWaypoint.SetOrigin(vector.Zero);
            m_AttachedTo.GetOwner().AddChild(m_AIWaypoint, -1);
 
            SCR_EntityWaypoint entityWaypoint = SCR_EntityWaypoint.Cast(m_AIWaypoint);
            if (entityWaypoint)
                entityWaypoint.SetEntity(m_AttachedTo.GetOwner());
 
            m_AttachedTo.Attach(this);
        }
        else
        {
            SCR_EntityWaypoint entityWaypoint = SCR_EntityWaypoint.Cast(m_AIWaypoint);
            if (entityWaypoint)
                entityWaypoint.SetEntity(null);
            if (m_AttachedTo)
                m_AttachedTo.Detach(this);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnAttachedToId()
    {
        SCR_EditableEntityComponent attachedTo = SCR_EditableEntityComponent.Cast(Replication.FindItem(m_AttachedToId));
        AttachTo(attachedTo);
    }
 
    //------------------------------------------------------------------------------------------------
    void SetWaypointIndex(int index, bool isCurrent, SCR_EditableEntityComponent prevWaypoint)
    {
        m_iIndex = index;
        m_bIsCurrent = isCurrent;
        m_PrevWaypoint = prevWaypoint;
        m_PrevWaypointId = Replication.FindItemId(prevWaypoint);
        Replication.BumpMe();
    }
 
    //------------------------------------------------------------------------------------------------
    int GetWaypointIndex()
    {
        return m_iIndex;
    }
 
    //------------------------------------------------------------------------------------------------
    bool IsCurrent()
    {
        return m_bIsCurrent;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_EditableEntityComponent GetPrevWaypoint()
    {
        if (m_PrevWaypoint)
            return m_PrevWaypoint;
        else
            return m_Group;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnPreWaypointIdRpl()
    {
        m_PrevWaypoint = SCR_EditableEntityComponent.Cast(Replication.FindItem(m_PrevWaypointId));
    }
 
    //------------------------------------------------------------------------------------------------
    override bool CanDuplicate(out notnull set<SCR_EditableEntityComponent> outRecipients)
    {
        SCR_EditableEntityComponent groupComponent = GetAIGroup();
        if (groupComponent)
            outRecipients.Insert(groupComponent);
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override Faction GetFaction()
    {
        if (!m_Group)
            return null;
 
        Faction faction = m_Group.GetFaction();
        return faction;
    }
 
    //------------------------------------------------------------------------------------------------
    override SCR_EditableEntityComponent GetAIGroup()
    {
        return m_Group;
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnParentEntityChanged(SCR_EditableEntityComponent parentEntity, SCR_EditableEntityComponent parentEntityPrev, bool changedByUser)
    {
        if (!parentEntity)
            return;
        
        
        if (m_AIWaypoint && m_Group && m_Group != parentEntity)
        {
            AttachTo(parentEntity);
 
            m_AttachedToId = Replication.FindItemId(parentEntity);
            Replication.BumpMe();
            
            super.OnParentEntityChanged(parentEntityPrev, parentEntityPrev, changedByUser); // Needed to register
            return;
        }
 
        EEditableEntityType parentType = parentEntity.GetEntityType();
        switch (parentType)
        {
            case EEditableEntityType.CHARACTER:
            case EEditableEntityType.GROUP:
            {
                SCR_EditableEntityComponent group = parentEntity.GetAIGroup();
                if (!group)
                    break;
 
                m_Group = group;
                super.OnParentEntityChanged(group, parentEntityPrev, changedByUser);
                break;
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override bool SetTransform(vector transform[4], bool changedByUser = false)
    {
        DetachFromTarget();
        return super.SetTransform(transform, changedByUser);
    }
 
    //------------------------------------------------------------------------------------------------
    override void SetTransformBroadcast(vector transform[4])
    {
        DetachFromTarget();
        super.SetTransformBroadcast(transform);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void DetachFromTarget()
    {
        if (m_AIWaypoint)
            AttachTo(null);
    }
 
    //------------------------------------------------------------------------------------------------
    override bool GetPos(out vector pos)
    {
        if (m_Group)
            return super.GetPos(pos);
        else
            return false;
    }
 
    //------------------------------------------------------------------------------------------------
    override bool CanSetParent(SCR_EditableEntityComponent parentEntity)
    {
        //--- When the group was not assigned yet and the target is a GROUP or a CHARACTER, always allow them to be a parent
        if (!m_Group)
        {
            switch (parentEntity.GetEntityType())
            {
                case EEditableEntityType.GROUP:
                case EEditableEntityType.CHARACTER:
                {
                    return true;
                }
            }
        }
 
        return super.CanSetParent(parentEntity);
    }
 
    //------------------------------------------------------------------------------------------------
    override SCR_EditableEntityComponent EOnEditorPlace(out SCR_EditableEntityComponent parent, SCR_EditableEntityComponent recipient, EEditorPlacingFlags flags, bool isQueue, int playerID = 0)
    {
        if (recipient)
        {
            AIGroup group = AIGroup.Cast(recipient.GetOwner());
            if (group)
            {
                if (!isQueue)
                {
                    SCR_EditableGroupComponent editableGroup = SCR_EditableGroupComponent.Cast(recipient);
                    if (editableGroup && !editableGroup.AreCycledWaypointsEnabled())
                        editableGroup.ClearWaypoints();
                }
 
                group.AddWaypoint(AIWaypoint.Cast(GetOwner()));
            }
        }
        return this;
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnDelete(IEntity owner)
    {
        super.OnDelete(owner);
 
        //--- Manually remove the waypoint entity from group's list of waypoints - it doesn't happen automatically
        if (m_Group && IsServer())
        {
            AIGroup aiGroup = AIGroup.Cast(m_Group.GetOwner());
            if (aiGroup)
                aiGroup.RemoveWaypoint(AIWaypoint.Cast(owner));
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override bool IsAttachable()
    {
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override bool IsAttached()
    {
        if (GetAttachedTo())
            return true;
 
        return false;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_AIWaypoint GetAIWaypoint()
    {
        return m_AIWaypoint;
    }
 
    //------------------------------------------------------------------------------------------------
    void SCR_EditableWaypointComponent(IEntityComponentSource src, IEntity ent, IEntity parent)
    {
        m_AIWaypoint = SCR_AIWaypoint.Cast(ent);
    }
 
}