Discussion DumbGOAP AI

Abbrew · Aug 7, 2023

A common approach to structuring AI with DOTS is Behavior Trees, which works well for very complex AIs. However, the tradeoff is a potentially non DOTS-friendly design where many different entities representing BT nodes must constantly be randomly accessed. An alternative design that provides performance while trading off a little readability and extensibility is a dumbed down version of GOAP, or DumbGOAP for short (I made this word up). The goal of DumbGOAP is to eliminate the unwieldiness of complex state machines while retaining the intelligent decisionmaking of Behavior Trees.

In DumbGOAP, overall AI behavior is grouped into an ordered list of Plans. Each Plan consists of a Condition and an Action. These Plans' Conditions are evaluated only during Decisions, which happen for an Actor at the start of the game, and every time the Actor finishes executing its latest Action. A simple example of a DumbGOAP AI for a Total War-style RTS game is, in the form of (Condition) (Action):
1. (If overly pressured by enemy) (Then flee the battlefield)
2. (If enemy nearby but not in melee range) (Then move towards enemy)
3. (If enemy in melee range) (Then attack enemy)
4. (If out of formation) (Then adhere to formation)
5. (By default) (Then stand around doing nothing)

First, an important concept in DumbGOAP is that each Plans' Conditions are evaluated in order of priority. So in that example, once an actor is ready to evaluate, it will first check if it's pressured. If so, it flees. Otherwise, it checks the next Condition and so on. A beneficial side effect is that early termination can eliminate unneeded calculations.

Second, once a Condition succeeds and its corresponding Action is chosen, the Decision logic won't run until the Action completes. In the case where the (Then attack enemy) Action is chosen in the example, the actor may spend 2 seconds in its attack animation, during which no costly Decision logic will run for it. The result is that unnecessary Decision calculations are avoided.

Next, you may realize that several useful constructs to flesh out AI behavior are missing. They, and their solutions, are:
1. Canceling an Action early: The solution is to have a Canceller execute every x seconds and if it succeeds, trigger another Decision immediately (make sure to run some cleanup logic on the cancelled Action!)
2. Executing something during an Action: The solution is to have a Duration execute every x seconds.

An example of an Action that can be enhanced by these two constructs is (Then flee the battlefield) from our example. There could be a Canceler (Cancel if no more enemies are nearby enough to threaten the actor) and a Duration (Constantly induce panic in your nearby allies). The result is a much more fleshed out Action.

Finally, one may ask "how is this different than or better than a state machine?" The answer is that DumbGOAP is, on a high level, no different than a state machine, yet at the same time is much better in scalability. In state machines, state is driven by an enum that represents the Action the Actor will take. Once an Actor is in a certain state/Action, it can only move onto a different state/Action that must be explicitly coded. However, in DumbGOAP, state/Action is driven on the fly by calculations done on the environment (which consists of the state of the Actor, other Actors, environment obstacles, etc), and can "transition" onto any other state/Action if the Decision logic allows for it. As a result, there is effectively only one "state" in DumbGOAP, which completely eliminates transition logic, which is the bane of complex state machines.

