private void OnSceneGUI()
{
PatrolPath path = (PatrolPath)target;
Handles.color = Color.yellow;
if (path.NumPoints > 0)
{
for (int i = 0; i < path.NumPoints; i++)
{
Vector2 newPos = Handles.FreeMoveHandle(path.pathPoints[i], Quaternion.identity, 0.25f, Vector2.zero, Handles.CylinderHandleCap);
if (path[i] != newPos)
{
Undo.RecordObject(path, "Move Path Point");
path[i] = newPos;
}
}
}
if (path.NumPoints > 1)
{
Handles.color = Color.green;
for (int i = 1; i < path.NumPoints; i++)
{
Handles.DrawLine(path[i - 1], path[i]);
}
if (path.loopPath)
{
Handles.DrawLine(path[path.NumPoints - 1], path[0]);
}
}
}
new public PatrolPath getShortestPath(IPoint src, IPoint dest, List <IPoint> availableTiles)
{
DistanceMap distMap = getDistanceMap(src);
PatrolPath reverse = new PatrolPath();
valuePoint vPrevious = new valuePoint();
List <IPoint> availableTilesCopy = availableTiles.GetRange(0, availableTiles.Count);
if (isPointInList(availableTiles, dest))
{
//Get last point, add to path,get next, add, etc
reverse.MyWaypoints.Add(dest);
vPrevious.p = dest;
while (!vPrevious.p.equals(src))
{
vPrevious = getPreviousInPath(getValuePoint(distMap.MyPoints, vPrevious.p),
availableTilesCopy, distMap.MyPoints);
if (vPrevious != null && vPrevious.p != null)
{
reverse.MyWaypoints.Add(vPrevious.p);
availableTilesCopy.Remove(availableTilesCopy.Find(delegate(IPoint p) { return(p.equals(vPrevious.p)); }));
}
else //Ran out of available points before reaching end
{
return(null);
}
}
//Reverse path
reverse.MyWaypoints.Reverse();
}
return(reverse);
}
public void OnSceneGUI()
{
PatrolPath path = target as PatrolPath;
if ((path.pathNodes == null) || (path.pathNodes.Length <= 0))
{
return;
}
Vector3[] worldPts = new Vector3[path.pathNodes.Length];
for (int i = 0; i < path.pathNodes.Length; i++)
{
worldPts[i] = path.transform.TransformPoint(path.pathNodes[i]);
worldPts[i] = Handles.FreeMoveHandle(worldPts[i], Quaternion.identity,
1.0f, Vector3.one, Handles.DotCap);
path.pathNodes[i] = path.transform.InverseTransformPoint(worldPts[i]);
}
Handles.DrawAAPolyLine(10.0f, worldPts);
if (GUI.changed)
{
EditorUtility.SetDirty(target);
}
}
protected void Awake()
{
_navMeshAgent = GetComponent <NavMeshAgent>();
_animator = GetComponent <Animator>();
_enemySight = GetComponent <EnemySight>();
_patrolPath = transform.parent.Find("Patrol Path")?.GetComponent <PatrolPath>();
StateData = new StateData
{
Animator = _animator,
Npc = gameObject,
EnemySight = _enemySight,
PatrolPath = _patrolPath,
NavMeshAgent = _navMeshAgent,
WalkSpeed = walkSpeed,
RunSpeed = runSpeed,
AccelerationFactor = accelerationFactor,
DecelerationFactor = decelerationFactor,
DestinationDistanceAccuracy = destinationDistanceAccuracy,
IsInDebugMode = debug,
IdleAtWaypoint = idleAtWaypoint,
MinIdleTime = minIdleTime,
MaxIdleTime = maxIdleTime,
CheckLastKnownPosition = checkLastKnownPosition
};
InitCustomStateMachineData();
}
public void DrawEnemyPatrol(PatrolPath path)
{
List <LineRenderer> patrolPathLines = new List <LineRenderer>();
for (int i = 0; i < path.pathPatrolGraphNode.Count - 1; i++)
{
PatrolManager.PatrolGraphNode node = path.pathPatrolGraphNode[i];
Vector3 from = new Vector3(path.pathPatrolGraphNode[i].pos.x, 3.0f, path.pathPatrolGraphNode[i].pos.z);
Vector3 to = new Vector3(path.pathPatrolGraphNode[i + 1].pos.x, 3.0f, path.pathPatrolGraphNode[i + 1].pos.z);
patrolLine[0].material = enemyPatrolMat;
patrolLine[0].enabled = true;
patrolLine[0].SetPosition(0, from);
patrolLine[0].SetPosition(1, to);
patrolPathLines.Add(patrolLine[0]);
patrolLine.RemoveAt(0);
if (!hasInPatrol.ContainsKey(path.pathPatrolGraphNode[i].pos))
{
hasInPatrol.Add(path.pathPatrolGraphNode[i].pos, new List <Vector3>());
}
hasInPatrol[path.pathPatrolGraphNode[i].pos].Add(path.pathPatrolGraphNode[i + 1].pos);
if (!hasInPatrol.ContainsKey(path.pathPatrolGraphNode[i + 1].pos))
{
hasInPatrol.Add(path.pathPatrolGraphNode[i + 1].pos, new List <Vector3>());
}
hasInPatrol[path.pathPatrolGraphNode[i + 1].pos].Add(path.pathPatrolGraphNode[i].pos);
}
patrolPathLineDic.Add(path, patrolPathLines);
}
// Use this for initialization
protected void Start()
{
enemiesSituation = GameObject.FindGameObjectWithTag("EnemyHandler").GetComponent <EnemiesSituation>();
health = GetComponent <Health>();
stateAction = Patrol;
patrolPath = GetComponent <PatrolPath>();
pathfinder = GetComponent <EnemyPathfinder>();
}
public override void OnInspectorGUI()
{
PatrolPath path = target as PatrolPath;
if ((path.pathNodes == null) || (path.pathNodes.Length <= 0))
{
path.pathNodes = new Vector3[2];
}
List <Vector3> ptList = new List <Vector3>(path.pathNodes);
List <Vector3> removeList = new List <Vector3>();
if (GUILayout.Button("Reset Rotation & Scale"))
{
for (int i = 0; i < ptList.Count; ++i)
{
ptList[i] = path.transform.TransformPoint(ptList[i]);
}
path.transform.localScale = Vector3.one;
path.transform.localRotation = Quaternion.identity;
for (int i = 0; i < ptList.Count; ++i)
{
ptList[i] = path.transform.InverseTransformPoint(ptList[i]);
}
}
for (int i = 0; i < ptList.Count; ++i)
{
EditorGUILayout.BeginHorizontal();
ptList[i] = EditorGUILayout.Vector3Field("" + 1, ptList[i]);
if (GUILayout.Button("-", GUILayout.Width(20)))
{
removeList.Add(ptList[i]);
}
EditorGUILayout.EndHorizontal();
}
if (GUILayout.Button("Add Point"))
{
Vector3 newPt = ptList[ptList.Count - 1] + Vector3.one;
ptList.Add(newPt);
}
while (removeList.Count > 0)
{
ptList.Remove(removeList[0]);
removeList.RemoveAt(0);
}
if (GUI.changed)
{
path.pathNodes = ptList.ToArray();
EditorUtility.SetDirty(target);
}
}
private void Start()
{
if (m_canMove)
{
m_path = GetComponent <PatrolPath>();
m_destination = m_path.GetPathNodeByIndex(0);
StartCoroutine(UpdateDestination());
}
}
private static void OnDrawGizmo(PatrolPath path, GizmoType gizmoType)
{
var start = path.transform.TransformPoint(path.startPosition);
var end = path.transform.TransformPoint(path.endPosition);
Handles.color = Color.yellow;
Handles.DrawDottedLine(start, end, 5);
Handles.DrawSolidDisc(start, path.transform.forward, 0.1f);
Handles.DrawSolidDisc(end, path.transform.forward, 0.1f);
}
public Enemy SpawnEnemyInPatrol(PatrolPath path, PatrolManager patrolManager)
{
Debug.Log("spppppppppppppppppawn ");
Enemy enemy = freeEnemy[0];
freeEnemy.RemoveAt(0);
usedEnemy.Add(enemy);
enemy.SetPatrolPath(path, patrolManager);
return(enemy);
}
// Start is called before the first frame update
void Start()
{
fov = GetComponent <FieldOfView>();
path = GetComponent <PatrolPath>();
initialPosition = transform.position;
initialAngle = transform.eulerAngles.z;
Reset();
}
public void UpdateWaypoints(PatrolPath patrol)
{
patrol.waypoints = new Transform[patrol.transform.childCount];
int i = 0;
foreach (Transform t in patrol.transform)
{
patrol.waypoints[i++] = t;
}
}
static public List <Guard> getGuards(XmlDocument myDoc)
{
XmlNode positionNode, positionXNode, positionYNode,
patrolNode, wpXNode, wpYNode, orientationNode;
XmlNodeList guardNodes = myDoc.SelectNodes("Character"),
waypointNodes;
List <Guard> guards = new List <Guard>();
Guard _cGuard;
PatrolPath _cPath;
#region READ GUARDS TO LIST
if (guardNodes != null)
{
foreach (XmlNode g in guardNodes)
{
_cGuard = new Guard();
_cPath = new PatrolPath();
//Read Position
_cGuard.fromXml(g);
positionNode = ((XmlElement)g).SelectNodes("Position")[0];
positionXNode = ((XmlElement)positionNode).SelectNodes("X")[0];
positionYNode = ((XmlElement)positionNode).SelectNodes("Y")[0];
_cGuard.MyPosition = new PointObj(Int32.Parse(positionXNode.InnerText),
Int32.Parse(positionYNode.InnerText),
0);
//Read Patrol
//First, put guard position as first waypoint
_cPath.MyWaypoints.Add(_cGuard.MyPosition);
//Add rest of waypoints
patrolNode = ((XmlElement)g).SelectNodes("Patrol")[0];
if (patrolNode != null)
{
waypointNodes = ((XmlElement)patrolNode).SelectNodes("Waypoint");
foreach (XmlElement wp in waypointNodes)
{
wpXNode = wp.SelectNodes("X")[0];
wpYNode = wp.SelectNodes("Y")[0];
_cPath.MyWaypoints.Add(new PointObj(Int32.Parse(wpXNode.InnerText),
Int32.Parse(wpYNode.InnerText),
0));
}
}
//save patrol in guard
_cGuard.getNPCBehavior().setPatrol(_cPath);
//Add guard to list
guards.Add(_cGuard);
}
}
#endregion
return(guards);
}
public override void OnInspectorGUI()
{
PatrolPath myTarget = target as PatrolPath;
if (GUILayout.Button("Rebuild Path"))
{
myTarget.RebuildPath();
}
addNodeMode = EditorGUILayout.Toggle("Add Nodes Mode", addNodeMode);
this.DrawDefaultInspector();
}
public static PatrolWalkConfig Default(PatrolPath path, Transform trans)
{
return(new PatrolWalkConfig
{
path = path,
trans = trans,
circular = true,
forward = true,
nearDistance = 0.1f,
});
}
private void ShowPath(PatrolPath p, bool show)
{
foreach (var ob in p.waypoints)
{
if (ob == null)
{
continue;
}
ob.gameObject.SetActive(show);
}
}
private void DrawPatrol(PatrolPath p)
{
var waypoints = p.waypoints;
if (waypoints == null)
{
return;
}
Handles.color = p.color;
GUIStyle style = new GUIStyle();
style.normal.textColor = p.color;
var len = waypoints.Length;
if (len < 2)
{
return;
}
for (int i = 0; i < waypoints.Length; i++)
{
var next = i == len - 1 ? waypoints[0] : waypoints[i + 1];
var curr = waypoints[i];
if (curr != null && next != null)
{
string text;
if (showNames)
{
text = $" {i.ToString() } :: {curr.name}";
}
else
{
text = i.ToString();
}
Handles.DrawLine(curr.transform.position, next.transform.position);
Handles.SphereHandleCap(i, curr.transform.position, Quaternion.identity, 0.35f, EventType.Repaint);
if (showLabels)
{
Handles.BeginGUI();
Vector3 pos = curr.transform.position;
Vector2 pos2D = HandleUtility.WorldToGUIPoint(pos);
var rect = new Rect(pos2D.x + labelOffset.x, pos2D.y + labelOffset.y, 100, 100);
GUI.Label(rect, text, style);
Handles.EndGUI();
}
}
}
}
public PatrolState(Enemy owner, StateMachine <Enemy> fsm, PatrolPath patrolPath, float pauseTime = 0.0f)
: base(owner, fsm)
{
this.path = patrolPath;
this.seekStates = null;
this.currentTargetIndex = -1;
this.pauseTime = pauseTime;
this.patrolPauseTimer = pauseTime;
this.rotationSpeed = DEFAULT_ROTATION_SPEED;
this.rotationFov = DEFAULT_FOV;
this.stopped = false;
this.targetDirection = Owner.transform.forward;
}
// Start is called before the first frame update
void Start()
{
agent = GetComponent <NavMeshAgent>();
patrol = GetComponent <PatrolPath>();
fow = GetComponent <FieldOfView>();
line = GetComponent <LineRenderer>();
actions = GetComponent <Actions>();
animator = GetComponent <Animator>();
playerController = GetComponent <PlayerController>();
playerController.SetArsenal("AK-74M");
player = GameObject.Find("Player");
characterController = player.GetComponent <CharacterController>();
allEnemies = GameObject.FindGameObjectsWithTag("Enemy");
}
public PatrolPointArgs(
WhatHappenedType wht,
ActorData ad,
WayPoint pp,
int index,
PatrolPath inPath,
bool dwo)
{
whatHappened = wht;
characterActor = ad;
patrolPoint = pp;
patrolPointIndex = index;
patrolPath = inPath;
destinationWasOccupied = dwo;
}
public override void OnEnter()
{
base.OnEnter();
_waitTimer = new Timer(WaitTime.Value);
if (UsePath)
{
//if(PatrolPathGameObject.Value)
if (PatrolPathGameObject == null)
{
Finish();
return;
}
_path = PatrolPathGameObject.Value.GetComponent <PatrolPath>();
}
}
public PatrolWalk(PatrolWalkConfig c)
{
if (c.trans == null && c.IsNear == null)
{
Debug.LogError("Patrol walk needs transform or IsNear function");
}
last = c.path.waypoints.Length - 1;
startIndex = Mathf.Clamp(c.startIndex, 0, last);
IsNear = c.IsNear ?? DefaultIsNear;
wayIndex = startIndex;
path = c.path;
trans = c.trans;
nearDistance = c.nearDistance;
circular = c.circular;
forward = c.forward;
}
protected override void Initialize()
{
capsule = GetComponent <CapsuleCollider>();
patrol = GetComponent <PatrolPath>();
agent = GetComponent <DungeonNavAgent>();
lastSighting = GetComponent <LastPlayerSighting>();
State startState = null;
if (hasPatrolling)
{
startState = new AIStatePatrol(this);
}
else
{
startState = new AIStateIdle(this);
}
stateMachine.MoveTo(startState);
}
public void initFromSpawner(Spawner spawner)
{
endCondition = BehaviorChangeConditions.NA;
mySpawner = spawner;
currTgtWpIndex = 1;
isPostPath = false;
//Positionning enemy at the first waypoint's coordinates
if (mySpawner != null)
{
path = mySpawner.path;
rb.position = transform.position = path.wayPoints[0].position;
}
//Orienting enemy in the direction of the path, if there are more than one waypoints
//if (path.Length > 1)
//{
// transform.LookAt(path[currTargetIndex]);
// rb.rotation = transform.eulerAngles.z;
//}
}
public void OnSceneGUI()
{
Event current = Event.current;
int controlID = GUIUtility.GetControlID(this.GetHashCode(), FocusType.Passive);
switch (current.GetTypeForControl(controlID))
{
case EventType.MouseDown:
if (addNodeMode && current.button == 0)
{
GUIUtility.hotControl = controlID;
PatrolPath myTarget = target as PatrolPath;
Ray worldRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
RaycastHit hitInfo;
if (Physics.Raycast(worldRay, out hitInfo))
{
Vector3 loc = new Vector3(hitInfo.point.x, Mathf.Round(hitInfo.point.y), hitInfo.point.z);
PatrolNode node = Instantiate(myTarget.nodeType, loc, Quaternion.identity) as PatrolNode;
node.name = "Patrol Node (" + myTarget.Path.Count + ")";
node.transform.parent = myTarget.transform;
}
current.Use();
}
break;
case EventType.MouseUp:
if (addNodeMode && current.button == 0)
{
GUIUtility.hotControl = 0;
current.Use();
}
break;
}
if (GUI.changed)
{
EditorUtility.SetDirty(target);
}
}
public override void OnInspectorGUI()
{
PatrolPath path = (PatrolPath)target;
//Add a button that will add new waypoints
if (GUILayout.Button("Add Waypoint"))
{
//Call Start() on the path so its waypoint data is initialised
path.Start();
//Create the new object to house our waypoint
GameObject newWaypoint = new GameObject();
newWaypoint.name = "Waypoint" + path.Size();
newWaypoint.transform.parent = path.transform;
newWaypoint.transform.localPosition = Vector3.zero;
//Create the waypoint component instance
PatrolPathWaypoint waypoint = newWaypoint.AddComponent <PatrolPathWaypoint>();
waypoint.orderInSequence = path.Size();
//Add it to the path!
path.AddWaypoint(waypoint);
}
}
// Use this for initialization
void Start()
{
// Get access to the unit we are controlling
unit = GetComponent <Unit>();
// Install an on death function to remove all logic from the unit
unit.installDeathListener(delegate() { root = new Leaf(delegate() { return(BehaviorReturnCode.Success); }); });
////////////////////////////////////////////////////////////////////
///////////////////// PATROLLING/IDLE //////////////////////////
////////////////////////////////////////////////////////////////////
Leaf checkIsPatrolling = new Leaf(delegate()
{
if (unit.patrolling == false)
{
return(BehaviorReturnCode.Failure);
}
return(BehaviorReturnCode.Success);
});
Leaf patrolPath = new Leaf(delegate()
{
// Check if we have a patrol path to make use of
PatrolPath path = unit.GetComponent <PatrolPath>();
if (path != null)
{
unit.setDestination(path.patrolPointHolder.transform.GetChild(path.nextPatrolPoint()).position);
unit.patrolling = true;
return(BehaviorReturnCode.Success);
}
return(BehaviorReturnCode.Failure);
});
Leaf patrolArea = new Leaf(delegate()
{
// If we have a patrol area use that to find our random position
PatrolArea area = unit.GetComponent <PatrolArea>();
if (area == null)
{
return(BehaviorReturnCode.Failure);
}
// Generate our patrol position
Vector3 newTargetPosition = Vector3.zero;
Vector3 patrolPosition = area.patrolAreaObject.transform.position;
float patrolRange = area.patrolAreaObject.transform.localScale.x;
if (unit.findRandomPointOnNavMesh(patrolPosition, patrolRange, out newTargetPosition))
{
// Start moving towards our new random point
unit.setDestination(newTargetPosition);
unit.patrolling = true;
return(BehaviorReturnCode.Success);
}
return(BehaviorReturnCode.Failure);
});
Leaf manualPatrol = new Leaf(delegate()
{
// Check to see if the unit manually patrols
ManualPatrol manualPatrolling = unit.GetComponent <ManualPatrol>();
if (manualPatrolling == null)
{
return(BehaviorReturnCode.Failure);
}
// If the unit manually patrols wait for a new patrol position
if (manualPatrolling.getPatrolConsumed())
{
return(BehaviorReturnCode.Running);
}
// If we have a new patrol position consume it
unit.setDestination(manualPatrolling.getPatrolPosition());
unit.patrolling = true;
return(BehaviorReturnCode.Success);
});
Leaf patrolFollowLeader = new Leaf(delegate()
{
// Check to see if the unit has a leader to follow
FollowLeader leaderToFollow = unit.GetComponent <FollowLeader>();
if (leaderToFollow == null)
{
return(BehaviorReturnCode.Failure);
}
// If the unit has a leader follow it but don't start patrolling. This allows
// the unit to continuously follow the leader as it moves.
unit.setDestination(leaderToFollow.getFollowPosition());
return(BehaviorReturnCode.Success);
});
Leaf patrolRandom = new Leaf(delegate()
{
// If we don't have a defined path generate a random position
Vector3 patrolCenterPosition = transform.position;
float patrolRange = unit.patrolSearchRange;
Vector3 newTargetPosition = Vector3.zero;
// Generate our patrol position
if (unit.findRandomPointOnNavMesh(patrolCenterPosition, patrolRange, out newTargetPosition))
{
// Start moving towards our new random point
unit.setDestination(newTargetPosition);
unit.patrolling = true;
return(BehaviorReturnCode.Success);
}
return(BehaviorReturnCode.Failure);
});
Selector selectPatrolPath = new Selector(checkIsPatrolling, patrolPath, patrolArea, manualPatrol, patrolFollowLeader, patrolRandom);
Leaf sendPatrolToSquad = new Leaf(delegate()
{
SquadLeader squad = unit.GetComponent <SquadLeader>();
if (squad == null)
{
return(BehaviorReturnCode.Success);
}
// If the unit is part of a squad inform the subordinates of a new patrol position
squad.issueNewTroopMovement();
return(BehaviorReturnCode.Success);
});
Leaf waitToReachDestination = new Leaf(delegate()
{
if (unit.isMovingNavMesh() && unit.patrolling)
{
return(BehaviorReturnCode.Running);
}
// If the unit is a follower then don't bother waiting to reach a destination
else if (unit.GetComponent <FollowLeader>() != null)
{
return(BehaviorReturnCode.Failure);
}
else
{
return(BehaviorReturnCode.Success);
}
});
Leaf stopRunning = new Leaf(delegate()
{
unit.anim.SetBool("Running", false);
unit.agent.isStopped = true;
return(BehaviorReturnCode.Success);
});
Leaf playIdleAnim = new Leaf(delegate()
{
unit.anim.SetTrigger("PatrolIdleAnim1Trigger");
return(BehaviorReturnCode.Success);
});
RandomBehavior idleRand = new RandomBehavior(.1f, playIdleAnim);
Timer playIdleAnimTimer = new Timer(1.0f, idleRand);
Leaf stopPatrolling = new Leaf(delegate()
{
unit.patrolling = false;
return(BehaviorReturnCode.Success);
});
Timer stopPatrollingTimer = new Timer(unit.patrolWaitTime, stopPatrolling);
StateSequence patrolLogic = new StateSequence(selectPatrolPath, sendPatrolToSquad, waitToReachDestination, stopRunning, playIdleAnimTimer, stopPatrollingTimer);
////////////////////////////////////////////////////////////////////
///////////////////// AGGRO/ATTACKING //////////////////////////
////////////////////////////////////////////////////////////////////
Leaf dropTargetLogic = new Leaf(delegate()
{
// If we don't have a target continue
if (unit.target == null)
{
return(BehaviorReturnCode.Success);
}
// If our target is dying search for a new one
if (unit.target.isUnitDying())
{
unit.target = null;
}
// If our target it outside of our aggro radius clear it
if (unit.distanceToTarget() > unit.enemySearchRadius)
{
unit.target = null;
}
return(BehaviorReturnCode.Success);
});
Leaf acquireTarget = new Leaf(delegate()
{
// If we already have a living target just return success
if (unit.target != null)
{
return(BehaviorReturnCode.Success);
}
// Search for the closest enemy
IUnit foundTarget = unit.findClosestTarget();
// If we were able to find a target return success, otherwise we failed
if (foundTarget != null)
{
// If we find a new target stop patrolling
unit.patrolling = false;
unit.target = foundTarget;
return(BehaviorReturnCode.Success);
}
else
{
return(BehaviorReturnCode.Failure);
}
});
Leaf checkToAttack = new Leaf(delegate()
{
// If we are already attacking continue
if (unit.attacking)
{
return(BehaviorReturnCode.Success);
}
// Check if our target is within the attack radius and isn't already dying
if (unit.distanceToTarget() <= unit.attackRadius)
{
// Face the target
Quaternion lookRot = Quaternion.LookRotation(unit.target.getGameObject().transform.position - unit.transform.position);
unit.transform.rotation = Quaternion.Euler(0, lookRot.eulerAngles.y, 0);
// Stop the navmesh agent
unit.agent.isStopped = true;
// Stop running
unit.anim.SetBool("Running", false);
// Play our attack animation
unit.anim.SetTrigger("AttackTrigger");
unit.attacking = true;
}
else
{
unit.attacking = false;
}
return(BehaviorReturnCode.Success);
});
Leaf moveToTarget = new Leaf(delegate()
{
// If we're still attacking wait to finish
if (unit.attacking == true)
{
return(BehaviorReturnCode.Success);
}
// Start moving towards our target
unit.setDestination(unit.target.getGameObject().transform.position);
return(BehaviorReturnCode.Success);
});
Sequence attackSequence = new Sequence(dropTargetLogic, acquireTarget, checkToAttack, moveToTarget);
////////////////////////////////////////////////////////////////////
////////////////////////// ROOT ////////////////////////////////
////////////////////////////////////////////////////////////////////
root = new Selector(attackSequence, patrolLogic);
}
void MoveNodesOnTransformChange(PatrolPath pp)
{
Vector3 delta = pp.transform.position - lastPosition;
for (int i = 0; i < pp.points.Count; i++)
{
pp.points[i].position = pp.points[i].position + delta;
}
lastPosition = pp.transform.position;
}
public void setPatrol(PatrolPath _patrol)
{
throw new NotImplementedException();
}
public override void InitializePatrolPath()
{
PatrolPath = _algorithm.CalculatePath(StartCell, _level.Map[8, 27], _level.Map);
PatrolPath.AddRange(_algorithm.CalculatePath(_level.Map[8, 27], _level.Map[12, 30], _level.Map));
PatrolPath.AddRange(_algorithm.CalculatePath(_level.Map[12, 30], StartCell, _level.Map));
}
public Mover(PatrolPath path, float speed)
{
this.path = path;
this.duration = (path.endPosition - path.startPosition).magnitude / speed;
this.startTime = Time.time;
}
public void Restart()
{
currentStep = 1;
linkedSpawnPath = null;
}
