private void DrawDirectionAngle(Transform _center, float _inner_radius, float _outer_radius, float _outer_radius_max, float _outer_radius_min, float _inner_angle, float _outer_angle)
{
Vector3 _center_pos = _center.position;
float _level = GetLevel();
Vector3 _left_inner_pos = Tools.GetDirectionPosition(_center, -_inner_angle, _inner_radius);
Vector3 _right_inner_pos = Tools.GetDirectionPosition(_center, _inner_angle, _inner_radius);
Vector3 _left_outer_pos = Tools.GetDirectionPosition(_center, -_outer_angle, _outer_radius);
Vector3 _right_outer_pos = Tools.GetDirectionPosition(_center, _outer_angle, _outer_radius);
_center_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(_center_pos, _left_inner_pos);
Gizmos.DrawLine(_center_pos, _right_inner_pos);
Gizmos.DrawLine(_left_inner_pos, _left_outer_pos);
Gizmos.DrawLine(_right_inner_pos, _right_outer_pos);
CustomGizmos.Arc(_center, _inner_radius, 1, -_inner_angle, _inner_angle, _level, false);
CustomGizmos.Arc(_center, _outer_radius, 1, -_outer_angle, _outer_angle, _level, false);
CustomGizmos.Arc(_center, _outer_radius_min, 1, -_outer_angle, _outer_angle, _level, true);
CustomGizmos.Arc(_center, _outer_radius_max, 1, -_outer_angle, _outer_angle, _level, true);
}
/// <summary>
/// Draws regular polygons animation
/// </summary>
private void Polygons()
{
int sidesCount = 3 + (int)(sidesCountAmplitude * (sinParam + 1) / 2);
Vector3 currentDirection = Quaternion.AngleAxis(doubleSinParam * normalAmplitude, new Vector3(-1, 0, 1).normalized) * Vector3.up;
CustomGizmos.DrawRegularPoligon(new Vector3(6, 0, 2) + Vector3.right * sinParam * positionAmplitude, Vector3.right, polygonsRadius, sidesCount, currentDirection);
}
private void DrawDirectionAngle(Transform _center, float _radius, float _angle, float _max = 0, float _min = 0)
{
Vector3 _center_pos = _center.position;
float _level = GetLevel();
Vector3 _left_pos = Tools.GetDirectionPosition(_center, -_angle, _radius);
Vector3 _right_pos = Tools.GetDirectionPosition(_center, _angle, _radius);
_center_pos.y = _level;
_left_pos.y = _level;
_right_pos.y = _level;
Gizmos.DrawLine(_center_pos, _left_pos);
Gizmos.DrawLine(_center_pos, _right_pos);
CustomGizmos.Arc(_center, _radius, 1, -_angle, _angle, _level, false);
if (_min > 0 && _min < _radius)
{
CustomGizmos.Arc(_center, _min, 1, -_angle, _angle, _level, true);
}
if (_max > _radius)
{
CustomGizmos.Arc(_center, _max, 1, -_angle, _angle, _level, true);
}
}
/// <summary>
/// Calculates arrow head position and draws it
/// </summary>
private void ArrowHead()
{
Vector3 arrowHeadPos = Vector3.up * (sinParam * arrowHeadAmplitude + arrowHeadOffset) + new Vector3(0.5f, 0, 0.5f);
Vector3 currentDirection = Quaternion.AngleAxis(currentAngle, Vector3.up) * Vector3.forward;
CustomGizmos.DrawArrowTip(arrowHeadPos, Vector3.down, arrowTipSize, currentDirection);
}
/// <summary>
/// Raises the draw gizmos event.
/// </summary>
public void OnDrawGizmos()
{
if (!ShowGrid)
{
return;
}
Gizmos.color = GridColor;
int _size = 5;
for (int i = 0; i < 10; i++)
{
Vector3 _pos_x1 = new Vector3(m_GridMovePosition.x - (GridSize * _size), 1, m_GridMovePosition.z - (GridSize * _size) + (GridSize * i));
Vector3 _pos_x2 = new Vector3(m_GridMovePosition.x + (GridSize * _size), 1, m_GridMovePosition.z - (GridSize * _size) + (GridSize * i));
Vector3 _pos_z1 = new Vector3(m_GridMovePosition.x - (GridSize * _size) + (GridSize * i), 1, m_GridMovePosition.z - (GridSize * _size));
Vector3 _pos_z2 = new Vector3(m_GridMovePosition.x - (GridSize * _size) + (GridSize * i), 1, m_GridMovePosition.z + (GridSize * _size));
Gizmos.DrawLine(_pos_x1, _pos_x2);
Gizmos.DrawLine(_pos_z1, _pos_z2);
for (int a = 1; a <= 10; a++)
{
Vector3 _node_point = _pos_x1 + new Vector3(GridSize * a, 0, 0);
Vector3 _offset = new Vector3(-GridSize * 0.25f, 10, GridSize * 0.5f);
CustomGizmos.Text("" + _node_point.x + ":" + _node_point.z, _node_point + _offset, GridColor, 14, FontStyle.Normal);
}
}
}
/// <summary>
/// Resets memory footprint for bezier if necessary
/// </summary>
private void MemoryReset()
{
if (resetMemory)
{
resetMemory = false;
CustomGizmos.ResetBezierMemory();
}
}
/// <summary>
/// Calculates and draws a rectangle
/// </summary>
private void Rectangle()
{
float rectSinParam = Mathf.Sin(lerpingHalfParam * 2 * Mathf.PI);
float rectCosParam = Mathf.Cos(lerpingHalfParam * 2 * Mathf.PI);
Vector2 halfSizes = new Vector2(
1.5f * (rectSinParam * rectSizeAmplitude + (1 - rectSizeAmplitude)),
1 * (rectCosParam * rectSizeAmplitude + (1 - rectSizeAmplitude))
);
CustomGizmos.DrawCrossedRect(new Vector3(4, 0, 1.5f), Vector3.forward, Vector3.right, halfSizes, 5);
}
private void DrawGridClear()
{
// Iterate over XY dimensions
for (int y = 0; y < grid.height; y++)
{
for (int x = 0; x < grid.width; x++)
{
// Draw default wire grid
CustomGizmos.DrawWireSquare(GetWorldPosition(x, y) + new Vector3(0.5f, 0.5f, 0.0f), Vector3.one * grid.cellSize, Color.white, Color.clear, "");
}
}
}
public void DrawOwnerGizmos()
{
#if UNITY_EDITOR
Vector3 _owner_pos = m_Owner.transform.position;
_owner_pos.y = GetLevel();
CustomGizmos.Triangle(_owner_pos, m_Owner.transform.forward, 2, 35);
if (m_creature_control.Creature.Move.FieldOfView > 0)
{
float _angle = m_creature_control.Creature.Move.FieldOfView;
float _distance = m_creature_control.Creature.Move.VisualRange;
if (_distance == 0)
{
_distance = 1.5f;
}
float _degree = CustomGizmos.GetBestDegrees(_distance, _angle);
CustomGizmos.ArrowArc(m_Owner.transform, _distance, _degree, -_angle, _angle, GetLevel());
if (_angle < 180)
{
Vector3 _left_pos = Tools.GetDirectionPosition(m_Owner.transform, -_angle, _distance);
Vector3 _right_pos = Tools.GetDirectionPosition(m_Owner.transform, _angle, _distance);
CustomGizmos.OffsetPath(m_Owner.transform.position, 2, _left_pos, 1);
CustomGizmos.OffsetPath(m_Owner.transform.position, 2, _right_pos, 1);
}
}
if (m_creature_control.Creature.Move.GroundOrientation == GroundOrientationType.NONE || m_creature_control.Creature.Move.GroundOrientation == GroundOrientationType.QUADRUPED)
{
if (m_creature_control.Creature.Move.GroundOrientationPlus)
{
UnityEditor.Handles.CubeCap(0, m_creature_control.Creature.Move.FrontLeftPositionGround, m_Owner.transform.rotation, 0.1f);
UnityEditor.Handles.CubeCap(0, m_creature_control.Creature.Move.BackLeftPositionGround, m_Owner.transform.rotation, 0.1f);
UnityEditor.Handles.CubeCap(0, m_creature_control.Creature.Move.FrontRightPositionGround, m_Owner.transform.rotation, 0.1f);
UnityEditor.Handles.CubeCap(0, m_creature_control.Creature.Move.BackRightPositionGround, m_Owner.transform.rotation, 0.1f);
Gizmos.DrawLine(m_creature_control.Creature.Move.FrontLeftPositionGround, m_creature_control.Creature.Move.FrontLeftPosition);
Gizmos.DrawLine(m_creature_control.Creature.Move.BackLeftPositionGround, m_creature_control.Creature.Move.BackLeftPosition);
Gizmos.DrawLine(m_creature_control.Creature.Move.FrontRightPositionGround, m_creature_control.Creature.Move.FrontRightPosition);
Gizmos.DrawLine(m_creature_control.Creature.Move.BackRightPositionGround, m_creature_control.Creature.Move.BackRightPosition);
UnityEditor.Handles.CubeCap(0, m_creature_control.Creature.Move.FrontLeftPosition, m_Owner.transform.rotation, 0.1f);
UnityEditor.Handles.CubeCap(0, m_creature_control.Creature.Move.BackLeftPosition, m_Owner.transform.rotation, 0.1f);
UnityEditor.Handles.CubeCap(0, m_creature_control.Creature.Move.FrontRightPosition, m_Owner.transform.rotation, 0.1f);
UnityEditor.Handles.CubeCap(0, m_creature_control.Creature.Move.BackRightPosition, m_Owner.transform.rotation, 0.1f);
}
}
#endif
}
/// <summary>
/// Calculates and draws a bezier curve with arrow
/// </summary>
private void BezierArrow()
{
Vector3 currentDirection = Quaternion.AngleAxis(currentAngle, new Vector3(-1, 0, 1).normalized) * Vector3.up;
List <Vector3> bezierPoints = new List <Vector3>();
bezierPoints.Add(new Vector3(3, 0, 4));
bezierPoints.Add(new Vector3(1, 0, 4));
bezierPoints.Add(new Vector3(2, 0, 5));
bezierPoints.Add(new Vector3(0, 0, 5));
float bezSinParam = Mathf.Sin(lerpingHalfParam * 2 * Mathf.PI);
CustomGizmos.BezierWithArrow(bezierPoints, 10, (bezSinParam + 1) / 2, arrowTipSize, currentDirection);
}
void OnDrawGizmos()
{
if (visualizing)
{
Vector3 position = new Vector3(200, Screen.height - 100, 0);
CustomGizmos.drawUIString(currentGesture.NumberPoints + "", position, Color.green);
position += Vector3.down * 20;
foreach (string error in currentErrors)
{
CustomGizmos.drawUIString(error, position, Color.green);
position += Vector3.down * 20;
}
currentGesture.DrawGizmos();
}
}
private void DrawGridAirSealed()
{
// Iterate over XY dimensions
for (int y = 0; y < grid.height; y++)
{
for (int x = 0; x < grid.width; x++)
{
// Draw grid indicating air sealed spaces
if (StaticMaps.worldTileData[x, y].IsSealed())
{
CustomGizmos.DrawWireSquare(GetWorldPosition(x, y) + new Vector3(0.5f, 0.5f, 0.0f), Vector3.one * grid.cellSize, Color.white, new Color(0.0f, 0.0f, 0.75f, 0.4f), "");
}
else
{
CustomGizmos.DrawWireSquare(GetWorldPosition(x, y) + new Vector3(0.5f, 0.5f, 0.0f), Vector3.one * grid.cellSize, Color.white, Color.clear, "");
}
}
}
}
private void DrawGridBuildingBlocked()
{
// Iterate over XY dimensions
for (int y = 0; y < grid.height; y++)
{
for (int x = 0; x < grid.width; x++)
{
// Draw grid indicating tiles which cannot be built upon
if (StaticMaps.worldTileData[x, y].GetCanBuildUpon())
{
CustomGizmos.DrawWireSquare(GetWorldPosition(x, y) + new Vector3(0.5f, 0.5f, 0.0f), Vector3.one * grid.cellSize, Color.white, Color.clear, "");
}
else
{
CustomGizmos.DrawWireSquare(GetWorldPosition(x, y) + new Vector3(0.5f, 0.5f, 0.0f), Vector3.one * grid.cellSize, Color.white, new Color(0.75f, 0.0f, 0.0f, 0.4f), "");
}
}
}
}
public override void DrawGizmos(bool _draw)
{
if (!_draw || !this.enabled || Entity == null)
{
return;
}
CustomGizmos.Color(GizmoColor);
Gizmos.DrawSphere(this.transform.position, GizmoSize);
//Gizmos.DrawWireCube( this.transform.position, Vector3.one );
if (Entity.EntityType == ICE.World.EnumTypes.EntityClassType.Waypoint)
{
ICECreatureWaypoint _waypoint = Entity as ICECreatureWaypoint;
if (_waypoint != null && _waypoint.Links.Enabled)
{
foreach (WaypointLinkObject _link in _waypoint.Links.Links)
{
if (_link.Enabled && _link.Waypoint != null)
{
float _dist = 0.25f;
Vector3 _pos_origin = this.transform.position;
Vector3 _pos_target = _link.Waypoint.transform.position;
Vector3 _dir = (_pos_target - _pos_origin).normalized;
//_dir.y = 0;
Vector3 _rot_dir = _dir;
_rot_dir.y = 0;
_rot_dir = Quaternion.Euler(0, 90, 0) * _rot_dir;
Gizmos.DrawLine(_pos_origin + (_rot_dir * _dist), _pos_target + (_rot_dir * _dist));
//CustomGizmos.Arrow( _pos_origin + ( _rot_dir * _dist ) + ( _dir * 2 ), _dir );
CustomGizmos.ArrowHead(_pos_origin + (_rot_dir * _dist) + (_dir * 1.0f), _dir, _dist * 2, _dist * 100);
CustomGizmos.ArrowHead(_pos_origin + (_rot_dir * _dist) + (_dir * 1.5f), _dir, _dist * 2, _dist * 100);
CustomGizmos.ArrowHead(_pos_origin + (_rot_dir * _dist) + (_dir * 2.0f), _dir, _dist * 2, _dist * 100);
//CustomGizmos.Arrow( 0, _pos_origin + ( _rot_dir * _dist ) + ( _dir * 1 ), Quaternion.LookRotation( _dir ), _dist * 10 );
}
}
}
}
}
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
}
private void OnDrawGizmos()
{
if (Astronomy.SunLight == null)
{
return;
}
if (!Application.isPlaying)
{
Astronomy.SunLight.transform.localRotation = Astronomy.Rotation();
}
Gizmos.color = Color.blue;
Gizmos.DrawLine(Astronomy.SunLight.transform.position + (Astronomy.SunLight.transform.forward * Astronomy.Radius * 0.75f), Astronomy.SunLight.transform.position + (Astronomy.SunLight.transform.forward * Astronomy.Radius));
//Gizmos.DrawLine( Sun.transform.position - ( Sun.transform.forward * Radius * 0.75f ), Sun.transform.position - ( Sun.transform.forward * Radius ) );
CustomGizmos.Circle(Astronomy.SunLight.transform.position, Astronomy.SunLight.transform.up, Astronomy.Radius);
CustomGizmos.Arrow(Astronomy.SunLight.transform.position + (Astronomy.SunLight.transform.forward * Astronomy.Radius * 0.75f), Astronomy.SunLight.transform.forward * -2, 10);
CustomGizmos.HandlesColor(Gizmos.color);
CustomGizmos.Arrow(0, Astronomy.SunLight.transform.position - (Astronomy.SunLight.transform.forward * Astronomy.Radius), Astronomy.SunLight.transform.rotation, 50);
if (m_PathPositions.Count > 1000)
{
m_PathPositions.RemoveAt(0);
}
Vector3 _prior_pos = Vector3.zero;
foreach (Vector3 _pos in m_PathPositions)
{
if (_prior_pos != Vector3.zero)
{
Gizmos.DrawLine(_prior_pos, _pos);
}
_prior_pos = _pos;
}
}
/// <summary>
/// Calculates lines positions and draws them
/// </summary>
private void Lines()
{
CustomGizmos.DrawLine(new Vector3(1f, 0, 0), new Vector3(1f, 0, 1), 1f - sinParam * linesAmplitude - linesOffset, 0);
CustomGizmos.DrawLine(new Vector3(1.2f, 0, 0), new Vector3(1.2f, 0, 1), sinParam * linesAmplitude + linesOffset);
CustomGizmos.DrawLine(new Vector3(1.4f, 0, 0), new Vector3(1.4f, 0, 1), 0, 1 - sinParam * linesAmplitude - linesOffset);
}
private void DrawRegisterGizmos()
{
ICECreatureRegister _register = ICECreatureRegister.Instance;
if (_register == null)
{
return;
}
if (!_register.UseDebug)
{
return;
}
Gizmos.color = new Color(Color.blue.r, Color.blue.g, Color.blue.b, 0.75f);
Vector3 _s = new Vector3(0.5f, 0.15f, 0.5f);
Gizmos.DrawCube(transform.position + (Vector3.up * 0.25f), _s);
Gizmos.DrawCube(transform.position + (Vector3.up * 0.50f), _s);
Gizmos.DrawCube(transform.position + (Vector3.up * 0.75f), _s);
Gizmos.color = new Color(Color.blue.r, Color.blue.g, Color.blue.b, 1f);
CustomGizmos.Text("CREATURE REGISTER", transform.position, Gizmos.color, 14, FontStyle.Bold);
foreach (ReferenceGroupObject _group in _register.ReferenceGroupObjects)
{
if (_group.ReferenceGameObject == null)
{
continue;
}
if (_register.RegisterDebug.ShowReferenceGizmos && !_group.Status.isPrefab)
{
Gizmos.color = new Color(_register.RegisterDebug.ColorReferences.r, _register.RegisterDebug.ColorReferences.g, _register.RegisterDebug.ColorReferences.b, 0.25f);
Vector3 _pos = _group.ReferenceGameObject.transform.position;
float _size = Mathf.Clamp(_group.ReferenceGameObject.transform.lossyScale.magnitude, 0.25f, 1) * 0.25f;
Gizmos.DrawSphere(_pos, _size);
_pos.y += 2;
if (_register.RegisterDebug.ShowReferenceGizmosText)
{
Gizmos.color = new Color(_register.RegisterDebug.ColorReferences.r, _register.RegisterDebug.ColorReferences.g, _register.RegisterDebug.ColorReferences.b, 1f);
CustomGizmos.Text(_group.ReferenceGameObject.name + " (SCENE REFERENCE)", _pos, Gizmos.color, 12, FontStyle.Italic);
}
}
if (_register.RegisterDebug.ShowCloneGizmos)
{
foreach (GameObject _item in _group.ActiveObjects)
{
if (_group.ReferenceGameObject == _item)
{
continue;
}
Gizmos.color = new Color(_register.RegisterDebug.ColorClones.r, _register.RegisterDebug.ColorClones.g, _register.RegisterDebug.ColorClones.b, 0.25f);
Vector3 _pos = _item.transform.position;
float _size = Mathf.Clamp(_item.transform.lossyScale.magnitude, 0.25f, 1) * 0.25f;
Gizmos.DrawSphere(_pos, _size);
if (_register.RegisterDebug.ShowCloneGizmosText)
{
_pos.y += 2;
Gizmos.color = new Color(_register.RegisterDebug.ColorClones.r, _register.RegisterDebug.ColorClones.g, _register.RegisterDebug.ColorClones.b, 1f);
CustomGizmos.Text(_item.name + " (CLONE)", _pos, Gizmos.color, 12, FontStyle.Italic);
}
}
}
if (_register.RegisterDebug.ShowSpawnPointGizmos && _group.PoolManagementEnabled)
{
foreach (SpawnPointObject _point in _group.ValidSpawnPoints)
{
if (_point.SpawnPointGameObject == null)
{
continue;
}
GameObject[] _objects = _point.GetAllSpawnPointGameObjects();
foreach (GameObject _object in _objects)
{
Gizmos.color = new Color(_register.RegisterDebug.ColorSpawnPoints.r, _register.RegisterDebug.ColorSpawnPoints.g, _register.RegisterDebug.ColorSpawnPoints.b, 0.25f);
Vector3 _pos = _object.transform.position;
float _size = Mathf.Clamp(_object.transform.lossyScale.magnitude, 0.25f, 1) * 0.25f;
Gizmos.DrawSphere(_pos, _size);
if (_point.UseRandomRect)
{
CustomGizmos.Box(_object.transform, _point.RandomRect, new Vector3(0, _point.RandomRect.y * 0.5f, 0));
}
else
{
CustomGizmos.Circle(_pos, _point.SpawningRangeMin, CustomGizmos.GetBestDegrees(_point.SpawningRangeMin, 360), false);
CustomGizmos.BeamCircle(_pos, _point.SpawningRangeMax, CustomGizmos.GetBestDegrees(_point.SpawningRangeMax, 360), false, _point.SpawningRangeMax - _point.SpawningRangeMin, "", false, true);
}
if (_register.RegisterDebug.ShowSpawnPointGizmosText)
{
_pos.z += _point.SpawningRangeMax;
_pos.y += 4;
Gizmos.color = new Color(_register.RegisterDebug.ColorSpawnPoints.r, _register.RegisterDebug.ColorSpawnPoints.g, _register.RegisterDebug.ColorSpawnPoints.b, 1f);
CustomGizmos.Text(_point.SpawnPointGameObject.name + " (SP)", _pos, Gizmos.color, 12, FontStyle.Italic);
}
}
}
}
}
}
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 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 );
}
}
}
}
/// <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";*/
}
}
/// <summary>
/// Draws a rotating circle
/// </summary>
private void Circle()
{
Vector3 currentDirection = Quaternion.AngleAxis(currentAngle, new Vector3(-1, 0, 1).normalized) * Vector3.up;
CustomGizmos.DrawRegularPoligon(new Vector3(5, 0, 4), Vector3.right, circleRadius, 30, currentDirection);
}
protected static void DrawGizmoStringTopRight(string text, Color color)
{
CustomGizmos.drawUIString(text, new Vector3(Screen.width - 100, Screen.height - 100, 0), color);
}
/// <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);
}
}
}
/// <summary>
/// Calculates and draws bezier curves
/// </summary>
private void Bezier()
{
CustomGizmos.Bezier(new Vector3(1, 0, 2), new Vector3(.5f, 0, 3), new Vector3(0, 0, 2), 10);
CustomGizmos.CubicBezier(new Vector3(1, 0, 3), new Vector3(.5f, 0, 4), new Vector3(0, 0, 3), new Vector3(-1, 0, 4), 10);
}
/// <summary>
/// Calculates and draws an H gizmo
/// </summary>
private void HGizmo()
{
Vector3 currentDirection = Quaternion.AngleAxis(currentAngle, Vector3.forward) * Vector3.up;
CustomGizmos.DrawH(new Vector3(2, 0, 2), new Vector3(2, 0, 3), arrowTipSize, currentDirection);
}
/// <summary>
/// Calculates and draws line arrows
/// </summary>
private void LineArrow()
{
Vector3 currentDirection = Quaternion.AngleAxis(currentAngle, Vector3.forward) * Vector3.up;
CustomGizmos.DrawLineArrow(new Vector3(2, 0, 0), new Vector3(2, 0, 1), arrowTipSize, (sinParam + 1) / 2, currentDirection);
}