Now, you may have a few concerns about code implementation of this AI design. They are addressed thus:
1. Spaghetti code: admittedly, having a giant chain of if/else (we can't use switch because we're calculating booleans on if the Plan's Condition allows the Action) reeks of sphagetti code that makes it easy to make mistakes, and hard to read. This could be mitigated by carefully collapsing each Action execution under a #region. Further, actual execution of an Action could be refactored into a helper method for readability and reusability.
2. Parallelization: inevitably, within a single Actor entity, it will have to interact with other Actor entities which may involve Component/BufferLookups Read-Writes which in turn prevents parallelization. The solution is to relegate all Actor interactions to a separate single-threaded job that bears the brunt of all random access. To support this, the now-parallelizable Decision job will write to a NativeQueue<Damage/Stun/Intimidate/Buff>.ParallelWriter, and the Interaction job will process them with all the expensive Lookups it wants. Of course, this means that the parallelized Decision job will need support for common operations within itself. They are parallel pathfinding (you can nest NavMeshQuery inside of a NativeArray and access them with [NativeThreadIndex], provided that you label the NativeArray with [NativeDisableContainerSafetyRestriction] and [NativeDisableParallelForIForgotTheRest]) and querying for nearby other Actors (you can implement your own spatial partitioning)
3. Long running Actions: say an Actor must execute (Then adhere to formation) because it's too far away from its formation, but by the time it gets there, the formation has moved 100 meters away because its leading officer has moved. This unrealistic behavior would also happen in other long-running Actions, many of which have to do with following long paths. A simple solution is to terminate all long-running and looping Actions within X seconds, so that another Evaluate is triggered. This way, the Actor can recalculate its destination with more regularity and up-to-date accuracy. If it ends up doing the exact same Action, then the only harm done is a wasted Decision (which are still quite infrequent and inconsequential). If it ends up doing something else, then that's value gained because that something else is always smarter Decision. Make sure to not early terminate these long-running/looping behaviors too often, or else Decisions will happen too frequently!

In summary, DumbGOAP is suitable if:
1. Your Actor's AI can be described as "I don't care about the long-term future, I'll just keep doing what makes sense in the moment". Most likely huge-scale RTS games with simple-minded soldiers
2. The Actor interacts with other Actors based off of spatial queries (or any type of query that can be accessed from within a parallelized job), or by accessing its own components containing pre-defined Actor relationships

It's unsuitable if:
1. Your Actor's AI needs to follow careful long-term or multi-step schemes that necessitates storing complex state, in which case a state machine or even better a Behavior Tree is needed. Most suitable for small-scale RTS games where the less numerous Actors make up for it with much more complex and believable AI.

Abbrew · Aug 7, 2023

Here's a code dump of the singular parallelized Decision job, and the trick I used to get a parallel job to use NavMeshQuery. CritterInteractionInterface contains all the NativeQueue.ParallelWriter for interactions between Actors

Code (CSharp):

[UpdateAfter(typeof(PlayerMarionetteSystem))]

[UpdateInGroup(typeof(CollapseJobSystemGroup))]

[BurstCompile]

public partial struct CritterSystem : ISystem

{

private EnvironmentComponent _environment;

private NativeArray<CritterPathFinder> _pathfinders;

private NavMeshQuery _navMeshQuery;

private CritterInteractionInterface _interactions;

[BurstCompile]

public void OnUpdate(ref SystemState state)

{

var world = state.WorldUnmanaged;

var playerMarionette = world.GetSystem<PlayerMarionetteSystem>();

new CritterControlJob

{

ViewDirection = playerMarionette.ViewDirection,

OrderedToBeginRun = playerMarionette.OrderedToBeginRun,

OrderedToContinueRun = playerMarionette.OrderedToContinueRun,

RunDirection = playerMarionette.RunDirection,

OrderedToMeleeAttack = playerMarionette.OrderedToMeleeAttack,

OrderedToMeleeAttackWhileRunning = playerMarionette.OrderedToMeleeAttackWhileRunning,

OrderedToDodge = playerMarionette.OrderedToDodge,

OrderedToShove = playerMarionette.OrderedToShove,

OrderedToShoveWhileRunning = playerMarionette.OrderedToShoveWhileRunning,

OrderedToToggleMoveFormation = playerMarionette.OrderedToToggleMoveFormation,

OrderedToRally = playerMarionette.OrderedToRally,

OrderedToFlinchBreaker = playerMarionette.OrderedToFlinchBreaker,

DeltaSeconds = SystemAPI.Time.DeltaTime,

Interactions = _interactions

}.Schedule();

new CritterBehaviorJob

{

DeltaSeconds = SystemAPI.Time.DeltaTime,

ElapsedSeconds = SystemAPI.Time.ElapsedTime,

AppearanceTransforms = SystemAPI.GetSingletonBuffer<AppearanceTransformElement>(),

AppearanceCumulativeIndices = SystemAPI.GetSingletonBuffer<AppearanceCumulativeIndexElement>(),

Environment = _environment,

TacticalPlaces = SystemAPI.GetSingletonBuffer<TacticalGeographyPlaceElement>(true),

Proximities = SystemAPI.GetSingleton<CritterProximityGridComponent>().Data,

Pathfinders = _pathfinders,

NavMeshQuery = _navMeshQuery,

CollisionWorld = SystemAPI.GetSingleton<PhysicsWorldSingleton>().PhysicsWorld.CollisionWorld,

Interactions = _interactions

}.ScheduleParallel();

NavMeshWorld.GetDefaultWorld().AddDependency(state.Dependency);

}

[WithAll(typeof(CritterPlayerComponent))]

[BurstCompile]

private partial struct CritterControlJob : IJobEntity

{

public float2 ViewDirection;

public bool OrderedToBeginRun;

public bool OrderedToContinueRun;

public float2 RunDirection;

public bool OrderedToMeleeAttack;

public bool OrderedToMeleeAttackWhileRunning;

public bool OrderedToDodge;

public bool OrderedToShove;

public bool OrderedToShoveWhileRunning;

public bool OrderedToToggleMoveFormation;

public bool OrderedToRally;

public bool OrderedToFlinchBreaker;

public float DeltaSeconds;

[WriteOnly]

public CritterInteractionInterface Interactions;

public void Execute(

Entity critter,

in LocalTransform transform,

ref CritterStateComponent state,

in CritterActionComponent action,

ref CritterTimeRequiredComponent timeRequired,

ref CritterPlayerOrderComponent orders,

// Face Constantly

ref CritterDurationFaceConstantlyConfigurationComponent durationFaceConstantlyConfig,

// Formation Leader

in CritterFormationFollowerComponent followerComponent,

in DynamicBuffer<CritterFormationLeaderFollowerElement> followers

)

{

#region Injected Configurations

CritterDurationFaceConstantlyActions.AdjustAt(

ref durationFaceConstantlyConfig,

orders.ViewDirection

);

#endregion

#region Orders

var currentlyIdle =

CritterActions.IsDoing(action, CritterAction.PlanIdle)

& !CritterActions.IsDoing(action, CritterAction.DurationRun);

var currentlyRunning = CritterActions.IsDoing(action, CritterAction.DurationRun);

var currentlyMeleeAttacking = CritterActions.IsDoing(action, CritterAction.PlanMeleeAttack);

var orderedOtherThanRun =

OrderedToMeleeAttack

| OrderedToMeleeAttackWhileRunning;

orders.ViewDirection = ViewDirection;

var orderedToBeginRunDueToPendingContinueRun =

OrderedToContinueRun

& !orderedOtherThanRun

& currentlyIdle;

orders.OrderedToBeginRun = OrderedToBeginRun

| orderedToBeginRunDueToPendingContinueRun;

orders.OrderedToContinueRun =

OrderedToContinueRun

& currentlyRunning

& !orderedToBeginRunDueToPendingContinueRun

& !currentlyMeleeAttacking;

orders.RunDirection = RunDirection;

orders.OrderedToMeleeAttack = OrderedToMeleeAttack;

orders.OrderedToMeleeAttackWhileRunning = OrderedToMeleeAttackWhileRunning;

orders.OrderedToDodge = OrderedToDodge;

orders.OrderedToShove =

OrderedToShove

& state.Command >= state.ShoveCommandCost;

orders.OrderedToShoveWhileRunning =

OrderedToShoveWhileRunning

& state.Command >= state.ShoveCommandCost;

orders.OrderedToRally =

OrderedToRally

& state.Command >= state.RallyCommandCost;

orders.OrderedToFlinchBreaker =

OrderedToFlinchBreaker

& state.IsFlinching

& state.Command >= state.FlinchBreakerCommandCost;

if (Hint.Unlikely(OrderedToToggleMoveFormation))

{

orders.OrderedToMoveFormation = !orders.OrderedToMoveFormation;

}

state.CanVoluntarilyAct |= orders.OrderedToFlinchBreaker;

var orderedExplicitly =

orders.OrderedToBeginRun

| orders.OrderedToContinueRun

| orders.OrderedToMeleeAttack

| orders.OrderedToMeleeAttackWhileRunning

| orders.OrderedToShove

| orders.OrderedToShoveWhileRunning

| orders.OrderedToFlinchBreaker

| orders.OrderedToRally

| orders.OrderedToDodge;

if (Hint.Unlikely(state.CanVoluntarilyAct & orderedExplicitly))

{

CritterActions.Restart(ref timeRequired);

}

#endregion

}

}

public void Initialize(ref SystemState state)

{

_environment = SystemAPI.GetSingleton<EnvironmentComponent>();

var numThreads = JobsUtility.ThreadIndexCount;

_pathfinders = new NativeArray<CritterPathFinder>(numThreads, Allocator.Persistent);

for (var i = 0; i < numThreads; i++)

{

_pathfinders[i] = new CritterPathFinder(_environment, Allocator.Persistent);

}

_navMeshQuery = _environment.CreateNavMeshQuery();

_interactions = state.WorldUnmanaged.GetSystem<CritterInteractionSystem>().Interface;

}

public void OnDestroy(ref SystemState state)

{

foreach (var pathfinder in _pathfinders)

{

pathfinder.Dispose();

}

_pathfinders.Dispose();

_navMeshQuery.Dispose();

}

}

[WithOptions(EntityQueryOptions.IgnoreComponentEnabledState)]

[BurstCompile]

public partial struct CritterBehaviorJob : IJobEntity

{

public float DeltaSeconds;

public double ElapsedSeconds;

[NativeSetThreadIndex]

public int ThreadIndex;

[NativeDisableParallelForRestriction]

[WriteOnly]

public DynamicBuffer<AppearanceTransformElement> AppearanceTransforms;

[ReadOnly]

public DynamicBuffer<AppearanceCumulativeIndexElement> AppearanceCumulativeIndices;

public EnvironmentComponent Environment;

[ReadOnly]

public CollisionWorld CollisionWorld;

[ReadOnly]

public DynamicBuffer<TacticalGeographyPlaceElement> TacticalPlaces;

[ReadOnly]

public CritterProximityGrid Proximities;

[NativeDisableParallelForRestriction]

[NativeDisableContainerSafetyRestriction]

public NativeArray<CritterPathFinder> Pathfinders;

[ReadOnly]

public NavMeshQuery NavMeshQuery;

[WriteOnly]

public CritterInteractionInterface Interactions;

public void Execute(

// Critter

Entity critter,

ref LocalTransform transform,

ref CritterTimePassedComponent timePassed,

ref CritterTimeRequiredComponent timeRequired,

ref CritterPlayerOrderComponent orders,

ref CritterStateComponent state,

ref CritterActionComponent action,

ref CritterEventsRuntimeComponent eventsRuntime,

ref CritterTriggerComponent triggers,

// Diplomacy

in DiplomacySideComponent diplomacy,

// Appearance

in DynamicBuffer<CritterPartBodyElement> bodyParts,

in CritterPartBodyIdentifierPortalComponent identifierPortalPart,

in DynamicBuffer<CritterPartFormationVisualizerElement> formationVisualizerParts,

// Animation

EnabledRefRW<AnimationPlayComponent> playToggle,

ref AnimationPlayClipComponent clip,

EnabledRefRW<AnimationAdjustComponent> adjustToggle,

ref AnimationAdjustSpeedComponent adjust,

// Formation

in DynamicBuffer<CritterFormationLeaderFollowerElement> formationFollowers,

in CritterFormationFollowerComponent formationFollower,

// Idle

// Melee Attack

ref CritterPlanMeleeAttackConfigurationComponent planMeleeAttackConfig,

ref CritterPlanMeleeAttackRuntimeComponent planMeleeAttackRuntime,

ref DynamicBuffer<CritterPlanMeleeAttackEventsTimestampElement> planMeleeAttackEventsTimestamps,

ref DynamicBuffer<CritterPlanMeleeAttackEventsRuntimeTimestampElement> planMeleeAttackRuntimeTimestamps,

// Dodge

ref DynamicBuffer<CritterPlanDodgeEventsTimestampElement> planDodgeEventsTimestamps,

ref DynamicBuffer<CritterPlanDodgeEventsRuntimeTimestampElement> planDodgeRuntimeTimestamps,

// Follow Path

ref CritterPlanFollowPathConfigurationComponent planFollowPathConfig,

ref CritterPlanFollowPathRuntimeComponent planFollowPathRuntime,

ref DynamicBuffer<CritterPlanFollowPathRuntimeWaypointElement> planFollowPathWaypoints,

// Lead Followers

// Face Constantly

ref CritterDurationFaceConstantlyConfigurationComponent durationFaceConstantlyConfig,

// Run

ref CritterDurationRunConfigurationComponent durationRunConfig,

ref CritterDurationRunRuntimeComponent durationRunRuntime,

// Canceler Enemies In Range

ref CritterCancelerCritterInRangeConfigurationComponent cancelerCritterInRangeConfig,

// Canceler If Ping Dodge

ref CritterCancelerIfPingDodgeConfigurationComponent cancelerIfPingDodgeConfig,

// Canceler Melee Enemy Is Dodging

ref CritterCancelerMeleeEnemyIsDodgingConfigurationComponent cancelerMeleeEnemyIsDodgingConfig,

// Canceler After Time PAssed

ref CritterCancelerAfterTimeConfigurationComponent cancelerAfterTimeConfig

)

{

#region Appearance

#region Body Parts

foreach (var bodyPart in bodyParts.AsNativeArray())

{

var index = AppearanceCumulativeIndices[bodyPart.Part.PrototypeIndex].Value + bodyPart.Part.InstanceIndex;

AppearanceTransforms[index] = new AppearanceTransformElement

{

Value = transform.ToMatrix()

};

}

#endregion

#region Identifier Portal

if (Hint.Likely(identifierPortalPart.Visible && !state.Dead))

{

var index = AppearanceCumulativeIndices[identifierPortalPart.Part.PrototypeIndex].Value + identifierPortalPart.Part.InstanceIndex;

AppearanceTransforms[index] = new AppearanceTransformElement

{

Value = transform.ToMatrix()

};

}

else

{

var index = AppearanceCumulativeIndices[identifierPortalPart.Part.PrototypeIndex].Value + identifierPortalPart.Part.InstanceIndex;

AppearanceTransforms[index] = new AppearanceTransformElement

{

Value = float4x4.zero

};

}

#endregion

#region Formation

var numVisualizerParts = formationVisualizerParts.Length;

var followerRanks = new NativeList<float2>(Allocator.Temp);

CritterFormationActions.CreateRanks(formationFollower, followerRanks);

var followerRanksFast = followerRanks.AsArray();

var numRanks = followerRanks.Length;

var numPartsToVisualize = math.min(numVisualizerParts, numRanks);

var formationTransform = formationFollower.OfficerTransform;

var visualizerPartsFast = formationVisualizerParts.AsNativeArray();

for (var i = 0; i < numPartsToVisualize; i++)

{

var part = visualizerPartsFast[i];

var index = AppearanceCumulativeIndices[part.Part.PrototypeIndex].Value + part.Part.InstanceIndex;

var rankFormationLocation = followerRanksFast[i];

var rankLocation = formationTransform.TransformPoint(rankFormationLocation.WithY()).RemoveY();

EnvironmentQueries.WalkableHeightAt(Environment, CollisionWorld, rankLocation, out var raycastHit);

var rankHeight = raycastHit.Position.y;

var rankPosition = rankLocation.WithY(rankHeight);

AppearanceTransforms[index] = new AppearanceTransformElement

{

Value = formationTransform.WithPosition(rankPosition).ToMatrix()

};

}

for (var i = numPartsToVisualize; i < numVisualizerParts; i++)

{

var part = visualizerPartsFast[i];

var index = AppearanceCumulativeIndices[part.Part.PrototypeIndex].Value + part.Part.InstanceIndex;

AppearanceTransforms[index] = new AppearanceTransformElement

{

Value = float4x4.zero

};

}

#endregion

#endregion

#region Always

if (Hint.Unlikely(state.IsOrderable & orders.OrderedToMoveFormation))

{

ExecuteDurationLeadFollowers(

critter,

in transform,

in formationFollower,

in formationFollowers

);

}

#endregion

#region Evaluation

var random = this.Random(critter, ElapsedSeconds);

if (Hint.Unlikely(timePassed.Seconds > timeRequired.Seconds))

{

#region Mortality

if (Hint.Unlikely(state.Dead))

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleDead(

ref state,

ref action,

ref timeRequired,

playToggle,

ref clip,

state.DeadPoseDuration

);

goto execution;

}

if (Hint.Unlikely(state.Health <= 0))

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleDying(

ref state,

ref action,

ref timeRequired,

state.DyingDuration,

playToggle,

ref clip

);

goto execution;

}

#endregion

#region Triggers

if (Hint.Unlikely(Triggered(triggers)))

{

var trigger = triggers.Data;

Reset(ref triggers);

if (trigger == CritterTrigger.Flinch)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanFlinch(

ref action,

ref state,

ref timeRequired,

state.FlinchDuration,

playToggle,

ref clip,

state.FlinchDuration

);

goto execution;

}

if (trigger == CritterTrigger.Knockback)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleKnockback(

ref state,

ref action,

ref timeRequired,

state.KnockbackDuration,

playToggle,

ref clip,

state.KnockbackDuration

);

ActivateDurationRunKnockback(

transform,

ref action,

ref durationRunConfig,

state.KnockbackSpeed,

state.KnockbackSpeedRecurve,

ref durationRunRuntime

);

goto execution;

}

if (trigger == CritterTrigger.Dodge)

{

PositionActions.RotateTo(

ref transform,

state.TriggerDodgeDirection

);

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanDodge(

ref action,

ref eventsRuntime,

ref timeRequired,

state.DodgeInvulnerableLag,

state.DodgeVulnerableLag,

state.DodgeEndLag,

ref planDodgeRuntimeTimestamps,

playToggle,

ref clip

);

goto execution;

}

}

