public bool ComparePrecursorTarget(TargetObject _precursor) { if (_precursor == null || _precursor.TargetGameObject == null) { return(false); } bool _result = false; // using EQUAL to get true if one of the conditions are correct if (PrecursorType == TargetPrecursorType.TYPE && PrecursorTargetType == _precursor.Type) { _result = true; } else if (PrecursorType == TargetPrecursorType.NAME && PrecursorTargetName == _precursor.TargetGameObject.name) { _result = true; } else if (PrecursorType == TargetPrecursorType.TAG && _precursor.TargetGameObject.CompareTag(PrecursorTargetTag)) { _result = true; } // if the desired operator is NOT we have to invert the result of the EQUAL check if (Operator == LogicalOperatorType.NOT) { _result = !_result; } return(_result); }
private void DrawTargetGizmos(TargetObject _target) { Color _target_color = (_target.Active?ActiveTargetColor:TargetColor); Color _selection_color = (_target.Active?ActiveTargetColor:InteractionColor); DrawTargetGizmos(_target, _target_color, _selection_color); }
public TargetObject FindTargetByName(string _name) { if (_name == "") { return(null); } TargetObject _target = null; if (_target == null && Essentials.TargetReady() && Essentials.Target.TargetGameObject.name == _name) { _target = Essentials.Target; } if (_target == null && Missions.Outpost.Enabled && Missions.Outpost.TargetReady() && Missions.Outpost.Target.TargetGameObject.name == _name) { _target = Missions.Outpost.Target; } if (_target == null && Missions.Escort.Enabled && Missions.Escort.TargetReady() && Missions.Escort.Target.TargetGameObject.name == _name) { _target = Missions.Escort.Target; } if (_target == null && Missions.Patrol.Enabled) { _target = Missions.Patrol.Waypoints.GetWaypointByName(_name); } /*if( _target == null ) * _target = Interaction.GetInteractorByName( _name );*/ return(_target); }
/// <summary> /// Draws the escort. /// </summary> public void DrawEscort() { if (!CreatureControl.Creature.Missions.Escort.TargetReady() || ShowEscort == false) { return; } TargetObject _target = CreatureControl.Creature.Missions.Escort.Target; DrawTargetGizmos(_target); if (!Application.isPlaying) { BehaviourModeObject _mode = null; _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Missions.Escort.BehaviourModeFollow); DrawBehaviourModeGizmos(_target, _mode); _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Missions.Escort.BehaviourModeEscort); DrawBehaviourModeGizmos(_target, _mode); _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Missions.Escort.BehaviourModeIdle); DrawBehaviourModeGizmos(_target, _mode); _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Missions.Escort.BehaviourModeStandby); DrawBehaviourModeGizmos(_target, _mode); } }
public void AddAvailableTarget(TargetObject _target) { if (_target == null || !_target.IsValidAndReady) { return; } _target.Selectors.ResetStatus(); AvailableTargets.Add(_target); }
private bool IsTargetUpdatePermitted(TargetObject _target) { if (_target == null) { return(false); } if (m_ActiveTarget == null || Behaviour.BehaviourMode == null || Behaviour.BehaviourMode.Favoured.Enabled == false) { return(true); } bool _permitted = true; if ((Behaviour.BehaviourMode.Favoured.Enabled == true) && ( (Behaviour.BehaviourMode.Favoured.FavouredMinimumPeriod > 0 && Behaviour.BehaviourTimer < Behaviour.BehaviourMode.Favoured.FavouredMinimumPeriod) || (Behaviour.BehaviourMode.Favoured.FavouredUntilNextMovePositionReached && !Move.MovePositionReached()) || (Behaviour.BehaviourMode.Favoured.FavouredUntilTargetMovePositionReached && !m_ActiveTarget.TargetMoveComplete) || (Behaviour.BehaviourMode.Favoured.FavouredUntilNewTargetInRange(_target, Vector3.Distance(_target.TargetGameObject.transform.position, m_Owner.transform.position))) || (Behaviour.BehaviourMode.HasActiveDetourRule && Behaviour.BehaviourMode.Favoured.FavouredUntilDetourPositionReached && !Move.DetourComplete))) { _permitted = false; } else { _permitted = true; } //mode check - the new mode could be also forced, so we have to check this here if (_permitted == false) { BehaviourModeObject _mode = Behaviour.GetBehaviourModeByKey(_target.BehaviourModeKey); if (_mode != null && _mode.Favoured.Enabled == true) { if (Behaviour.BehaviourMode.Favoured.FavouredPriority > _mode.Favoured.FavouredPriority) { _permitted = false; } else if (Behaviour.BehaviourMode.Favoured.FavouredPriority < _mode.Favoured.FavouredPriority) { _permitted = true; } else { _permitted = (Random.Range(0, 1) == 0?false:true); } } } return(_permitted); }
private Vector3 DrawBehaviourModeGizmos(TargetObject _target, BehaviourModeObject _mode) { if (_target == null || _target.IsValid == false || _mode == null) { return(Vector3.zero); } foreach (BehaviourModeRuleObject _rule in _mode.Rules) { DrawBehaviourModeRuleGizmos(_target, _rule); } return(Vector3.zero); }
public SpawnPointObject(TargetObject _target) { Enabled = true; Foldout = true; AccessType = _target.AccessType; SpawnPointGameObject = _target.TargetGameObject; if (_target.Move.HasRandomRange) { SpawningRangeMin = _target.Move.StoppingDistance; SpawningRangeMax = _target.Move.RandomRange; SpawningRangeMaximum = _target.Move.RandomRangeMaximum; } }
public bool FavouredUntilNewTargetInRange(TargetObject _target, float _distance) { if (_target == null || _target.TargetGameObject == null || FavouredTarget == false || FavouredTargetRange <= 0) { return(false); } if (_distance <= FavouredTargetRange && (string.IsNullOrEmpty(FavouredTargetName) || _target.TargetGameObject.name == FavouredTargetName)) { return(false); } else { return(true); } }
public float CompareSuccessorTargets(TargetObject _target, Vector3 _position) { /* * if( _target == null || _target.TargetGameObject == null || UseAdvanced == false ) * return 0; * * float _relevance_multiplier = 0; * * foreach( TargetSelectorObject _group in m_SelectorGroups ) * { * foreach( TargetSelectorConditionObject _selector in _group.Conditions ) * { * if( _selector.Enabled == true && _selector.ExpressionType == TargetSelectorExpressionType.SUCCESSOR ) * { * bool _valid = false; * * if( ( _selector.SuccessorType == TargetSuccessorType.NAME && _target.TargetGameObject.name == _selector.SuccessorTargetName ) || * ( _selector.SuccessorType == TargetSuccessorType.TAG && _target.TargetGameObject.CompareTag( _selector.SuccessorTargetName ) ) || * ( _selector.SuccessorType == TargetSuccessorType.TYPE && _target.Type == _selector.SuccessorTargetType ) ) * { * if( _selector.UseRange ) * _valid = _target.TargetInSelectionRange( _position, _selector.Distance ); * else * _valid = true; * } * * if( _valid == _selector.Included ) * _valid = true; * else * _valid = false; * * if( _valid ) * { * if( _selector.UseMultiplier ) * _relevance_multiplier += _selector.RelevanceMultiplier; * else * _relevance_multiplier += 1; * } * } * } * } * _target.Selectors.UpdateRelevance( _relevance_multiplier ); * * return _relevance_multiplier;*/ return(0); }
public bool PrepareRuleTarget(ICEWorldBehaviour _component, TargetObject _target) { if (!Enabled || !OwnerIsReady(_component)) { return(false); } // By default an additional interactor rule have the same TargetGameObject as the initial rule but while // Selectors.Preselection.Enabled is true the rule will select its own best target of the same type according // to the specifier pre-selection criteria if (Selectors.Preselection.Enabled) { if (PrepareTargetGameObject(_component) == null || !IsValidAndReady) { return(false); } } else { if (_target == null || _target.IsValidAndReady == false) { return(false); } OverrideTargetGameObject(_target.TargetGameObject); } if (OverrideInfluences == false) { Influences.Copy(_target.Influences); } //if( Selectors.UseDefaultPriority ) // Selectors.Priority = _target.Selectors.Priority; if (OverrideTargetMovePosition == false) { Move.Copy(_target.Move); } Behaviour.CurrentBehaviourModeKey = GetBestBehaviourModeKey(Owner); return(true); }
public void ResetActiveTarget() { // handle previous target m_PreviousTarget = m_ActiveTarget; m_PreviousTargetGameObject = m_ActiveTargetGameObject; m_PreviousTargetID = m_ActiveTargetID; m_PreviousTargetName = m_ActiveTargetName; m_PreviousTargetKey = m_ActiveTargetName + m_ActiveTargetID.ToString(); if (m_PreviousTarget != null) { m_PreviousTarget.SetActive(false); if (m_PreviousTarget.EntityComponent != null) { m_PreviousTarget.EntityComponent.RemoveActiveCounterpart(OwnerComponent as ICECreatureEntity); } if (m_PreviousTarget.GroupMessage.Type != BroadcastMessageType.NONE) { BroadcastMessageDataObject _data = new BroadcastMessageDataObject(); _data.Type = m_PreviousTarget.GroupMessage.Type; _data.TargetGameObject = m_PreviousTargetGameObject; _data.Command = ""; ICECreatureEntity _entity = OwnerComponent as ICECreatureEntity; if (_entity != null) { _entity.Message.SendGroupMessage(_data); } } } m_ActiveTarget = null; m_ActiveTargetGameObject = null; m_ActiveTargetID = 0; m_ActiveTargetName = ""; m_ActiveTargetKey = ""; }
public void Copy(TargetObject _target) { if (_target == null) { return; } BehaviourModeKey = _target.BehaviourModeKey; TargetIgnoreLevelDifference = _target.TargetIgnoreLevelDifference; IsPrefab = _target.IsPrefab; TargetOffset = _target.TargetOffset; TargetSmoothingMultiplier = _target.TargetSmoothingMultiplier; TargetGameObject = _target.TargetGameObject; TargetRandomRange = _target.TargetRandomRange; TargetStopDistance = _target.TargetStopDistance; UseUpdateOffsetOnActivateTarget = _target.UseUpdateOffsetOnActivateTarget; UseUpdateOffsetOnMovePositionReached = _target.UseUpdateOffsetOnMovePositionReached; Selectors.Copy(_target.Selectors); }
public void DrawMoveGizmos() { #if UNITY_EDITOR if (m_Owner == null || m_creature_control.Creature.Move.CurrentTarget == null) { return; } TargetObject _target = m_creature_control.Creature.Move.CurrentTarget; Vector3 _move_position = m_creature_control.Creature.Move.MovePosition; Vector3 _target_move_position = _target.TargetMovePosition; float _move_stop_distance = m_creature_control.Creature.Move.CurrentMove.MoveStopDistance; float _move_lateral_variance = m_creature_control.Creature.Move.CurrentMove.MoveLateralVariance; Vector3 _owner_pos = m_Owner.transform.position; _owner_pos.y = GetLevel(); _move_position.y = GetLevel(); _target_move_position.y = GetLevel(); CustomGizmos.OffsetPath(_owner_pos, 2, _move_position, _move_stop_distance); // PATH FROM CREATURE TO NEXT MOVE POSITION CustomGizmos.Circle(_move_position, _move_stop_distance, 5, false); // STOP DISTANCE RANGE if (m_creature_control.Creature.Move.CurrentMove.Type != MoveType.ESCAPE) { CustomGizmos.OffsetPath(_move_position, _move_stop_distance, _target_move_position, _target.TargetStopDistance); // PATH NEXT MOVE POSITION TO TARGET MOVE POSITION } if (_move_lateral_variance > 0) { float _max_range = _move_stop_distance + _move_lateral_variance; CustomGizmos.ZickZackCircle(_move_position, _move_lateral_variance, "", false); // RANDOM RANGE CustomGizmos.Circle(_move_position, _max_range, 5, true); // MAX MOVE RANGE } #endif }
/// <summary> /// Draws the home. /// </summary> public void DrawHome() { if (!CreatureControl.Creature.Essentials.TargetReady() || ShowHome == false) { return; } TargetObject _target = CreatureControl.Creature.Essentials.Target; DrawTargetGizmos(_target); if (!Application.isPlaying) { BehaviourModeObject _mode = null; _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Essentials.BehaviourModeTravel); DrawBehaviourModeGizmos(_target, _mode); _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Essentials.BehaviourModeLeisure); DrawBehaviourModeGizmos(_target, _mode); _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Essentials.BehaviourModeRendezvous); DrawBehaviourModeGizmos(_target, _mode); } }
public MissionObject(TargetType _type) { m_Target = new TargetObject(_type); }
public TargetObject(TargetObject _target) { Copy(_target); }
/// <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 ); } } } }
private void DrawBehaviourModeRuleGizmos(TargetObject _target, BehaviourModeRuleObject _rule) { #if UNITY_EDITOR if (_target == null || _target.IsValid == false || _rule == null) { return; } Vector3 _owner_position = m_Owner.transform.position; Vector3 _target_pos = _target.TargetPosition; Vector3 _target_move_position = _target.TargetMovePosition; float _target_stop_distance = _target.TargetStopDistance; float _target_selection_range = _target.Selectors.SelectionRange; //float _target_selection_angle = _target.Selectors.SelectionAngle; DrawOwnerGizmos(); if (Application.isPlaying) { DrawPathGizmos(); DrawMoveGizmos(); } float _level = GetLevel(); _owner_position.y = _level; _target_pos.y = _level; _target_move_position.y = _level; if (_rule.Move.Type == MoveType.DEFAULT) { } else if (_rule.Move.Type == MoveType.AVOID) { MoveContainer _move = _rule.Move; //float _radius = _target_selection_range + 0.25f;// _move.Avoid.MaxAvoidDistance;//( _target_selection_range / 2 ) + 0.25f; //float _angle = _move.Avoid.MaxDirectionAngle; Gizmos.color = MoveAvoidColor; UnityEditor.Handles.color = Gizmos.color; //DrawDirectionAngle( m_Owner.transform, _radius, _angle ); //DrawDirectionAngle( _target.TargetGameObject.transform, _radius, _angle ); Vector3 _right = Vector3.Cross(_target.TargetGameObject.transform.up, _target.TargetGameObject.transform.forward); Vector3 _avoid_pos_right = _target_pos + (_right * _move.Avoid.AvoidDistance); Vector3 _avoid_pos_left = _target_pos + (_right * -_move.Avoid.AvoidDistance); CustomGizmos.OffsetPath(_target_pos, 0, _avoid_pos_right, _move.MoveStopDistance); CustomGizmos.DottedCircle(_avoid_pos_right, _move.MoveStopDistance, 5, 2); CustomGizmos.OffsetPath(_target_pos, 0, _avoid_pos_left, _move.MoveStopDistance); CustomGizmos.DottedCircle(_avoid_pos_left, _move.MoveStopDistance, 5, 2); if (Application.isPlaying) { /* * Gizmos.color = Color.blue; * Gizmos.DrawLine( _target_pos, CreatureControl.Creature.Move.AvoidMovePosition ); * Gizmos.color = Color.red; * Gizmos.DrawLine( _target_pos, CreatureControl.Creature.Move.MovePosition ); */ } } else if (_rule.Move.Type == MoveType.ESCAPE) { MoveContainer _move = _rule.Move; float _inner_radius = (_target_selection_range / 2) + 0.25f; float _outer_radius = _inner_radius + _rule.Move.MoveSegmentLength; float _outer_radius_max = _inner_radius + _rule.Move.MoveSegmentLengthMax; float _outer_radius_min = _inner_radius + _rule.Move.MoveSegmentLengthMin; float _inner_angle = 0; float _outer_angle = _inner_angle + _move.Escape.RandomEscapeAngle; Gizmos.color = MoveEscapeColor; Vector3 _left_inner_pos = Tools.GetDirectionPosition(_target.TargetGameObject.transform, -_inner_angle, _inner_radius); Vector3 _right_inner_pos = Tools.GetDirectionPosition(_target.TargetGameObject.transform, _inner_angle, _inner_radius); Vector3 _left_outer_pos = Tools.GetDirectionPosition(_target.TargetGameObject.transform, -_outer_angle, _outer_radius); Vector3 _right_outer_pos = Tools.GetDirectionPosition(_target.TargetGameObject.transform, _outer_angle, _outer_radius); _target_pos.y = _level; _left_inner_pos.y = _level; _right_inner_pos.y = _level; _left_outer_pos.y = _level; _right_outer_pos.y = _level; Gizmos.DrawLine(_target_pos, _left_inner_pos); Gizmos.DrawLine(_target_pos, _right_inner_pos); Gizmos.DrawLine(_left_inner_pos, _left_outer_pos); Gizmos.DrawLine(_right_inner_pos, _right_outer_pos); CustomGizmos.Arc(_target.TargetGameObject.transform, _inner_radius, 1, -_inner_angle, _inner_angle, _level, false); CustomGizmos.Arc(_target.TargetGameObject.transform, _outer_radius, 1, -_outer_angle, _outer_angle, _level, false); CustomGizmos.Arc(_target.TargetGameObject.transform, _outer_radius_min, 1, -_outer_angle, _outer_angle, _level, true); CustomGizmos.Arc(_target.TargetGameObject.transform, _outer_radius_max, 1, -_outer_angle, _outer_angle, _level, true); // DENGER ZONE BEGIN _inner_radius += 0.25f; float _degree = CustomGizmos.GetBestDegrees(_inner_radius, _inner_angle); CustomGizmos.ArrowArc(_target.TargetGameObject.transform, _inner_radius, _degree, -_inner_angle, _inner_angle, _level); Transform _target_transform = _target.TargetGameObject.transform; Vector3 _center = _target_transform.position; Vector3 _center_pos = Tools.GetDirectionPosition(_target_transform, 0, _inner_radius + (_inner_radius / 10)); Vector3 _left_pos = Tools.GetDirectionPosition(_target_transform, -_inner_angle, _inner_radius); Vector3 _right_pos = Tools.GetDirectionPosition(_target_transform, _inner_angle, _inner_radius); _center.y = _level; _center_pos.y = _level; _left_pos.y = _level; _right_pos.y = _level; Gizmos.DrawLine(_center, _center_pos); Gizmos.DrawLine(_center, _left_pos); Gizmos.DrawLine(_center, _right_pos); } else if (_rule.Move.Type == MoveType.ORBIT) { MoveContainer _move = _rule.Move; float _degrees = CreatureControl.Creature.Move.OrbitDegrees; float _radius = _move.Orbit.Radius; if (Application.isPlaying) { _move = CreatureControl.Creature.Move.CurrentMove; _radius = CreatureControl.Creature.Move.OrbitRadius; } Gizmos.color = MoveOrbitColor; CustomGizmos.Orbit(m_Owner.transform.position, _target_move_position, _radius, _degrees, _move.Orbit.RadiusShift, _move.Orbit.MinDistance, _move.Orbit.MaxDistance, _level); } else if (_rule.Move.Type == MoveType.DETOUR) { Vector3 _detour_pos = _rule.Move.Detour.Position; _detour_pos.y = _level; Gizmos.color = MoveDetourColor; CustomGizmos.OffsetPath(_detour_pos, _rule.Move.MoveStopDistance, _target_move_position, _target_stop_distance); CustomGizmos.Circle(_detour_pos, _rule.Move.MoveStopDistance, 5, false); // STOP DISTANCE RANGE //DrawMoveGizmos( Vector3 _initial_position, Vector3 _move_position, float _stop_distance, float _random_range, Vector3 _target_position, float _target_stop_distance ) } #endif }
/// <summary> /// Draws the target gizmos. /// </summary> /// <param name="_target">_target.</param> private void DrawTargetGizmos(TargetObject _target, Color _target_color, Color _selection_color) { #if UNITY_EDITOR if (_target == null || _target.IsValid == false) { return; } Vector3 _target_pos = _target.TargetPosition; Vector3 _target_direction = _target.TargetDirection; Vector3 _target_pos_offset = _target.TargetOffsetPosition; Vector3 _target_pos_move = _target.TargetMovePosition; float _target_selection_distance = _target.Selectors.SelectionRange; float _target_selection_angle = _target.Selectors.SelectionAngle; Vector3 _target_pos_top = _target_pos; Vector3 _target_pos_bottom = _target_pos; float _level = GetLevel(); _target_pos.y = GetLevel(); _target_pos_offset.y = GetLevel(); _target_pos_move.y = GetLevel(); _target_pos_top.y = GetLevel() + 3; _target_pos_bottom.y = 0; Color _previous_color = Gizmos.color; Gizmos.color = _target_color; UnityEditor.Handles.color = _target_color; // SELECTION RANGE BEGIN /*if( ShowSolidInteractionRange && SolidInteractionAlpha > 0 ) * { * UnityEditor.Handles.color = _selection_color; * UnityEditor.Handles.DrawWireDisc( _target_pos , Vector3.up, _target_selection_distance ); * * Color _selection_color_transparent = _selection_color; * _selection_color_transparent.a = SolidInteractionAlpha; * UnityEditor.Handles.color = _selection_color_transparent; * UnityEditor.Handles.DrawSolidDisc( _target_pos , Vector3.up, _target_selection_distance ); * } * else * { * UnityEditor.Handles.color = _selection_color; * UnityEditor.Handles.DrawWireDisc( _target_pos , Vector3.up, _target_selection_distance ); * }*/ //if( _target_selection_angle > 0 && _target_selection_angle <= 180 ) { if (_target_selection_angle == 0) { _target_selection_angle = 180; } CustomGizmos.ArrowArc(_target.TargetGameObject.transform, _target_selection_distance, CustomGizmos.GetBestDegrees(_target_selection_distance, _target_selection_angle), -_target_selection_angle, _target_selection_angle, _level, true); if (_target_selection_angle < 180) { Transform _target_transform = _target.TargetGameObject.transform; Vector3 _center = _target_transform.position; Vector3 _center_pos = Tools.GetDirectionPosition(_target_transform, 0, _target_selection_distance + (_target_selection_distance / 10)); Vector3 _left_pos = Tools.GetDirectionPosition(_target_transform, -_target_selection_angle, _target_selection_distance - 0.25f); Vector3 _right_pos = Tools.GetDirectionPosition(_target_transform, _target_selection_angle, _target_selection_distance - 0.25f); _center.y = _level; _center_pos.y = _level; _left_pos.y = _level; _right_pos.y = _level; //Gizmos.DrawLine( _center, _center_pos ); Gizmos.DrawLine(_center, _left_pos); Gizmos.DrawLine(_center, _right_pos); /**/ } } // SELECTION RANGE END // TARGET ICON BEGIN Gizmos.DrawLine(_target_pos_bottom, _target_pos_top); Gizmos.DrawIcon(_target_pos_top, "ice_waypoint.png"); // TARGET ICON END // TARGET STOP DISTANCE BEGIN if (_target.TargetIgnoreLevelDifference) { CustomGizmos.Circle(_target_pos_move, _target.TargetStopDistance, 5, false); // IGNORES LEVEL DIFFERNCE SO WE DRAW JUST A CIRCLE } else { Gizmos.DrawWireSphere(_target_pos_move, _target.TargetStopDistance); // IF THE LEVEL IS IMPORTANT FOR THE STOP DISTANCE WE DRAW A SPHERE } // TARGET STOP DISTANCE END // MAX AND RANDOM RANGE BEGIN CustomGizmos.Circle(_target_pos_offset, _target.TargetRandomRange, 5, false); // RANDOM RANGE CustomGizmos.Circle(_target_pos_offset, _target.TargetRandomRange + _target.TargetStopDistance, 5, true); // MAX RANGE // MAX AND RANDOM RANGE END // SPECIAL CASES FOR INTERACTOR WHICH COULD HAVE SEVERAL SELECTION RANGES if (_target.Type != TargetType.INTERACTOR) { if (Vector3.Distance(_target_pos_move, _target_pos_offset) <= _target.TargetStopDistance) { CustomGizmos.OffsetPath(_target_pos, 0.0f, _target_pos_offset, _target.TargetStopDistance); } else { Gizmos.DrawLine(_target_pos, _target_pos_offset); } CustomGizmos.OffsetPath(_target_pos_offset, 0.0f, _target_pos_move, _target.TargetStopDistance); // DIRECTION CustomGizmos.Arrow(_target_pos, _target_direction * _target.TargetStopDistance, 0.5f, 20); } BehaviourModeObject _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(_target.BehaviourModeKey); DrawBehaviourModeGizmos(_target, _mode); // PRIVIOUS COLOR Gizmos.color = _previous_color; UnityEditor.Handles.color = _previous_color; #endif } } /// <summary> /// Pointer object. /// </summary> [System.Serializable] public class PathObject : System.Object { public void NavMeshPath(NavMeshAgent _agent) { /* * GameObject _object = new GameObject(); * _object.transform.parent = _agent.gameObject.transform; * LineRenderer _line = _object.AddComponent<LineRenderer>(); * _line.SetColors(Color.white,Color.white); * _line.SetWidth(0.1f,0.1f); * //Get def material * * _line.gameObject.renderer.material.color = Color.white; * _line.gameObject.renderer.material.shader = Shader.Find("Sprites/Default"); * _line.gameObject.AddComponent<LineScript>(); * _line.SetVertexCount(_agent.path.corners.Length+1); * int i = 0; * foreach(Vector3 v in p.corners) * { * _line.SetPosition(i,v); * //Debug.Log("position agent"+g.transform.position); * //Debug.Log("position corner = "+v); * i++; * } * _line.SetPosition(p.corners.Length,_agent.destination); * _line.gameObject.tag = "ligne";*/ } }
public InteractorObject() { m_Target = new TargetObject(TargetType.INTERACTOR); }
/// <summary> /// Sets the active target. /// </summary> /// <param name="_target">_target.</param> public void SetActiveTarget(TargetObject _target) { if (Status.IsDead) { return; } if (Move.Deadlocked) { Move.ResetDeadlock(); if (Move.DeadlockAction == DeadlockActionType.BEHAVIOUR) { Behaviour.SetBehaviourModeByKey(Move.DeadlockBehaviour); return; } else if (Move.DeadlockAction == DeadlockActionType.UPDATE && m_ActiveTarget != null) { m_ActiveTarget.UpdateOffset(); } else { Status.Kill(); return; } } if (_target == null || Status.RecreationRequired) { _target = Essentials.Target; } if (_target == null || !_target.IsValid) { Debug.LogError(m_Owner.name + " have no target!"); return; } if (IsTargetUpdatePermitted(_target)) { if (m_ActiveTarget != _target) { m_PreviousTarget = m_ActiveTarget; if (m_PreviousTarget != null) { m_PreviousTarget.SetActive(false); } m_ActiveTarget = _target; if (m_ActiveTarget != null) { m_ActiveTarget.SetActive(true); } m_TargetChanged = true; } if (m_ActiveTarget != null) { Behaviour.SetBehaviourModeByKey(ActiveTarget.BehaviourModeKey); } } }
public void SelectBestTarget() { TargetObject _favourite_target = null; foreach (TargetObject _target in m_AvailableTargets) { if (_target == null || _target.IsValid == false) { continue; } _target.Selectors.ResetRelevanceMultiplier(); /* * if( m_ActiveTarget != null && m_ActiveTarget != _target ) * m_ActiveTarget.Selectors.CompareSuccessorTargets( _target, m_Owner.transform.position ); */ bool _final_result = false; if (_target.TargetInSelectionRange(m_Owner.transform, Move.FieldOfView, Move.VisualRange)) { _final_result = true; } if (_target.Selectors.UseAdvanced) { foreach (TargetSelectorObject _selector in _target.Selectors.Selectors) { bool _selector_result = false; foreach (TargetSelectorConditionObject _condition in _selector.Conditions) { if (_condition.Enabled == false) { continue; } bool _condition_result = false; if (_condition.ExpressionType == TargetSelectorExpressionType.DISTANCE) { _condition_result = false; //_target.TargetInSelectionRange( m_Owner.transform.position, _condition.Distance ); //TODO - HANDLE DISTANCE } else if (_condition.ExpressionType == TargetSelectorExpressionType.BEHAVIOR) { if (Behaviour.BehaviourModeKey == _condition.BehaviourModeKey) { _condition_result = true; } if (_condition.Operator == LogicalOperatorType.NOT) { _condition_result = !_condition_result; } } else if (_condition.ExpressionType == TargetSelectorExpressionType.POSITION) { switch (_condition.PositionType) { case TargetSelectorPositionType.TARGETMOVEPOSITION: _condition_result = _target.TargetMoveComplete; break; case TargetSelectorPositionType.TARGETMAXRANGE: _condition_result = _target.TargetInMaxRange(m_Owner.transform.position); break; } if (_condition.Operator == LogicalOperatorType.NOT) { _condition_result = !_condition_result; } } else if (_condition.ExpressionType == TargetSelectorExpressionType.PRECURSOR) { TargetObject _precursor = null; if (_target == m_ActiveTarget) { _precursor = m_PreviousTarget; } else { _precursor = m_ActiveTarget; } _condition_result = _condition.ComparePrecursorTarget(_precursor); } if (_condition.ConditionType == ConditionalOperatorType.AND || _condition_result == true) { _selector_result = _condition_result; } } if (_selector_result) { foreach (TargetSelectorStatementObject _statement in _selector.Statements) { if (_statement.StatementType == TargetSelectorStatementType.PRIORITY) { _target.Selectors.Priority = _statement.Priority; } else if (_statement.StatementType == TargetSelectorStatementType.SUCCESSOR) { if (_statement.SuccessorType == TargetSuccessorType.NAME) { TargetObject _successor = FindTargetByName(_statement.SuccessorTargetName); if (_successor != null && _successor.IsValid) { _favourite_target = _successor; } } } } } if (_selector.ConditionType == ConditionalOperatorType.AND || _selector_result == true) { _final_result = _selector_result; } } } if (_final_result) { bool _handled = false; if (_target.Selectors.UseAdvanced && _target.Selectors.Statements.Count > 0) { foreach (TargetSelectorStatementObject _statement in _target.Selectors.Statements) { if (_statement.StatementType == TargetSelectorStatementType.SUCCESSOR) { if (_statement.SuccessorType == TargetSuccessorType.NAME) { TargetObject _successor = FindTargetByName(_statement.SuccessorTargetName); if (_successor != null && _successor.IsValid) { _favourite_target = _successor; _handled = true; } } } } } if (_handled == false) { if (_favourite_target == null) { _favourite_target = _target; } else if (_target.SelectionPriority > _favourite_target.SelectionPriority) { _favourite_target = _target; } else if (_target.SelectionPriority == _favourite_target.SelectionPriority && Random.Range(0, 1) == 1) { _favourite_target = _target; } } } } SetActiveTarget(_favourite_target); }
public void Action(InventoryActionDataObject _action) { if (_action == null || !_action.Enabled) { return; } if (_action.DropItemRequired()) { InventorySlotObject _slot = GetSlotByItemName(_action.ItemName); if (_slot != null && _slot.Amount > 0) { Transform _transform = ICE.World.Utilities.SystemTools.FindChildByName(_action.ParentName, Owner.transform); _transform = (_transform != null ? _transform : Owner.transform); Quaternion _rotation = Quaternion.Euler(0, UnityEngine.Random.Range(0, 360), 0); Vector3 _position = PositionTools.FixTransformPoint(_transform, _action.Offset); GameObject _item = _slot.GiveItem(_position, _rotation); if (_item == null) { _item = CreatureRegister.Spawn(_slot.ItemReferenceObject, _position, _rotation); _slot.Amount--; } } } else if (_action.ParentUpdateRequired()) { InventorySlotObject _slot = GetSlotByItemName(_action.ItemName); if (_slot != null && _slot.Amount > 0) { if (_slot.ItemObject != null) { _slot.MountPointName = _action.ParentName; } } } else if (_action.CollectActiveItemRequired()) { ICECreatureControl _control = OwnerComponent as ICECreatureControl; TargetObject _target = _control.Creature.ActiveTarget; if (_control != null && _target != null && _target.Selectors.TotalCheckIsValid) //&& LastCollectedObjectID != _target.TargetID ) { GameObject _item = _target.TargetGameObject; //LastCollectedObjectID = _target.TargetID; if (_target.EntityComponent != null && _target.EntityComponent.IsChildEntity) { ICEWorldEntity _parent = _target.EntityComponent.RootEntity; if (_parent != null) { if (DebugLogIsEnabled) { PrintDebugLog(this, "CollectActiveItem : take '" + _target.Name + "' from " + _parent.name + " (" + _parent.ObjectInstanceID + ")"); } InventorySlotObject _slot = GetInventorySlot(_parent.gameObject, _target.TargetName); if (_slot != null) { _item = _slot.GiveItem(); } } } if (Insert(_item)) { //Debug.Log( _control.Creature.ActiveTarget.TargetGameObject.name + " - " + _control.Creature.ActiveTarget.TargetGameObject.GetInstanceID() ); //_target.ResetTargetGameObject(); _control.Creature.ResetActiveTarget(); // } } } }
/// <summary> /// Draws the patrol. /// </summary> public void DrawPatrol() { if (!CreatureControl.Creature.Missions.Patrol.TargetReady() || ShowPatrol == false) { return; } TargetObject _target = null; Vector3 _target_move_position = Vector3.zero; float _target_stop_distance = 0; WaypointObject _last_waypoint_target = CreatureControl.Creature.Missions.Patrol.Waypoints.GetLastValidWaypoint(); Vector3 _last_target_move_position = Vector3.zero; float _last_target_stop_distance = 0; if (_last_waypoint_target != null) { _last_target_move_position = _last_waypoint_target.TargetMovePosition; _last_target_move_position.y = GetLevel(); _last_target_stop_distance = _last_waypoint_target.TargetStopDistance; } for (int i = 0; i < CreatureControl.Creature.Missions.Patrol.Waypoints.Waypoints.Count; i++) { _target = (TargetObject)CreatureControl.Creature.Missions.Patrol.Waypoints.Waypoints[i]; if (_target.IsValid == false) { continue; } _target_move_position = _target.TargetMovePosition; _target_move_position.y = GetLevel(); _target_stop_distance = _target.TargetStopDistance; if (CreatureControl.Creature.Missions.Patrol.Waypoints.Waypoints[i].Enabled) { DrawTargetGizmos(_target); Color _default_color = Gizmos.color; Gizmos.color = MoveProjectedPathColor; CustomGizmos.OffsetPath(_last_target_move_position, _last_target_stop_distance, _target_move_position, _target_stop_distance); Gizmos.color = _default_color; _last_target_move_position = _target_move_position; _last_target_stop_distance = _target_stop_distance; } else { Color _color = TargetColor; _color.a = 0.25f; DrawTargetGizmos(_target, _color); } if (!Application.isPlaying) { BehaviourModeObject _mode = null; _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Missions.Patrol.GetBehaviourModeTravelByIndex(i)); DrawBehaviourModeGizmos(_target, _mode); _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Missions.Patrol.GetBehaviourModePatrolByIndex(i)); DrawBehaviourModeGizmos(_target, _mode); _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Missions.Patrol.GetBehaviourModeLeisureByIndex(i)); DrawBehaviourModeGizmos(_target, _mode); _mode = CreatureControl.Creature.Behaviour.GetBehaviourModeByKey(CreatureControl.Creature.Missions.Patrol.GetBehaviourModeRendezvousByIndex(i)); DrawBehaviourModeGizmos(_target, _mode); } } }
public EssentialsObject() { m_Target = new TargetObject(TargetType.HOME); }
/// <summary> /// Sets the active target. /// </summary> /// <param name="_target">_target.</param> public void SetActiveTarget(TargetObject _target) { if (Status.IsDead || Status.IsSpawning) { return; } if (Move.Deadlock.Deadlocked) { Move.Deadlock.Reset(Owner.transform); if (Move.Deadlock.Action == DeadlockActionType.BEHAVIOUR) { SetActiveBehaviourModeByKey(Move.Deadlock.Behaviour); return; } else if (Move.Deadlock.Action == DeadlockActionType.UPDATE && m_ActiveTarget != null) { m_ActiveTarget.Move.UpdateRandomOffset(); } else { Status.Kill(); return; } } if (_target == null || !_target.IsValidAndReady || Status.RecreationRequired) { _target = Essentials.PrepareTarget(OwnerComponent); } if (_target == null || !_target.IsValidAndReady) { if (DebugLogIsEnabled) { PrintDebugLog(this, "Sorry, the creature have no valid target!"); } return; } m_TargetChanged = false; if (IsTargetUpdatePermitted(_target)) { // update target if (!_target.CompareTarget(m_ActiveTarget, m_ActiveTargetID)) { // handle previous target ResetActiveTarget(); // handle new target m_ActiveTarget = _target; m_ActiveTargetGameObject = _target.TargetGameObject; m_ActiveTargetID = _target.TargetID; m_ActiveTargetName = _target.TargetName; m_ActiveTargetKey = _target.TargetName + _target.TargetID.ToString(); if (m_ActiveTarget != null) { m_ActiveTarget.SetActive(OwnerComponent); if (m_ActiveTarget.EntityComponent != null) { m_ActiveTarget.EntityComponent.AddActiveCounterpart(OwnerComponent as ICECreatureEntity); } if (m_ActiveTarget.GroupMessage.Type != BroadcastMessageType.NONE) { /* * BroadcastMessageDataObject _data = new BroadcastMessageDataObject(); * * _data.Type = m_ActiveTarget.GroupMessage.Type; * _data.TargetGameObject = m_ActiveTarget.TargetGameObject; * _data.Command = m_ActiveTarget.GroupMessage.Command;*/ ICECreatureEntity _entity = OwnerComponent as ICECreatureEntity; if (_entity != null) { _entity.Message.SendGroupMessage(new BroadcastMessageDataObject(m_ActiveTarget.GroupMessage.Type, m_ActiveTarget.TargetGameObject, m_ActiveTarget.GroupMessage.Command)); } } } if (DebugLogIsEnabled) { string _previus = (m_PreviousTargetName != "" ? m_PreviousTargetName + " (" + m_PreviousTargetID + ")": "unknown"); string _active = (m_ActiveTargetName != "" ? m_ActiveTargetName + " (" + m_ActiveTargetID + ")": "unknown"); PrintDebugLog(this, "SetActiveTarget - creature changed active target from " + _previus + " to " + _active + "."); } Move.UpdateTargets(m_ActiveTarget, Essentials.Target); m_TargetChanged = true; } // update target behaviour if (m_ActiveTarget != null) { string _key = ActiveTarget.Behaviour.CurrentBehaviourModeKey; if (string.IsNullOrEmpty(_key)) { // if the active target is not a HOME or if the creature outside the max range it have to travel to reach its target if (!ActiveTarget.TargetInMaxRange(Owner.transform.position)) { _key = Essentials.BehaviourModeRun; } // if the creature reached the TargetMovePosition it should do the rendezvous behaviour else if (ActiveTarget.TargetMoveComplete) { _key = Essentials.BehaviourModeIdle; } // in all other case the creature should be standby and do some leisure activities else //if( Target.TargetRandomRange > 0 ) { _key = Essentials.BehaviourModeWalk; } } SetActiveBehaviourModeByKey(_key); } } }