protected override void Action(AIBehaviors fsm)
{
Vector3 targetPoint = patrolPoints[currentPatrolPoint].position;
Vector3 thisPos = fsm.transform.position;
fsm.MoveAgent(targetPoint, movementSpeed, rotationSpeed);
if ( (thisPos - targetPoint).sqrMagnitude < pointDistanceThreshold * pointDistanceThreshold )
{
currentPatrolPoint += patrolDirection;
// Check for once, loop, ping pong, clamp forever
if ( patrolMode == PatrolMode.Loop )
{
currentPatrolPoint %= patrolPoints.Length;
}
else if ( patrolMode == PatrolMode.PingPong )
{
if ( patrolDirection == 1 && currentPatrolPoint == patrolPoints.Length )
{
currentPatrolPoint = patrolPoints.Length - 1;
patrolDirection = -1;
}
else if ( currentPatrolPoint == 0 )
{
currentPatrolPoint = 0;
patrolDirection = 1;
}
}
}
}
public bool HandleEvaluate(AIBehaviors fsm)
{
if ( !this.enabled )
return false;
return Evaluate(fsm);
}
protected override void Action(AIBehaviors fsm)
{
Transform target = fsm.GetClosestPlayer();
if ( target != null )
{
fsm.RotateAgent(target, rotationSpeed);
}
AIBehaviorsAnimationState animState = fsm.animationStates.GetStateWithName(attackAnimName);
fsm.PlayAnimation(animState);
if ( scriptWithAttackMethod != null )
{
if ( !string.IsNullOrEmpty(methodName) )
{
if ( attackAnimation != null && attackAnimation[attackAnimName] != null )
{
float curAnimPosition = attackAnimation[attackAnimName].normalizedTime % 1.0f;
if ( previousSamplePosition > attackPoint || curAnimPosition < attackPoint )
{
previousSamplePosition = curAnimPosition;
return;
}
previousSamplePosition = curAnimPosition;
}
scriptWithAttackMethod.SendMessage(methodName, new AIBehaviors_AttackData(attackDamage));
fsm.PlayAudio();
}
}
}
protected override void Action(AIBehaviors fsm)
{
if ( targetItem != null )
{
fsm.MoveAgent(targetItem, movementSpeed, rotationSpeed);
}
}
protected override bool Reason(AIBehaviors fsm)
{
Transform sightedPlayer;
float closestPlayerDistance = Mathf.Infinity;
sightedPlayer = fsm.GetClosestPlayerWithinSight(out closestPlayerDistance, false);
if ( sightedPlayer != null )
{
float sqrStartChaseDistance = startChaseDistance * startChaseDistance;
float sqrBreakChaseDistance = breakChaseDistance * breakChaseDistance;
if ( closestPlayerDistance > sqrBreakChaseDistance )
{
curFollowMode = FollowMode.Normal;
}
else if ( closestPlayerDistance < sqrStartChaseDistance )
{
curFollowMode = FollowMode.Chase;
}
lastSightedPlayer = sightedPlayer;
lastSightedPlayerLocation = lastSightedPlayer.position;
}
else
lastSightedPlayer = null;
return true;
}
public bool GetRandomResult(AIBehaviors fsm, out BaseState resultState, float randomValue)
{
resultState = null;
if ( states.Length > 0 )
{
float totalWeight = 1.0f;
for ( int i = 0; i < states.Length; i++ )
{
if ( randomValue > totalWeight - weights[i] )
{
resultState = states[i];
return true;
}
totalWeight -= weights[i];
}
resultState = states[states.Length - 1];
return true;
}
else
{
Debug.LogWarning("The 'Go To Random State Trigger' requires at least 1 possible state!");
}
return false;
}
public static BaseState DrawEnabledStatePopup(AIBehaviors fsm, BaseState curState)
{
List<string> statesList = new List<string>();
Dictionary<string, BaseState> statesDictionary = new Dictionary<string, BaseState>();
BaseState[] states = fsm.GetAllStates();
string[] stateSelections;
int selection = 0;
// Get the state names
for ( int i = 0; i < fsm.stateCount; i++ )
{
// Should we include state i in the list?
if ( states[i].isEnabled )
{
string stateName = states[i].name;
statesList.Add(stateName);
statesDictionary[stateName] = states[i];
if ( states[i] == curState )
{
selection = statesList.Count-1;
}
}
}
stateSelections = statesList.ToArray();
selection = EditorGUILayout.Popup(selection, stateSelections);
return statesDictionary[stateSelections[selection]];
}
protected override void Action(AIBehaviors fsm)
{
Transform tfm = fsm.transform;
Vector3 position = tfm.position;
Quaternion rotation = tfm.rotation;
Instantiate(changeInto, position, rotation);
Destroy(fsm.gameObject);
}
protected override bool Evaluate(AIBehaviors fsm)
{
if ( CheckIfInPlayerCameraView(fsm.transform.position) )
{
fsm.ChangeActiveState(transitionState);
return true;
}
return false;
}
protected override bool Evaluate(AIBehaviors fsm)
{
if ( IsThresholdCrossed(fsm) )
{
fsm.ChangeActiveState(transitionState);
return true;
}
return false;
}
protected override bool Evaluate(AIBehaviors fsm)
{
if ( DidTimeExpire(Time.time) )
{
fsm.ChangeActiveState(transitionState);
return true;
}
return false;
}
protected override void DrawStateInspectorEditor(SerializedObject m_Object, AIBehaviors stateMachine)
{
SerializedObject m_State = new SerializedObject(this);
SerializedProperty m_Prop;
m_Prop = m_State.FindProperty("changeInto");
EditorGUILayout.PropertyField(m_Prop);
m_State.ApplyModifiedProperties();
}
protected override bool Evaluate(AIBehaviors fsm)
{
if ( fsm.GetClosestPlayerWithinSight(false) == null )
{
fsm.ChangeActiveState(transitionState);
return true;
}
return false;
}
protected override bool Evaluate(AIBehaviors fsm)
{
// Logic here, return true if the trigger was triggered
if ( Input.GetKeyDown(keycode) )
{
fsm.ChangeActiveState(transitionState);
return true;
}
return false;
}
// === Init === //
public void InitState(AIBehaviors fsm)
{
cooldowns = 0;
cooledDownTime = 0.0f;
lastActionTime = Time.time;
deltaTime = 0.0f;
InitTriggers();
Init(fsm);
PlayRandomAnimation(fsm);
}
protected override void StateEnded(AIBehaviors fsm)
{
fsm.isDefending = false;
if ( defensiveCallScript != null )
{
if ( !string.IsNullOrEmpty(endDefendMethodName) )
{
defensiveCallScript.SendMessage(endDefendMethodName, this);
}
}
}
protected override bool Evaluate(AIBehaviors fsm)
{
BaseState result = null;
if ( GetRandomResult(fsm, out result, Random.value) )
{
fsm.ChangeActiveState(result);
return true;
}
return false;
}
protected override bool Evaluate(AIBehaviors fsm)
{
bool myLogicIsTrue = false;
// Logic here, return true if the trigger was triggered
if ( myLogicIsTrue )
{
fsm.ChangeActiveState(transitionState);
return true;
}
return false;
}
protected override bool Reason(AIBehaviors fsm)
{
if ( Vector3.Distance(fsm.transform.position, helpPoint) < withinHelpPointDistance )
{
if ( helpPointReachedState != null )
{
fsm.ChangeActiveState(helpPointReachedState);
return false;
}
}
return true;
}
protected override void Init(AIBehaviors fsm)
{
fsm.isDefending = true;
if ( defensiveCallScript != null )
{
if ( !string.IsNullOrEmpty(startDefendMethodName) )
{
defensiveCallScript.SendMessage(startDefendMethodName, this);
}
}
fsm.PlayAudio();
}
protected override void Action(AIBehaviors fsm)
{
float speed = 0.0f;
if ( curFollowMode == FollowMode.Chase )
speed = chaseSpeed;
else
speed = movementSpeed;
if ( lastSightedPlayer != null )
fsm.MoveAgent(lastSightedPlayer, speed, rotationSpeed);
else
fsm.MoveAgent(lastSightedPlayerLocation, speed, rotationSpeed);
}
protected override void Init(AIBehaviors fsm)
{
Transform fsmTFM = fsm.transform;
Transform targetRotationTFM;
targetRotationObject = new GameObject("RotationTarget");
targetRotationTFM = targetRotationObject.transform;
targetRotationTFM.position = fsmTFM.position + fsmTFM.forward;
fsm.RotateAgent(targetRotationTFM, rotationSpeed);
targetRotationTFM.parent = fsmTFM;
fsm.PlayAudio();
}
public void DrawInspectorGUI(AIBehaviors fsm)
{
SerializedObject sObject = new SerializedObject(this);
SerializedProperty prop;
DrawInspectorProperties(sObject);
GUILayout.BeginHorizontal();
GUILayout.Label("Change to State:");
prop = sObject.FindProperty("transitionState");
prop.objectReferenceValue = AIBehaviorsStatePopups.DrawEnabledStatePopup(fsm, prop.objectReferenceValue as BaseState);
GUILayout.EndHorizontal();
sObject.ApplyModifiedProperties();
}
protected override void DrawStateInspectorEditor(SerializedObject m_Object, AIBehaviors stateMachine)
{
SerializedObject m_State = new SerializedObject(this);
SerializedProperty m_Prop;
m_Prop = m_State.FindProperty("withinHelpPointDistance");
EditorGUILayout.PropertyField(m_Prop);
EditorGUILayout.Separator();
GUILayout.Label("State when help point reached");
m_Prop = m_State.FindProperty("helpPointReachedState");
m_Prop.objectReferenceValue = AIBehaviorsStatePopups.DrawEnabledStatePopup(stateMachine, m_Prop.objectReferenceValue as BaseState);
m_State.ApplyModifiedProperties();
}
protected override bool Evaluate(AIBehaviors fsm)
{
float time = Time.time;
Transform target;
if ( SpeedExceededForTarget(out target, time) )
{
StartCoroutine(HandleSeekObject(target));
fsm.ChangeActiveState(transitionState);
return true;
}
timeTotal += time - previousCheckTime;
previousCheckTime = time;
return false;
}
void OnEnable()
{
BaseState[] states;
m_Object = new SerializedObject(target);
fsm = m_Object.targetObject as AIBehaviors;
transform = fsm.transform;
derivedStateNames = AIBehaviorsComponentInfoHelper.GetStateTypeNames();
curStateSelection = 0;
prevStateSelection = 0;
AIBehaviorsLegacy.UpgradeTriggers(fsm);
// Sorts old states and initializes new states
InitStates();
states = fsm.GetAllStates();
for ( int i = 0; i < fsm.stateCount; i++ )
{
states[i].OnInspectorEnabled(m_Object);
}
if ( EditorPrefs.HasKey(advancedModeKey) )
{
advancedMode = EditorPrefs.GetBool(advancedModeKey, false);
}
if ( EditorPrefs.HasKey(selectedStateKey) )
{
string stateName = EditorPrefs.GetString(selectedStateKey);
for ( int i = 0; i < states.Length; i++ )
{
if ( stateName == states[i].name )
{
curStateSelection = i;
prevStateSelection = i;
}
}
}
MarkStatesAsUpgraded();
}
protected override bool Evaluate(AIBehaviors fsm)
{
Transform[] tfms = fsm.GetPlayerTransforms();
Vector3 thisTFMPos = fsm.transform.position;
for ( int i = 0; i < tfms.Length; i++ )
{
Vector3 targetDir = tfms[i].position - thisTFMPos;
if ( targetDir.sqrMagnitude < distanceThreshold * distanceThreshold )
{
fsm.ChangeActiveState(transitionState);
return true;
}
}
return false;
}
public static void DrawGizmos(AIBehaviors fsm, int selectedState)
{
Transform transform = fsm.transform;
Vector3 position = transform.position;
Quaternion rotation = transform.rotation;
foreach ( BaseTrigger trigger in fsm.GetStateByIndex(selectedState).triggers )
{
Undo.SetSnapshotTarget(trigger, "Changes to Trigger");
trigger.DrawGizmos(position, rotation);
if ( GUI.changed )
{
EditorUtility.SetDirty(fsm.GetStateByIndex(selectedState));
}
}
}
protected override void DrawStateInspectorEditor(SerializedObject m_Object, AIBehaviors stateMachine)
{
SerializedProperty m_property = m_Object.FindProperty("newTag");
string resultTag;
GUILayout.BeginHorizontal();
{
GUILayout.Label("Change To Tag:");
resultTag = EditorGUILayout.TagField(newTag);
}
GUILayout.EndHorizontal();
if ( resultTag != newTag )
{
m_property.stringValue = resultTag;
}
m_Object.ApplyModifiedProperties();
}
protected override bool Reason(AIBehaviors fsm)
{
if ( targetItem == null )
{
GameObject[] gos = GameObject.FindGameObjectsWithTag(seekItemsWithTag);
Vector3 pos = fsm.transform.position;
Vector3 diff;
float nearestItem = Mathf.Infinity;
foreach ( GameObject go in gos )
{
Transform tfm = go.transform;
float sqrMagnitude;
diff = tfm.position - pos;
sqrMagnitude = diff.sqrMagnitude;
if ( sqrMagnitude < nearestItem )
{
targetItem = tfm;
nearestItem = sqrMagnitude;
}
}
}
else
{
float sqrDist = (fsm.transform.position - targetItem.position).sqrMagnitude;
if ( sqrDist < sqrDistanceToTargetThreshold )
{
if ( destroyTargetWhenReached )
{
Destroy(targetItem.gameObject);
}
fsm.ChangeActiveState(seekTargetReachedState);
return false;
}
}
return true;
}
public override void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
car = animator.gameObject.GetComponent <AIBehaviors>();
}
public override bool IsThresholdCrossed(AIBehaviors fsm)
{
return(fsm.GetHealthValue() <= healthThreshold);
}