#endregion

#region Player

if (Hint.Unlikely(state.IsOrderable))

{

#region MeleeAttack

if (orders.OrderedToMeleeAttack)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackStrike(

ref action,

ref eventsRuntime,

ref timeRequired,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

state.MeleeTelegraphLag,

state.MeleeCommitmentLag,

state.MeleeStrikeLag,

state.MeleeEndLag,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

ActivateDurationFaceConstantlyAt(

ref action,

ref durationFaceConstantlyConfig

);

goto execution;

}

#endregion

#region MeleeAttackWhileRunning

if (orders.OrderedToMeleeAttackWhileRunning)

{

if (Hint.Unlikely(CritterSearchActions.FindNearbyEnemiesVulnerable(

Proximities,

critter,

diplomacy.Data,

transform.Location().Forward(state.MeleeAttackRange, transform.Rotation),

state.MeleeAttackRange,

out var enemiesInMeleeRange

)))

{

#region Chasedown Attack

enemiesInMeleeRange.OrderedByClosestTo(transform.Location());

foreach (var enemyInMeleeRange in enemiesInMeleeRange)

{

// Enemy is routing

if (Hint.Likely(enemyInMeleeRange.Routing))

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackStrike(

ref action,

ref eventsRuntime,

ref timeRequired,

state.ChasedownDuration,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

var directionOfEnemy =

enemyInMeleeRange.Location

- transform.Location();

ActivateDurationRun(

ref action,

ref durationRunConfig,

state.ChasedownAttackMoveSpeed,

state.ChasedownSpeedRecurve,

directionOfEnemy,

ref durationRunRuntime

);

ActivateDurationFaceConstantlyTowards(

ref action,

ref durationFaceConstantlyConfig,

enemyInMeleeRange.Entity

);

goto execution;

}

}

#endregion

}

#region Directioned Attack

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackStrike(

ref action,

ref eventsRuntime,

ref timeRequired,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

state.MeleeTelegraphLag,

state.MeleeCommitmentLag,

state.MeleeStrikeLag,

state.MeleeEndLag,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

goto execution;

#endregion

}

#endregion

#region Dodge

if (orders.OrderedToDodge)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanDodge(

ref action,

ref eventsRuntime,

ref timeRequired,

state.DodgeInvulnerableLag,

state.DodgeVulnerableLag,

state.DodgeEndLag,

ref planDodgeRuntimeTimestamps,

playToggle,

ref clip

);

goto execution;

}

#endregion

#region Shove

if (orders.OrderedToShove)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackShove(

ref action,

ref eventsRuntime,

ref timeRequired,

state.ShoveDuration,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

ActivateDurationFaceConstantlyAt(

ref action,

ref durationFaceConstantlyConfig

);

goto execution;

}

#endregion

#region ShoveWhileRunning

if (orders.OrderedToShoveWhileRunning)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackShove(

ref action,

ref eventsRuntime,

ref timeRequired,

state.ShoveDuration,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

goto execution;

}

#endregion

#region Rally

if (orders.OrderedToRally)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleRally(

critter,

transform,

ref state,

ref action,

ref timeRequired,

state.RallyDuration,

state.RallyCommandCost,

state.RallyAllyBuffAmount,

state.RallyAllyBuffRadius,

state.RallyEnemyDebuffAmount,

state.RallyEnemyDebuffRadius,

diplomacy.Data,

playToggle,

ref clip

);

goto execution;

}

