public InteractorObject GetInteractor(GameObject _object)
        {
            if (_object == null)
            {
                return(null);
            }

            InteractorObject _interactor_obj = null;

            foreach (InteractorObject _interactor in Interactors)
            {
                if (_interactor.TargetGameObject == null)
                {
                    continue;
                }
                else if ((_interactor.AccessType == TargetAccessType.NAME && _interactor.TargetName == _object.name) ||
                         (_interactor.AccessType == TargetAccessType.TAG && _interactor.TargetTag == _object.tag) ||
                         (_interactor.AccessType == TargetAccessType.OBJECT && _interactor.TargetGameObject.GetInstanceID() == _object.GetInstanceID()))
                {
                    _interactor_obj = _interactor;
                    break;
                }
            }

            return(_interactor_obj);
        }
        public void Sense()
        {
            InteractorObject _best_interactor = null;
            GameObject       _best_creature   = null;
            int _best_priority = 0;

            float _best_distance = Mathf.Infinity;

            for (int i = 0; i < Interactors.Count; ++i)
            {
                InteractorObject _interactor = Interactors[i];

                if (!_interactor.Enabled)
                {
                    continue;
                }

                GameObject _creature = CreatureRegister.FindNearestCreature(_interactor.Name, m_Owner.transform.position, _interactor.GetStartDistance());

                if (_creature != null)
                {
                    float _creature_distance = Tools.GetHorizontalDistance(m_Owner.transform.position, _creature.transform.position);

                    if (_creature_distance <= _best_distance)
                    {
                        int _priority = GetPriority(_creature, _interactor.Selectors.Priority);

                        if (_priority >= _best_priority)
                        {
                            _best_priority   = _priority;
                            _best_creature   = _creature;
                            _best_distance   = _creature_distance;
                            _best_interactor = _interactor;
                        }
                    }
                }
            }


            if (_best_creature != null && _best_interactor != null)
            {
                if (m_Interactor == null || m_Interactor.Target.TargetGameObject != _best_creature)
                {
                    m_Interactor = _best_interactor;

                    m_Interactor.Target = new TargetObject(TargetType.INTERACTOR);
                    m_Interactor.Target.TargetGameObject = _best_creature;


                    PrepareTarget();
                }
            }
            else
            {
                m_Interactor = null;
            }
        }
                // INTERACTIONS END

                // INTERACTOR BEGIN
                public static void SaveInteractorToFile(InteractorObject _interactor, string owner)
                {
                    path = UnityEditor.EditorUtility.SaveFilePanelInProject("Save Interactor As", owner.ToLower() + ".cc_interactor", "cc_interactor", "");

                    if (path.Length == 0)
                    {
                        return;
                    }

                    XmlSerializer serializer = new XmlSerializer(typeof(InteractorObject));
                    FileStream    stream     = new FileStream(path, FileMode.Create);

                    serializer.Serialize(stream, _interactor);
                    stream.Close();
                }
                public static InteractorObject LoadInteractorFromFile(InteractorObject _interactor)
                {
                    path = UnityEditor.EditorUtility.OpenFilePanel("Open Interactor File", Application.dataPath, "cc_interactor");

                    if (path.Length == 0)
                    {
                        return(_interactor);
                    }

                    XmlSerializer serializer = new XmlSerializer(typeof(InteractorObject));
                    FileStream    stream     = new FileStream(path, FileMode.Open);

                    _interactor = serializer.Deserialize(stream) as InteractorObject;
                    stream.Close();

                    return(_interactor);
                }
        public InteractorObject AddInteractor(GameObject _object, StatusObject _status)
        {
            if (_object == null || _status == null)
            {
                return(null);
            }

            InteractorObject _interactor = GetInteractor(_object);

            if (_interactor == null)
            {
                _interactor = new InteractorObject();
                if (_interactor.AutoCreate(_object, _status))
                {
                    Interactors.Add(_interactor);
                }
            }

            return(_interactor);
        }
        public void Copy(InteractorObject _object)
        {
            if (_object == null)
            {
                return;
            }

            base.Copy(_object);

            Enabled                = _object.Enabled;
            InteractorFoldout      = _object.InteractorFoldout;
            ShowInteractorInfoText = _object.ShowInteractorInfoText;
            InteractorInfoText     = _object.InteractorInfoText;

            Rules.Clear();
            foreach (InteractorRuleObject _rule in _object.Rules)
            {
                Rules.Add(new InteractorRuleObject(_rule));
            }
        }
 public InteractorObject(InteractorObject _interactor) : base(_interactor)
 {
     Copy(_interactor);
 }
 public void Reset()
 {
     m_Interactors.Clear();
     m_Interactor = null;
 }
