public bool GetRandomNodeForLocation(string groupPath, TimeOfDay timeOfDay, out ActionNodeState nodeState)
{
bool foundNode = false;
nodeState = null;
List <ActionNodeState> nodeStates = null;
if (GetNodesForLocation(groupPath, out nodeStates))
{
List <int> numbersTried = new List <int> ();
//try random numbers until we have none left
while (numbersTried.Count <= nodeStates.Count)
{
int randomIndex = UnityEngine.Random.Range(0, nodeStates.Count);
//get another number that we haven't tried yet
while (numbersTried.Contains(randomIndex))
{
randomIndex = UnityEngine.Random.Range(0, nodeStates.Count);
}
numbersTried.Add(randomIndex);
//check to see if the node's time of day lines up
ActionNodeState checkState = nodeStates [randomIndex];
if (Flags.Check((uint)checkState.RoutineHours, (uint)timeOfDay, Flags.CheckType.MatchAny))
{
foundNode = true;
nodeState = checkState;
break;
}
}
}
return(foundNode);
}
public bool GetRandomNodeForLocation(string groupPath, Vector3 nearPoint, float range, out ActionNodeState nodeState)
{
bool foundNode = false;
nodeState = null;
List <ActionNodeState> nodeStates = null;
if (GetNodesForLocation(groupPath, out nodeStates))
{
List <int> numbersTried = new List <int> ();
//try random numbers until we have none left
while (numbersTried.Count <= nodeStates.Count)
{
int randomIndex = UnityEngine.Random.Range(0, nodeStates.Count);
//get another number that we haven't tried yet
while (numbersTried.Contains(randomIndex))
{
randomIndex = UnityEngine.Random.Range(0, nodeStates.Count);
}
numbersTried.Add(randomIndex);
//check to see if the node is in range
ActionNodeState checkState = nodeStates [randomIndex];
if (checkState.IsLoaded && Vector3.Distance(checkState.actionNode.transform.position, nearPoint) < range)
{
foundNode = true;
nodeState = checkState;
break;
}
}
}
return(foundNode);
}
public ActionNode SpawnActionNode(WIGroup group, ActionNodeState actionNodeState, Transform nodeParentTransform)
{
ActionNode actionNode = null;
if (!actionNodeState.IsLoaded)
{
GameObject newNodeGameObject = nodeParentTransform.gameObject.CreateChild(actionNodeState.FullName).gameObject;
actionNode = newNodeGameObject.AddComponent <ActionNode> ();
actionNode.State = actionNodeState;
//since we're spawning this in the chunk we have to apply the group's transforms to the node
actionNode.State.Transform.ApplyTo(actionNode.transform);
//now move it to the final point
actionNode.transform.parent = Transforms.Nodes;
actionNode.State.actionNode = actionNode;
}
else
{
actionNode = actionNodeState.actionNode;
}
//add the action node state to the lookup
actionNodeState.ParentGroupPath = group.Path;
List <ActionNodeState> nodeStates = null;
if (!NodeData.NodeStates.TryGetValue(group.Path, out nodeStates))
{
nodeStates = new List <ActionNodeState> ();
NodeData.NodeStates.Add(group.Path, nodeStates);
}
nodeStates.SafeAdd(actionNodeState);
return(actionNode);
}
public bool GetOrCreateNode(WIGroup group, Transform parentTransform, string nodeName, out ActionNodeState nodeState)
{
nodeState = null;
if (GetNode(nodeName, false, out nodeState))
{
return(true);
}
else
{
nodeState = new ActionNodeState();
nodeState.Name = nodeName;
SpawnActionNode(group, nodeState, parentTransform);
}
return(nodeState != null);
}
public bool GetNodes(List <string> actionNodeNames, bool skipReserved, List <ActionNodeState> nodeStates)
{
ActionNodeState nodeState = null;
bool foundAtLeastOne = false;
for (int i = 0; i < actionNodeNames.Count; i++)
{
if (GetNode(actionNodeNames [i], skipReserved, out nodeState))
{
nodeStates.Add(nodeState);
foundAtLeastOne = true;
}
}
return(foundAtLeastOne);
}
public static MotileAction Wait(ActionNodeState state)
{
MotileAction newAction = new MotileAction();
newAction.Type = MotileActionType.Wait;
if (state.IsLoaded)
{
newAction.LiveTarget = state.actionNode;
}
newAction.Target = new MobileReference(state.Name, state.ParentGroupPath);
newAction.Expiration = MotileExpiration.Never;
newAction.YieldBehavior = MotileYieldBehavior.YieldAndFinish;
newAction.IdleAnimation = state.IdleAnimation;
return(newAction);
}
public bool FindSuccessNode()
{
if (SuccessNode == null)
{
ActionNodeState successState = null;
if (ParentChunk.GetNode(State.SuccessActionNodeName, false, out successState))
{
SuccessNode = successState.actionNode;
if (SuccessNode == null)
{
//Debug.Log ("Couldn't find success node in " + name + " but it doesn't matter, still returning true");
return(false);
}
}
}
return(true);
}
public void CreateNodesAndTriggers()
{
foreach (KeyValuePair <string, KeyValuePair <string, string> > triggerStatePair in TriggerData.TriggerStates)
{
AddTrigger(triggerStatePair, Transforms.Triggers, false, false);
}
foreach (KeyValuePair <string, List <ActionNodeState> > actionNodeStateList in NodeData.NodeStates)
{
for (int i = 0; i < actionNodeStateList.Value.Count; i++)
{
ActionNodeState actionNodeState = actionNodeStateList.Value [i];
GameObject newNodeGameObject = Transforms.Nodes.gameObject.FindOrCreateChild(actionNodeState.FullName).gameObject;
ActionNode newNode = newNodeGameObject.GetOrAdd <ActionNode> ();
newNode.State = actionNodeState;
newNode.State.Transform.ApplyTo(newNode.transform);
newNode.State.actionNode = newNode;
newNode.State.ParentGroupPath = actionNodeStateList.Key;
}
}
}
public bool FindGuardNode()
{
if (GuardNode == null)
{
ActionNodeState guardNodeState = null;
if (ParentChunk.GetNode(State.GuardActionNodeName, false, out guardNodeState))
{
guardNodeState.OccupantIsDead = State.GuardIsDead;
GuardNode = guardNodeState.actionNode;
if (GuardNode == null)
{
//Debug.Log ("Couldn't get guard node from action node state, quitting in " + name);
return(false);
}
}
else
{
//Debug.Log ("Couldn't get guard node from parent chunk, quitting in " + name);
return(false);
}
}
return(true);
}
public bool GetNode(string actionNodeName, bool skipReserved, out ActionNodeState nodeState)
{
bool foundNode = false;
nodeState = null;
foreach (Transform nodeTransform in Transforms.Nodes)
{
if (nodeTransform.name.Contains(actionNodeName))
{
ActionNode actionNode = null;
if (nodeTransform.gameObject.HasComponent <ActionNode> (out actionNode) &&
actionNode.State.Name == actionNodeName)
{
if (!(skipReserved && actionNode.IsReserved))
{
nodeState = actionNode.State;
foundNode = true;
break;
}
}
}
}
return(foundNode);
}
public IEnumerator SpawnOverTime()
{
ActionNodeState nodeState = AvailableSpawnNodes [0];
if (State.SpawnBehindPlayer)
{
Vector3 nodeDirection = Vector3.zero;
float dot = 0f;
float leastDotSoFar = Mathf.Infinity;
for (int i = 0; i < AvailableSpawnNodes.Count; i++)
{
nodeDirection = (AvailableSpawnNodes [i].actionNode.Position - Player.Local.Position).normalized;
dot = Vector3.Dot(Player.Local.FocusVector, nodeDirection);
if (dot < leastDotSoFar)
{
leastDotSoFar = dot;
nodeState = AvailableSpawnNodes [i];
}
}
}
CurrentSpawnNode = nodeState.actionNode;
if (!string.IsNullOrEmpty(State.CustomSpeech))
{
//overrides node state's speech
nodeState.CustomSpeech = State.CustomSpeech;
}
if (!string.IsNullOrEmpty(State.CustomConversation))
{
//overrides node state's speech
nodeState.CustomConversation = State.CustomConversation;
}
//wait until we're ready to spawn
double waitUntil = Frontiers.WorldClock.AdjustedRealTime + State.SpawnDelay;
while (Frontiers.WorldClock.AdjustedRealTime < waitUntil)
{
yield return(null);
}
//then boom! go
if (!Characters.GetOrSpawnCharacter(CurrentSpawnNode, State.CharacterName, ParentChunk.AboveGroundGroup, out SpawnedCharacter))
{
Debug.Log("Couldn't spawn character");
}
else
{
if (!string.IsNullOrEmpty(State.DTSOnSpawn))
{
if (!State.DTSFirstTimeOnly || State.NumTimesTriggered < 2)
{
Talkative talkative = null;
if (SpawnedCharacter.worlditem.Is <Talkative> (out talkative))
{
talkative.SayDTS(State.DTSOnSpawn);
SpawnedCharacter.LookAtPlayer();
}
}
}
}
mSpawningOverTime = false;
yield break;
}
public static bool StartAction(Motile m, MotileAction action)
{
//Debug.Log("trying to start action");
//open up the door for mod-supplied delegtates
//do some general cleanup - if we're starting an action, we want to start from scratch
if (m.GoalObject == null)
{
Debug.Log("Goal object is null, action was cancelled");
action.Cancel();
return(true);
}
if (!GetUpdateCoroutine(m, action))
{
Debug.Log("Couldn't get coroutine");
action.Cancel();
return(true);
}
//reset this just in case
m.AvoidingObstacle = false;
m.GoalObject.parent = m.worlditem.Group.transform;
m.GoalObject.position = m.LastKnownPosition; // + transform.forward;
//m.rvoController.PositionLocked = false;
//m.rvoController.RotationLocked = false;
m.TargetMovementSpeed = 0.0f;
m.CurrentRotationChangeSpeed = m.State.MotileProps.RotationChangeSpeed;
//get the default pathfinding method
action.Method = GetDefaultGoToMethod(m.State.MotileProps.DefaultGoToMethod, action.Method);
//okay, now handle the new action
if (action.State != MotileActionState.Waiting || !action.ResetAfterInterrupt) //if we're NOT resuming OR we're supposed to reset on resuming
{
action.WTStarted = WorldClock.AdjustedRealTime;
}
bool started = false;
switch (action.Type)
{
case MotileActionType.FocusOnTarget:
case MotileActionType.FollowRoutine:
started = true;
break;
case MotileActionType.FollowGoal:
if (action.HasLiveTarget)
{
//goal objects can be moved externally
//so we don't need a live target
m.GoalObject.position = action.LiveTarget.Position;
}
started = true;
break;
case MotileActionType.FleeGoal:
if (action.HasLiveTarget)
{
m.GoalObject.position = action.LiveTarget.Position;
}
started = true;
break;
case MotileActionType.WanderIdly:
m.GoalObject.position = m.worlditem.Position;
started = true;
break;
case MotileActionType.FollowTargetHolder:
if (!action.HasLiveTarget)
{
//TODO get live target?
}
if (action.HasLiveTarget)
{
m.GoalHolder = action.LiveTarget.gameObject.GetOrAdd <RVOTargetHolder> ();
}
else
{
m.GoalHolder = action.LiveTargetHolder;
}
started = true;
break;
case MotileActionType.GoToActionNode:
//wait a tick to let the live target load
if (m.LastOccupiedNode != null)
{
m.LastOccupiedNode.VacateNode(m.worlditem);
}
if (!action.HasLiveTarget)
{
//get live target
ActionNodeState nodeState = null;
}
started = true;
break;
case MotileActionType.Wait:
default:
m.TargetMovementSpeed = 0.0f;
started = true;
break;
}
if (started)
{
if (action.State != MotileActionState.Error) //preserve the error
{
action.State = MotileActionState.Started;
}
//send messages
action.OnStartAction.SafeInvoke();
action.OnStartAction = null;
}
return(started);
}