#endregion

#region FlinchBreaker

if (orders.OrderedToFlinchBreaker)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivateIdleFlinchBreaker(

critter,

transform,

ref state,

ref action,

ref timeRequired,

state.FlinchBreakerDuration,

state.FlinchBreakerRange,

diplomacy.Data,

playToggle,

ref clip

);

}

#endregion

#region ContinueRun

if (orders.OrderedToContinueRun)

{

AdjustDurationRun(

ref durationRunConfig,

orders.RunDirection,

ref durationRunRuntime,

playToggle,

ref clip,

state.RunStrideDuration

);

PositionActions.RotateTo(

ref transform,

orders.RunDirection

);

ToggleDurationLeadFollowers(

ref action,

orders.OrderedToMoveFormation

);

goto execution;

}

#endregion

#region BeginRun

if (orders.OrderedToBeginRun)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleRun(

ref action,

ref timeRequired,

playToggle,

ref clip,

state.RunStrideDuration

);

ActivateDurationRun(

ref action,

ref durationRunConfig,

state.RunSpeed,

state.RunSpeedRecurve,

orders.RunDirection,

ref durationRunRuntime

);

PositionActions.RotateTo(

ref transform,

orders.RunDirection

);

ToggleDurationLeadFollowers(

ref action,

orders.OrderedToMoveFormation

);

goto execution;

}

#endregion

#region Idle

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleDillyDally(

ref action,

ref timeRequired,

playToggle,

ref clip,

state.IdleDillyDallyDuration

);

ActivateDurationFaceConstantlyAt(

ref action,

ref durationFaceConstantlyConfig

);

goto execution;

}

#endregion

}

#endregion

#region AI

else

