private bool SetRuleByIndex(int _index)
{
if (_index < 0 || _index >= m_Rules.Count)
{
return(false);
}
BehaviourModeRuleObject new_rule = m_Rules[_index];
if (m_Rule != new_rule || m_Rule == null)
{
m_LastRule = m_Rule;
m_LastRuleIndex = m_RuleIndex;
m_Rule = new_rule;
m_RuleIndex = _index;
m_RuleChanged = true;
}
else
{
m_RuleChanged = false;
}
return(m_RuleChanged);
}
public void Copy(BehaviourModeRuleObject _rule)
{
if (_rule == null)
{
return;
}
base.Copy(_rule);
Animation.Copy(_rule.Animation);
Look.Copy(_rule.Look);
Audio.Copy(_rule.Audio);
Inventory.Copy(_rule.Inventory);
Events.Copy(_rule.Events);
Effect.Copy(_rule.Effect);
Link.Copy(_rule.Link);
Move.Copy(_rule.Move);
Body.Copy(_rule.Body);
Influences.Copy(_rule.Influences);
Key = _rule.Key;
LengthMax = _rule.LengthMax;
LengthMin = _rule.LengthMin;
LengthMaximum = _rule.LengthMaximum;
Weight = _rule.Weight;
UseCustomLength = _rule.UseCustomLength;
FoldoutCustomLength = _rule.FoldoutCustomLength;
}
public BehaviourModeRuleObject(BehaviourModeRuleObject _rule)
{
Animation = _rule.Animation;
Audio = new AudioDataObject(_rule.Audio);
Effect = _rule.Effect;
Foldout = _rule.Foldout;
Influences = _rule.Influences;
Key = _rule.Key;
LengthMax = _rule.LengthMax;
LengthMin = _rule.LengthMin;
UseCustomLength = _rule.UseCustomLength;
Links = _rule.Links;
Move = _rule.Move;
UseFootsteps = _rule.UseFootsteps;
}
/// <summary>
/// Sets a rule by the specified index.
/// </summary>
/// <returns><c>true</c>, if rule was set by index, <c>false</c> otherwise.</returns>
/// <param name="_index">Index.</param>
private bool SetRuleByIndex(int _index)
{
List <BehaviourModeRuleObject> _rules = ValidRules;
if (_index < 0 || _index >= _rules.Count)
{
if (DebugLogIsEnabled)
{
PrintDebugLog(this, "SetRuleByIndex : Behaviour mode rule index '" + _index + "' out of range, please check this mode and its rules!");
}
return(false);
}
BehaviourModeRuleObject _new_rule = _rules[_index];
if (m_Rule != _new_rule || m_Rule == null)
{
//if( m_Rule != null )
// m_Rule.Stop();
m_LastRule = m_Rule;
m_Rule = _new_rule;
m_Rule.Index = _index;
//if( m_Rule != null )
// m_Rule.Start( OwnerComponent );
m_RuleChanged = true;
}
else
{
m_RuleChanged = false;
}
return(m_RuleChanged);
}
public BehaviourModeRuleObject(BehaviourModeRuleObject _rule) : base(_rule as ICEOwnerObject)
{
Copy(_rule);
}
public void Play(BehaviourModeRuleObject _rule)
{
if (_rule == null || _rule.Animation.InterfaceType == AnimationInterfaceType.NONE)
{
return;
}
if (m_Animator != null && m_animator_last_boolean != "")
{
m_Animator.SetBool(m_animator_last_boolean, false);
}
//m_AnimatorAutoSpeed = false;
if (_rule.Animation.InterfaceType == AnimationInterfaceType.ANIMATION)
{
if (m_Animation == null)
{
Debug.LogError("CAUTION : Missing Animation Component on " + m_Owner.gameObject.name);
return;
}
WrapMode _mode = _rule.Animation.Animation.wrapMode;
m_Animation[_rule.Animation.Animation.Name].wrapMode = _mode;
//animation[ m_BehaviourData.AnimationName ].speed = Mathf.Clamp( m_BehaviourData.MoveVelocity. controller.velocity.magnitude, 0.0, runMaxAnimationSpeed);
m_Animation.CrossFade(_rule.Animation.Animation.Name, _rule.Animation.Animation.TransitionDuration);
}
else if (_rule.Animation.InterfaceType == AnimationInterfaceType.CLIP)
{
if (m_Animation == null)
{
m_Animation = m_Owner.AddComponent <Animation>();
}
if (m_Animation != null && _rule.Animation.Clip.Clip != null)
{
m_Animation.AddClip(_rule.Animation.Clip.Clip, _rule.Animation.Clip.Clip.name);
m_Animation.CrossFade(_rule.Animation.Clip.Clip.name, _rule.Animation.Clip.TransitionDuration);
}
}
else if (_rule.Animation.InterfaceType == AnimationInterfaceType.ANIMATOR)
{
if (m_Animator == null)
{
Debug.LogError("Missing Animator Component!");
return;
}
if (_rule.Animation.Animator.Type == AnimatorControlType.DIRECT)
{
m_Animator.CrossFade(_rule.Animation.Animator.Name, _rule.Animation.Animator.TransitionDuration, -1, 0);
m_Animator.speed = _rule.Animation.Animator.Speed;
//m_AnimatorAutoSpeed = _rule.Animation.Animator.AutoSpeed;
/*if( _rule.Animation.Animator.AutoSpeed )
* m_Animator.speed = Mathf.Clamp( m_BehaviourData.MoveVelocity. controller.velocity.magnitude, 0.0, runMaxAnimationSpeed);
* else*/
}
else if (_rule.Animation.Animator.Type == AnimatorControlType.CONDITIONS)
{
if (_rule.Animation.Animator.Boolean != "-")
{
m_Animator.SetBool(_rule.Animation.Animator.Boolean, true);
m_animator_last_boolean = _rule.Animation.Animator.Boolean;
}
if (_rule.Animation.Animator.Trigger != "-")
{
m_Animator.SetTrigger(_rule.Animation.Animator.Trigger);
}
}
else if (_rule.Animation.Animator.Type == AnimatorControlType.ADVANCED)
{
}
}
}
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
}