Exemple #9
0
        /// <summary>
        /// Draws the interaction.
        /// </summary>
        public void DrawInteraction()
        {
            if (CreatureControl.Creature.Interaction.Interactors.Count == 0 || ShowInteractor == false)
            {
                return;
            }

            for (int i = 0; i < CreatureControl.Creature.Interaction.Interactors.Count; i++)
            {
                InteractorObject _interactor = CreatureControl.Creature.Interaction.Interactors[i];

                if (!_interactor.Enabled)
                {
                    continue;
                }

                List <GameObject> _target_game_objects = GetCreaturesByName(_interactor.Name);

                if (_target_game_objects != null && _target_game_objects.Count > 0)
                {
                    foreach (GameObject _target_game_object in _target_game_objects)
                    {
                        Vector3 _interactor_pos = _target_game_object.transform.position;

                        TargetObject _target = new TargetObject(TargetType.INTERACTOR);

                        _target.TargetGameObject = _target_game_object;
                        _target.BehaviourModeKey = _interactor.BehaviourModeKey;
                        _target.Selectors.Copy(_interactor.Selectors);
                        _target.UpdateOffset(_interactor.DefaultOffset);
                        _target.TargetStopDistance          = _interactor.DefaultStopDistance;
                        _target.TargetRandomRange           = _interactor.DefaultRandomRange;
                        _target.TargetSmoothingMultiplier   = 0;                      //_interactor.DefaultSmoothingMultiplier; // TODO:REWORK TargetSmoothingMultiplier
                        _target.TargetIgnoreLevelDifference = _interactor.DefaultIgnoreLevelDifference;

                        DrawTargetGizmos(_target);

                        // DIRECTION
                        CustomGizmos.Arrow(_target.TargetPosition, _target.TargetDirection * _target.TargetStopDistance, 0.5f, 20);

                        Vector3 _last_move_position = _target.TargetMovePosition;
                        float   _last_stop_distance = _target.TargetStopDistance;

                        _last_move_position.y = GetLevel();

                        Color _default_color = Gizmos.color;
                        Color _target_color  = (_target.Active?ActiveTargetColor:TargetColor);

                        foreach (InteractorRuleObject _rule in _interactor.Rules)
                        {
                            if (!_rule.Enabled)
                            {
                                continue;
                            }

                            _target = new TargetObject(TargetType.INTERACTOR);

                            _target.TargetGameObject = _target_game_object;
                            _target.BehaviourModeKey = _rule.BehaviourModeKey;
                            _target.Selectors.Copy(_rule.Selectors);

                            _target.UpdateOffset(_interactor.DefaultOffset);
                            _target.TargetStopDistance          = _interactor.DefaultStopDistance;
                            _target.TargetRandomRange           = _interactor.DefaultRandomRange;
                            _target.TargetSmoothingMultiplier   = 0;                          //_interactor.DefaultSmoothingMultiplier; // TODO:REWORK TargetSmoothingMultiplier
                            _target.TargetIgnoreLevelDifference = _interactor.DefaultIgnoreLevelDifference;

                            if (_rule.OverrideTargetMovePosition)
                            {
                                _target.UpdateOffset(_rule.Offset);
                                _target.TargetStopDistance          = _rule.StopDistance;
                                _target.TargetRandomRange           = _rule.RandomRange;
                                _target.TargetSmoothingMultiplier   = 0;
                                _target.TargetIgnoreLevelDifference = _rule.IgnoreLevelDifference;
                            }

                            DrawTargetGizmos(_target);

                            Vector3 _move_position = _target.TargetMovePosition;
                            _move_position.y = GetLevel();

                            Gizmos.color = _target_color;
                            if (_last_move_position != Vector3.zero)
                            {
                                CustomGizmos.OffsetPath(_last_move_position, _last_stop_distance, _move_position, _target.TargetStopDistance, true);
                            }

                            _last_stop_distance = _target.TargetStopDistance;
                            _last_move_position = _move_position;
                        }

                        Gizmos.color = _target_color;
                        if (_last_move_position != Vector3.zero)
                        {
                            CustomGizmos.OffsetPath(_last_move_position, _last_stop_distance, _interactor_pos, 0, false);
                        }

                        Gizmos.color = _default_color;
                        //CustomGizmos.OffsetPath( _default_data.OffsetPosition, _default_data.StopDistance, _interactor_pos, 0 );
                    }
                }
            }
        }