{

#region Rout/Traumatized If Panicked, Or Stop Rout If Far Away Enough

#region Check If Panicking

if (Hint.Likely(!state.Routing && !state.Traumatized))

{

var panic = 0f;

#region Outnumbered

CritterSearchActions.FindNearbyAllies(

Proximities,

critter,

diplomacy.Data,

transform.Location(),

state.RoutPanicOutnumberedCheckRadius,

out var outnumberingAllies

);

CritterSearchActions.FindNearbyEnemies(

Proximities,

critter,

diplomacy.Data,

transform.Location(),

state.RoutPanicOutnumberedCheckRadius,

out var outnumberingEnemies

);

panic +=

(outnumberingEnemies.Length - outnumberingAllies.Length)

* state.RoutPanicPerOutnumbered;

#endregion

if (Hint.Unlikely(panic > state.RoutPanicThreshold))

{

state.Routing =

!TacticalPlaces.GetOccupiedTacticalPlaceAt(

diplomacy.Data,

transform.Location(),

out var _

)

& TacticalPlaces.FindSuitableTacticalPlaceAt(

diplomacy.Data,

transform.Location(),

out var suitablePlaceIndex

);

state.RoutingPlaceIndex = suitablePlaceIndex;

state.Traumatized = !state.Routing;

}

}

#endregion

#region Rout If Possible, Traumatized Otherwise

if (Hint.Unlikely(state.Routing))

{

if(Hint.Unlikely(

!CritterSearchActions.FindNearbyEnemies(

Proximities,

critter,

diplomacy.Data,

transform.Location(),

state.RoutSafetyRadius,

out var _

)

))

{

#region Stop Routing Because No Enemies Nearby

state.Routing = false;

#endregion

}

else

{

#region Attempt To Rout To Nearest Safe Place

if (Hint.Likely(

// Path is available

Pathfinders[ThreadIndex].Calculate(

transform.Location(),

TacticalPlaces[state.RoutingPlaceIndex].Location,

out var numWaypoints,

out var waypoints,

out var initialDirection

)

// No enemies initially blocking the direction

& !CritterSearchActions.FindNearbyEnemies(

Proximities,

critter,

diplomacy.Data,

transform.Location() + initialDirection.WithLength(state.BlockedForwardRadius),

state.BlockedForwardRadius,

out var _

))

)

{

#region Continue Routing

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanFollowPath(

ref action,

ref state,

ref timePassed,

ref timeRequired,

ref planFollowPathConfig,

state.RoutSpeed,

state.RoutSpeedRecurve,

Critter.NO_STRIDE,

ref planFollowPathRuntime,

ref planFollowPathWaypoints,

numWaypoints,

waypoints,

playToggle,

ref clip,

state.RoutStrideDuration

);

ActivateCancelerCritterInRangeForEnemy(

ref action,

ref cancelerCritterInRangeConfig,

state.StoppingForwardRadius,

state.StoppingCheckFrequency,

offset: state.StoppingForwardRadius.AsY()

);

goto execution;

#endregion

}

else

{

#region Surrender Because Routing Blocked

state.Routing = false;

state.Traumatized = true;

#endregion

}

#endregion

}

}

#endregion

#region Surrender Or Recover Because Traumatized

if (Hint.Unlikely(state.Traumatized))

{

if (Hint.Unlikely(

CritterSearchActions.FindNearbyEnemies(

Proximities,

critter,

diplomacy.Data,

transform.Location(),

state.RoutSafetyRadius,

out var _

)

))

{

#region Surrender Because Enemies Nearby

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleWait(

ref action,

ref timeRequired,

state.IdleDillyDallyDuration,

playToggle,

ref clip,

state.IdleDillyDallyDuration

);

goto execution;

#endregion

}

else

{

#region Recover because no enemies nearby

state.Traumatized = false;

#endregion

}

}

#endregion

#endregion

#region Return To Formation If Too Far Away

if (Hint.Unlikely(

(state.IsFormationFollower | state.IsFormationLeader)

& !formationFollower.OutOfFormation(transform.Location())

))

{

if (Hint.Unlikely(

// Path is available

Pathfinders[ThreadIndex].Calculate(

transform.Location(),

formationFollower.CenterLocation.DistanceAway(

transform.Location(),

formationFollower.FormationReturnWithinDistance

),

out var numWaypoints,

out var waypoints,

out var initialDirection

)

// No enemies initially blocking the direction

& !CritterSearchActions.FindNearbyEnemies(

Proximities,

critter,

diplomacy.Data,

transform.Location() + initialDirection.WithLength(state.BlockedForwardRadius),

state.BlockedForwardRadius,

out var _

))

)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanFollowPath(

ref action,

ref state,

ref timePassed,

ref timeRequired,

ref planFollowPathConfig,

state.RunSpeed,

state.RunSpeedRecurve,

state.RunStrideDistance,

ref planFollowPathRuntime,

ref planFollowPathWaypoints,

numWaypoints,

waypoints,

playToggle,

ref clip,

state.RunStrideDuration

);

PositionActions.RotateTo(

ref transform,

initialDirection

);

ActivateCancelerCritterInRangeForEnemy(

ref action,

ref cancelerCritterInRangeConfig,

state.StoppingForwardRadius,

state.StoppingCheckFrequency,

offset: state.StoppingForwardRadius.AsY()

);

goto execution;

}

}

#endregion

#region Melee Action Or Shove Because Vulnerable Enemy In Range

if (Hint.Unlikely(CritterSearchActions.FindNearbyEnemiesVulnerable(

Proximities,

critter,

diplomacy.Data,

transform.Location().Forward(state.MeleeAttackRange, transform.Rotation),

state.MeleeAttackRange,

out var enemiesInMeleeRange

)))

{

enemiesInMeleeRange.OrderedByClosestTo(transform.Location());

foreach(var enemyInMeleeRange in enemiesInMeleeRange)

{

// Enemy is not routing

if (Hint.Likely(!enemyInMeleeRange.Routing))

{

// enemy cannot be dodging and is aware of attacker

if (Hint.Likely(

!enemyInMeleeRange.IsDodgingInvulnerable

))

{

#region Fair Combat

if (Hint.Likely(CritterActions.WithinFieldOfVision(

transform.Location(),

enemyInMeleeRange.Rotation.ToDirection().RemoveY(),

enemyInMeleeRange.Location,

enemyInMeleeRange.MeleeAwarenessArc

)))

{

#region Face To Face Combat

if (Hint.Unlikely(state.Command >= state.ShoveCommandCost))

{

#region Shove

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackShove(

ref action,

ref eventsRuntime,

ref timeRequired,

state.ShoveDuration,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

ActivateDurationFaceConstantlyTowards(

ref action,

ref durationFaceConstantlyConfig,

enemyInMeleeRange.Entity

);

goto execution;

#endregion

}

else

{

#region Attack

var attackCumulativeProbability = state.MeleeAttackWeight;

var bideCumulativeProbability = state.MeleeBideWeight + attackCumulativeProbability;

var feintCumulativeProbability = state.MeleeFeintWeight + bideCumulativeProbability;

var preemptiveDodgeCumulativeProbability = state.MeleePreemptiveDodgeWeight + feintCumulativeProbability;

var meleeAttackRandom = random.NextFloat();

if (meleeAttackRandom < attackCumulativeProbability)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackStrike(

ref action,

ref eventsRuntime,

ref timeRequired,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

state.MeleeTelegraphLag,

state.MeleeCommitmentLag,

state.MeleeStrikeLag,

state.MeleeEndLag,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

ActivateDurationFaceConstantlyTowards(

ref action,

ref durationFaceConstantlyConfig,

enemyInMeleeRange.Entity

);

ActivateCancelerMeleeEnemyIsDodging(

ref action,

ref cancelerMeleeEnemyIsDodgingConfig,

state.PullBackReactionTime,

state.MeleeAttackRange,

state.MeleeAttackArc

);

goto execution;

}

#endregion

#region Bide

if (meleeAttackRandom < bideCumulativeProbability)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleWait(

ref action,

ref timeRequired,

state.MeleeBideDuration,

playToggle,

ref clip,

state.IdleDillyDallyDuration

);

ActivateCancelerIfPingDodge(

ref action,

ref cancelerIfPingDodgeConfig,

state.DodgeReactionTime

);

goto execution;

}

#endregion

#region Feint

if (meleeAttackRandom < feintCumulativeProbability)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackFeint(

ref action,

ref eventsRuntime,

ref timeRequired,

ref planMeleeAttackConfig,

state.MeleeTelegraphLag,

state.MeleeCommitmentLag,

state.MeleeStrikeLag,

state.MeleeEndLag,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

ActivateDurationFaceConstantlyTowards(

ref action,

ref durationFaceConstantlyConfig,

enemyInMeleeRange.Entity

);

ActivateCancelerIfPingDodge(

ref action,

ref cancelerIfPingDodgeConfig,

state.DodgeReactionTime

);

goto execution;

}

#endregion

#region Preemptive Dodge

if (meleeAttackRandom < preemptiveDodgeCumulativeProbability)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanDodge(

ref action,

ref eventsRuntime,

ref timeRequired,

state.DodgeInvulnerableLag,

state.DodgeVulnerableLag,

state.DodgeEndLag,

ref planDodgeRuntimeTimestamps,

playToggle,

ref clip

);

goto execution;

}

#endregion

}

#endregion

}

else

{

#region Backstab

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackStrike(

ref action,

ref eventsRuntime,

ref timeRequired,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

state.MeleeTelegraphLag,

state.MeleeCommitmentLag,

state.MeleeStrikeLag,

state.MeleeEndLag,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

ActivateDurationFaceConstantlyTowards(

ref action,

ref durationFaceConstantlyConfig,

enemyInMeleeRange.Entity

);

ActivateCancelerMeleeEnemyIsDodging(

ref action,

ref cancelerMeleeEnemyIsDodgingConfig,

state.PullBackReactionTime,

state.MeleeAttackRange,

state.MeleeAttackArc

);

goto execution;

#endregion

}

#endregion

}

// Enemy is dodging

else

{

#region VS Dodger

if (Hint.Likely(CritterActions.WithinFieldOfVision(

transform.Location(),

enemyInMeleeRange.Rotation.ToDirection().RemoveY(),

enemyInMeleeRange.Location,

enemyInMeleeRange.MeleeAwarenessArc

)))

{

#region Bide Because Enemy Dodging

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleWait(

ref action,

ref timeRequired,

state.MeleeBideDuration,

playToggle,

ref clip,

state.IdleDillyDallyDuration

);

ActivateCancelerIfPingDodge(

ref action,

ref cancelerIfPingDodgeConfig,

state.DodgeReactionTime

);

goto execution;

#endregion

}

else

{

#region Backstab

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackStrike(

ref action,

ref eventsRuntime,

ref timeRequired,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

state.MeleeTelegraphLag,

state.MeleeCommitmentLag,

state.MeleeStrikeLag,

state.MeleeEndLag,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

ActivateDurationFaceConstantlyTowards(

ref action,

ref durationFaceConstantlyConfig,

enemyInMeleeRange.Entity

);

ActivateCancelerMeleeEnemyIsDodging(

ref action,

ref cancelerMeleeEnemyIsDodgingConfig,

state.PullBackReactionTime,

state.MeleeAttackRange,

state.MeleeAttackArc

);

goto execution;

#endregion

}

#endregion

}

}

// Enemy is routing

else

{

#region Chasedown Attack

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanMeleeAttackStrike(

ref action,

ref eventsRuntime,

ref timeRequired,

state.ChasedownDuration,

ref planMeleeAttackConfig,

state.MeleeAttackDamage,

state.MeleeAttackRange,

state.MeleeAttackArc,

ref planMeleeAttackRuntime,

ref planMeleeAttackRuntimeTimestamps,

playToggle,

ref clip

);

var directionOfEnemy =

enemyInMeleeRange.Location

- transform.Location();

ActivateDurationRun(

ref action,

ref durationRunConfig,

state.ChasedownAttackMoveSpeed,

state.ChasedownSpeedRecurve,

directionOfEnemy,

ref durationRunRuntime

);

ActivateDurationFaceConstantlyTowards(

ref action,

ref durationFaceConstantlyConfig,

enemyInMeleeRange.Entity

);

goto execution;

#endregion

}

}

}

#endregion

#region Move To Enemy Or Backup Ally In Seek Range Within Melee Distance

if (CritterSearchActions.FindNearbyEnemies(

Proximities,

critter,

diplomacy.Data,

transform.Location().Forward(state.AggressionSeekForwardRadius, transform.Rotation),

state.AggressionSeekForwardRadius,

out var enemiesInRange

))

{

foreach (var enemyInRange in enemiesInRange.OrderedByClosestTo(transform.Location()))

{

// Enemy is not too far away

if (Hint.Likely(formationFollower.MaxEnemySeekDistance.DistanceWithin(

enemyInRange.Location,

formationFollower.CenterLocation

)))

{

// Path to within melee range of enemy exists

if (Pathfinders[ThreadIndex].Calculate(

transform.Location(),

enemyInRange.Location.DistanceAway(transform.Location(), state.MeleeEngagementRange),

out var numWaypoints,

out var waypoints,

out var initialDirection

))

{

// No one is in front

if (!CritterSearchActions.FindAnyone(

Proximities,

critter,

transform.Location() + initialDirection.WithLength(state.BlockedForwardRadius),

state.BlockedForwardRadius,

out var _

))

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanFollowPath(

ref action,

ref state,

ref timePassed,

ref timeRequired,

ref planFollowPathConfig,

state.RunSpeed,

state.RunSpeedRecurve,

state.RunStrideDistance,

ref planFollowPathRuntime,

ref planFollowPathWaypoints,

numWaypoints,

waypoints,

playToggle,

ref clip,

state.RunStrideDuration

);

PositionActions.RotateTo(

ref transform,

initialDirection

);

ActivateCancelerCritterInRangeForAnyone(

ref action,

ref cancelerCritterInRangeConfig,

state.StoppingForwardRadius,

state.StoppingCheckFrequency,

offset: state.StoppingForwardRadius.AsY()

);

goto execution;

}

// Someone is in front blocking the way

else if(Hint.Likely(

state.AggressionAllyBackupRange.DistanceWithin(

transform.Location(),

enemyInRange.Location

)

))

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleWait(

ref action,

ref timeRequired,

state.IdleDillyDallyDuration,

playToggle,

ref clip,

state.IdleDillyDallyDuration

);

AlignWithFormation(

ref transform,

formationFollower

);

goto execution;

}

}

}

}

}

#endregion

#region Move To And Chase Down Routing Enemy

if(Hint.Unlikely(CritterSearchActions.FindNearbyEnemiesRouting(

Proximities,

critter,

diplomacy.Data,

transform.Location().Forward(state.ChasedownForwardRadius, transform.Rotation),

state.ChasedownForwardRadius,

out var nearbyEnemyRouters

)))

{

nearbyEnemyRouters.OrderedByClosestTo(transform.Location());

foreach(var nearbyEnemyRouter in nearbyEnemyRouters)

{

// Enemy is not too far away

if (Hint.Unlikely(formationFollower.MaxEnemyChasedownDistance.DistanceWithin(

nearbyEnemyRouter.Location,

formationFollower.CenterLocation

)

// Path exists

& Pathfinders[ThreadIndex].Calculate(

transform.Location(),

nearbyEnemyRouter.Location.DistanceAway(transform.Location(), state.MeleeEngagementRangeMovingTarget),

out var numWaypoints,

out var waypoints,

out var initialDirection

)

// No one blocking the initial direction

& !CritterSearchActions.FindAnyone(

Proximities,

critter,

transform.Location() + initialDirection.WithLength(state.BlockedForwardRadius),

state.BlockedForwardRadius,

out var _

)

))

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanFollowPath(

ref action,

ref state,

ref timePassed,

ref timeRequired,

ref planFollowPathConfig,

state.ChasedownSpeed,

state.ChasedownSpeedRecurve,

state.ChasedownStrideDistance,

ref planFollowPathRuntime,

ref planFollowPathWaypoints,

numWaypoints,

waypoints,

playToggle,

ref clip,

state.ChasedownStrideDuration

);

PositionActions.RotateTo(

ref transform,

initialDirection

);

ActivateCancelerCritterInRangeForAnyone(

ref action,

ref cancelerCritterInRangeConfig,

state.StoppingForwardRadius,

state.StoppingCheckFrequency,

offset: state.StoppingForwardRadius.AsY()

);

goto execution;

}

}

}

#endregion

#region Return To Formation If No Ranks Nearby And Outside Of Combat

if (Hint.Unlikely(

// No occupied ranks nearby

!CritterFormationActions.OccupiedRank(

formationFollower,

transform.Location(),

out var _

)

))

{

if (Hint.Unlikely(

// Path is available

Pathfinders[ThreadIndex].Calculate(

transform.Location(),

formationFollower.CenterLocation.DistanceAway(

transform.Location(),

formationFollower.FormationReturnWithinDistance

),

out var numWaypoints,

out var waypoints,

out var initialDirection

)

// No enemy initially blocking the direction

& !CritterSearchActions.FindNearbyEnemies(

Proximities,

critter,

diplomacy.Data,

transform.Location() + initialDirection.WithLength(state.BlockedForwardRadius),

state.BlockedForwardRadius,

out var _

))

)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanFollowPath(

ref action,

ref state,

ref timePassed,

ref timeRequired,

ref planFollowPathConfig,

state.RunSpeed,

state.RunSpeedRecurve,

state.RunStrideDistance,

ref planFollowPathRuntime,

ref planFollowPathWaypoints,

numWaypoints,

waypoints,

playToggle,

ref clip,

state.RunStrideDuration

);

PositionActions.RotateTo(

ref transform,

initialDirection

);

ActivateCancelerCritterInRangeForEnemy(

ref action,

ref cancelerCritterInRangeConfig,

state.StoppingForwardRadius,

state.StoppingCheckFrequency,

offset: state.StoppingForwardRadius.AsY()

);

goto execution;

}

}

#endregion

#region Move Forward In Rank if Available

// Calculate current rank priority

var isOccupyingRank = CritterFormationActions.OccupiedRank(

formationFollower,

transform.Location(),

out var occupiedRank

);

var priorityToBeat = math.select(int.MinValue, occupiedRank.Priority, isOccupyingRank);

// Other ranks in front

if (Hint.Likely(

state.IsFormationFollower

& CritterFormationActions.SearchForRanks(

formationFollower,

transform.Location().Forward(

formationFollower.RankImprovementForwardRange,

formationFollower.OfficerTransform.Rotation

),

formationFollower.RankImprovementForwardRange.AsRadii(),

out var ranks

)

))

{

foreach (var rank in ranks.OrderByPriorityDecreasing())

{

if (Hint.Unlikely(

// Better priority

rank.Priority > priorityToBeat

// No allies occupying that rank

& !CritterSearchActions.FindNearbyAllies(

Proximities,

critter,

diplomacy.Data,

rank.Location,

formationFollower.RankImprovementOthersOccupancyRadius,

out var _

)

))

{

if (Hint.Unlikely(

// Path is available

Pathfinders[ThreadIndex].Calculate(

transform.Location(),

rank.Location,

out var numWaypoints,

out var waypoints,

out var initialDirection

)

// No one initially blocking the direction

& !CritterSearchActions.FindAnyone(

Proximities,

critter,

transform.Location() + initialDirection.WithLength(state.BlockedForwardRadius),

state.BlockedForwardRadius,

out var _

))

)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanFollowPath(

ref action,

ref state,

ref timePassed,

ref timeRequired,

ref planFollowPathConfig,

state.RunSpeed,

state.RunSpeedRecurve,

state.RunStrideDistance,

ref planFollowPathRuntime,

ref planFollowPathWaypoints,

numWaypoints,

waypoints,

playToggle,

ref clip,

state.RunStrideDuration

);

PositionActions.RotateTo(

ref transform,

initialDirection

);

ActivateCancelerCritterInRangeForAnyone(

ref action,

ref cancelerCritterInRangeConfig,

state.StoppingForwardRadius,

state.StoppingCheckFrequency,

offset: state.StoppingForwardRadius.AsY()

);

goto execution;

}

}

}

}

#endregion

#region Move Backwards In Rank If Front Congested

isOccupyingRank = CritterFormationActions.OccupiedRank(

formationFollower,

transform.Location(),

out occupiedRank

);

var priorityToUndercut = math.select(int.MaxValue, occupiedRank.Priority, isOccupyingRank);

if (Hint.Likely(

state.IsFormationFollower

// There are ranks behind

& CritterFormationActions.SearchForRanks(

formationFollower,

transform.Location().Backward(

formationFollower.RankRetreatIfCrowdedBackwardRange,

formationFollower.OfficerTransform.Rotation

),

formationFollower.RankRetreatIfCrowdedBackwardRange.AsRadii(),

out ranks

)

// Too many allies are around

& CritterSearchActions.FindNearbyAllies(

Proximities,

critter,

diplomacy.Data,

transform.Location(),

formationFollower.RankRetreatIfCrowdedCheckRange,

out var crowdingAllies

)

& crowdingAllies.Length > formationFollower.RankRetreatIfCrowdedThreshold

))

{

foreach (var rank in ranks.OrderByPriorityDecreasing())

{

if (Hint.Unlikely(

// Better priority

rank.Priority > priorityToUndercut

// No allies occupying that rank

& !CritterSearchActions.FindNearbyAllies(

Proximities,

critter,

diplomacy.Data,

rank.Location,

formationFollower.RankRetreatOthersOccupancyRadius,

out var _

)

))

{

if (Hint.Unlikely(

// Path is available

Pathfinders[ThreadIndex].Calculate(

transform.Location(),

rank.Location,

out var numWaypoints,

out var waypoints,

out var initialDirection

)

// No enemies initially blocking the direction

& !CritterSearchActions.FindAnyone(

Proximities,

critter,

transform.Location() + initialDirection.WithLength(state.BlockedForwardRadius),

state.BlockedForwardRadius,

out var _

))

)

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanFollowPath(

ref action,

ref state,

ref timePassed,

ref timeRequired,

ref planFollowPathConfig,

state.RunSpeed,

state.RunSpeedRecurve,

state.RunStrideDistance,

ref planFollowPathRuntime,

ref planFollowPathWaypoints,

numWaypoints,

waypoints,

playToggle,

ref clip,

state.RunStrideDuration

);

PositionActions.RotateTo(

ref transform,

initialDirection

);

ActivateCancelerCritterInRangeForAnyone(

ref action,

ref cancelerCritterInRangeConfig,

state.StoppingForwardRadius,

state.StoppingCheckFrequency,

offset: state.StoppingForwardRadius.AsY()

);

goto execution;

}

}

}

}

#endregion

#region Move Away From Ally If Crowded

if (CritterSearchActions.FindNearbyAllies(

Proximities,

critter,

diplomacy.Data,

transform.Location(),

state.PersonalSpaceIntrudedRadius,

out var alliesInPersonalSpace

))

{

foreach (var allyInPersonalSpace in alliesInPersonalSpace.OrderedByClosestTo(transform.Location()))

{

var awayFromAlly = allyInPersonalSpace.Location.DistanceTowards(

transform.Location(),

state.PersonalSpaceMoveAwayDistance

);

if (Pathfinders[ThreadIndex].Calculate(

transform.Location(),

awayFromAlly,

out var numWaypoints,

out var waypoints,

out var initialDirection

))

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanFollowPath(

ref action,

ref state,

ref timePassed,

ref timeRequired,

ref planFollowPathConfig,

state.RunSpeed,

state.RunSpeedRecurve,

state.RunStrideDistance,

ref planFollowPathRuntime,

ref planFollowPathWaypoints,

numWaypoints,

waypoints,

playToggle,

ref clip,

state.RunStrideDuration

);

PositionActions.RotateTo(

ref transform,

initialDirection

);

goto execution;

}

}

}

#endregion

#region Idle As Default

{

PrepareForPlan(

ref action,

ref state,

ref timePassed,

ref triggers

);

ActivatePlanIdleWait(

ref action,

ref timeRequired,

state.IdleDillyDallyDuration,

playToggle,

ref clip,

state.IdleDillyDallyDuration

);

AlignWithFormation(

ref transform,

formationFollower

);

goto execution;

}

#endregion

}

#endregion

}

else

{

timePassed.Seconds += DeltaSeconds;

}

#endregion

execution:

#region Stats

if (Hint.Unlikely(state.Rally != 0f))

{

var rallyChange = (DeltaSeconds * math.select(state.MoraleRallyRecovery, -state.MoraleRallyUsage, state.Rally > 0));

var newRally = state.Rally + rallyChange;

state.Rally = math.select(newRally, 0, newRally * state.Rally < 0);

}

#endregion

#region Plans

if (CritterActions.IsDoing(action, CritterAction.PlanIdle))

{

ExecutePlanIdle();

}

else if (CritterActions.IsDoing(action, CritterAction.PlanFollowPath))

{

ExecutePlanFollowPath(

ref transform,

ref timeRequired,

in planFollowPathConfig,

ref planFollowPathRuntime,

ref planFollowPathWaypoints

);

}

else if (CritterActions.IsDoing(action, CritterAction.PlanMeleeAttack))

{

ExecutePlanMeleeAttack(

critter,

in transform,

ref state,

ref eventsRuntime,

ref timeRequired,

in timePassed,

in diplomacy,

adjustToggle,

ref adjust,

in planMeleeAttackConfig,

in planMeleeAttackRuntime,

in planMeleeAttackEventsTimestamps,

in planMeleeAttackRuntimeTimestamps

);

}

else if (CritterActions.IsDoing(action, CritterAction.PlanDodge))

{

ExecutePlanDodge(

ref state,

ref eventsRuntime,

in timePassed,

adjustToggle,

ref adjust,

in planDodgeEventsTimestamps,

in planDodgeRuntimeTimestamps

);

}

else if (CritterActions.IsDoing(action, CritterAction.PlanFlinch))

{

ExecutePlanFlinch();

}

#endregion

#region Duration

if (Hint.Unlikely(CritterActions.IsDoing(action, CritterAction.DurationFaceConstantly)))

{

ExecuteDurationFaceConstantly(

critter,

ref transform,

durationFaceConstantlyConfig

);

}

if (Hint.Unlikely(CritterActions.IsDoing(action, CritterAction.DurationLeadFollowers)))

{

ExecuteDurationLeadFollowers(

critter,

in transform,

in formationFollower,

in formationFollowers

);

}

if (Hint.Unlikely(CritterActions.IsDoing(action, CritterAction.DurationRun)))

{

ExecuteDurationRun(

ref transform,

in durationRunConfig,

ref durationRunRuntime

);

}

#endregion

#region Canceler

if (Hint.Unlikely(CritterActions.IsDoing(action, CritterAction.CancelerEnemyInRange)))

{

ExecuteCancelerCritterEnemyRange(

critter,

in transform,

in timePassed,

ref timeRequired,

in diplomacy,

in cancelerCritterInRangeConfig

);

}

if (Hint.Unlikely(CritterActions.IsDoing(action, CritterAction.CancelerAllyInRange)))

{

ExecuteCancelerCritterAllyInRange(

critter,

in transform,

in timePassed,

ref timeRequired,

in diplomacy,

in cancelerCritterInRangeConfig

);

}

if (Hint.Unlikely(CritterActions.IsDoing(action, CritterAction.CancelerAnyoneInRange)))

{

ExecuteCancelerCritterAnyoneInRange(

critter,

in transform,

in timePassed,

ref timeRequired,

in cancelerCritterInRangeConfig

);

}

if (Hint.Unlikely(CritterActions.IsDoing(action, CritterAction.CancelerIfPingDodge)))

{

ExecuteCancelerIfPingDodge(

in state,

ref triggers,

in timePassed,

ref timeRequired,

ref cancelerIfPingDodgeConfig

);

}

if (Hint.Unlikely(CritterActions.IsDoing(action, CritterAction.CancelerIfMeleeEnemyIsDodging)))

{

ExecuteCancelerMeleeEnemyIsDodging(

critter,

in transform,

in timePassed,

ref timeRequired,

in diplomacy,

in cancelerMeleeEnemyIsDodgingConfig

);

}

if (Hint.Unlikely(CritterActions.IsDoing(action, CritterAction.CancelerAfterTime)))

{

ExecuteCancelerAfterTime(

in timePassed,

ref timeRequired,

in cancelerAfterTimeConfig

);

}

#endregion

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void Reset(

ref CritterStateComponent state

)

{

state.CanVoluntarilyAct = true;

state.VulnerableToDamage = true;

state.IsFlinching = false;

state.IsDodgingInvulnerable = false;

state.PingDodge = false;

state.TriggerDodgeDirection = float2.zero;

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void PrepareForPlan(

ref CritterActionComponent action,

ref CritterStateComponent state,

ref CritterTimePassedComponent timePassed,

ref CritterTriggerComponent triggers

)

{

Reset(ref state);

action.Doing = CritterAction.None;

timePassed.Seconds = Critter.TIME_PASSED_BEGIN;

Reset(ref triggers);

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void ActivatePlan(

ref CritterActionComponent actionComponent,

CritterAction action,

ref CritterTimeRequiredComponent timeRequired,

float duration

)

{

PerformAction(ref actionComponent, action);

timeRequired.Seconds = duration;

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void PerformAction(

ref CritterActionComponent component,

CritterAction action

)

{

component.Doing |= action;

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void PerformAction(

ref CritterActionComponent component,

CritterAction action,

bool perform

)

{

component.Doing |= (CritterAction)math.select(0, (int)action ,perform);

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private bool Triggered(CritterTriggerComponent triggers)

{

return triggers.Data != CritterTrigger.None;

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void Reset(ref CritterTriggerComponent triggers)

{

triggers.Data = CritterTrigger.None;

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private void AlignWithFormation(

ref LocalTransform transform,

CritterFormationFollowerComponent formationFollower

)

{

var officerYRotation = formationFollower.OfficerTransform.Rotation.YawDegrees();

var thisYRotation = transform.Rotation.YawDegrees();

if (Hint.Unlikely(

officerYRotation.AngleDifferenceWithDegrees(thisYRotation)

> formationFollower.AngleFromFormationBeforeAlignment

))

{

PositionActions.RotateTo(

ref transform,

formationFollower.OfficerTransform.Rotation

);

}

}

}

Search Unity

Unity ID

Useful Searches

Discussion DumbGOAP AI

Abbrew

Abbrew