public override void OnlyLoadoutWeapons(HTNPlayer target)
{
if (target == null || target.IsDestroyed || target.IsDead() || target.IsWounded() || target.inventory == null || target.inventory.containerBelt == null || target.inventory.containerMain == null || target.inventory.containerWear == null)
{
return;
}
if (this.loadouts == null || this.loadouts.Length == 0)
{
UnityEngine.Debug.LogWarning(string.Concat("Loadout for NPC ", base.name, " was empty."));
}
else
{
PlayerInventoryProperties playerInventoryProperty = this.loadouts[UnityEngine.Random.Range(0, (int)this.loadouts.Length)];
if (playerInventoryProperty != null)
{
foreach (ItemAmount itemAmount in playerInventoryProperty.belt)
{
if (itemAmount.itemDef.category != ItemCategory.Weapon)
{
continue;
}
target.inventory.GiveItem(ItemManager.Create(itemAmount.itemDef, (int)itemAmount.amount, (ulong)0), target.inventory.containerBelt);
}
target.StartCoroutine(this.EquipWeapon(target));
return;
}
}
}
public static Ray AimAtBody(HTNPlayer npc, ref NpcPlayerInfo info)
{
Vector3 vector3 = npc.eyes.position;
Vector3 vector31 = info.Player.CenterPoint() - npc.CenterPoint();
return(new Ray(vector3, vector31.normalized));
}
public override void OnlyLoadoutWeapons(HTNPlayer target)
{
if (Object.op_Equality((Object)target, (Object)null) || target.IsDestroyed || (target.IsDead() || target.IsWounded()) || (Object.op_Equality((Object)target.inventory, (Object)null) || target.inventory.containerBelt == null || (target.inventory.containerMain == null || target.inventory.containerWear == null)))
{
return;
}
if (this.loadouts != null && this.loadouts.Length != 0)
{
PlayerInventoryProperties loadout = this.loadouts[Random.Range(0, this.loadouts.Length)];
if (!Object.op_Inequality((Object)loadout, (Object)null))
{
return;
}
foreach (ItemAmount itemAmount in loadout.belt)
{
if (itemAmount.itemDef.category == ItemCategory.Weapon)
{
target.inventory.GiveItem(ItemManager.Create(itemAmount.itemDef, (int)itemAmount.amount, 0UL), target.inventory.containerBelt);
}
}
((MonoBehaviour)target).StartCoroutine(this.EquipWeapon(target));
}
else
{
Debug.LogWarning((object)("Loadout for NPC " + ((Object)this).get_name() + " was empty."));
}
}
public static void TickFootstepHearingTest(IHTNAgent npc, ref NpcPlayerInfo info)
{
if (info.SqrDistance < npc.AiDefinition.Sensory.SqrHearingRange)
{
float player = info.Player.estimatedSpeed;
if (player <= 2f)
{
return;
}
if (player > 5f)
{
npc.AiDomain.NpcContext.EnemyPlayersAudible.Add(info);
}
else
{
HTNPlayer hTNPlayer = npc as HTNPlayer;
if (hTNPlayer)
{
AttackEntity heldEntity = hTNPlayer.GetHeldEntity() as AttackEntity;
if (info.SqrDistance < npc.AiDefinition.Engagement.SqrCloseRangeFirearm(heldEntity))
{
npc.AiDomain.NpcContext.EnemyPlayersAudible.Add(info);
return;
}
}
else if (info.SqrDistance < npc.AiDefinition.Engagement.SqrCloseRange)
{
npc.AiDomain.NpcContext.EnemyPlayersAudible.Add(info);
return;
}
}
}
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
ScientistAStarContext npcContext = npc.AiDomain.NpcContext as ScientistAStarContext;
if (npcContext == null)
{
return;
}
HTNPlayer htnPlayer = npc as HTNPlayer;
if (Object.op_Equality((Object)htnPlayer, (Object)null))
{
return;
}
FireTactic fireTactic = FireTactic.Single;
AttackEntity heldEntity = htnPlayer.GetHeldEntity() as AttackEntity;
if (Object.op_Implicit((Object)heldEntity))
{
BaseProjectile baseProjectile = heldEntity as BaseProjectile;
float num = float.MaxValue;
if (Object.op_Inequality((Object)npcContext.PrimaryEnemyPlayerInLineOfSight.Player, (Object)null))
{
num = npcContext.PrimaryEnemyPlayerInLineOfSight.SqrDistance;
if (Mathf.Approximately(num, 0.0f))
{
num = float.MaxValue;
}
}
fireTactic = (double)heldEntity.attackLengthMin <0.0 || (double)num> (double) npcContext.Body.AiDefinition.Engagement.SqrCloseRangeFirearm((AttackEntity)baseProjectile) ? ((double)heldEntity.attackLengthMin <0.0 || (double)num> (double) npcContext.Body.AiDefinition.Engagement.SqrMediumRangeFirearm((AttackEntity)baseProjectile) ? FireTactic.Single : FireTactic.Burst) : FireTactic.FullAuto;
}
npcContext.SetFact(Rust.Ai.HTN.ScientistAStar.Facts.FireTactic, fireTactic, true, true, true);
}
public static Ray AimAtHead(HTNPlayer npc, ref NpcPlayerInfo info)
{
Vector3 vector3 = npc.eyes.position;
Vector3 player = info.Player.eyes.position - npc.CenterPoint();
return(new Ray(vector3, player.normalized));
}
public override void StopVoices(HTNPlayer target)
{
if (!this._isRadioEffectRunning)
{
return;
}
this._isRadioEffectRunning = false;
}
public static Ray AimAtHead(HTNPlayer npc, ref NpcPlayerInfo info)
{
Vector3 position = npc.eyes.position;
Vector3 vector3 = Vector3.op_Subtraction(info.Player.eyes.position, npc.CenterPoint());
Vector3 normalized = ((Vector3) ref vector3).get_normalized();
return(new Ray(position, normalized));
}
public void AddNpc(HTNPlayer npc)
{
if (this._htnPlayers == null)
{
this._htnPlayers = new List <HTNPlayer>();
}
this._htnPlayers.Add(npc);
}
public void AddNpc(HTNPlayer npc)
{
if (_htnPlayers == null)
{
_htnPlayers = new List <HTNPlayer>();
}
_htnPlayers.Add(npc);
}
public override void StartVoices(HTNPlayer target)
{
if (this._isRadioEffectRunning)
{
return;
}
this._isRadioEffectRunning = true;
target.StartCoroutine(this.RadioChatter(target));
}
protected override void PostSpawnProcess(BaseEntity entity, BaseSpawnPoint spawnPoint)
{
HTNPlayer hTNPlayer = entity as HTNPlayer;
if (hTNPlayer != null && hTNPlayer.AiDomain != null)
{
hTNPlayer.AiDomain.Movement = Movement;
hTNPlayer.AiDomain.MovementRadius = MovementRadius;
}
}
protected override void PostSpawnProcess(BaseEntity entity, BaseSpawnPoint spawnPoint)
{
HTNPlayer movement = entity as HTNPlayer;
if (movement != null && movement.AiDomain != null)
{
movement.AiDomain.Movement = this.Movement;
movement.AiDomain.MovementRadius = this.MovementRadius;
}
}
protected override void PostSpawnProcess(BaseEntity entity, BaseSpawnPoint spawnPoint)
{
HTNPlayer htnPlayer = entity as HTNPlayer;
if (!Object.op_Inequality((Object)htnPlayer, (Object)null) || !Object.op_Inequality((Object)htnPlayer.AiDomain, (Object)null))
{
return;
}
htnPlayer.AiDomain.Movement = this.Movement;
htnPlayer.AiDomain.MovementRadius = this.MovementRadius;
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
if (AI.ignoreplayers)
{
return;
}
BearPlayersInRangeSensor.PlayerQueryResultCount = BaseEntity.Query.Server.GetPlayersInSphere(npc.transform.get_position(), npc.AiDefinition.Sensory.VisionRange, BearPlayersInRangeSensor.PlayerQueryResults, (Func <BasePlayer, bool>)(player => !Object.op_Equality((Object)player, (Object)null) && player.isServer && (!player.IsDestroyed && !Object.op_Equality((Object)((Component)player).get_transform(), (Object)null)) && (!player.IsDead() && (!player.IsSleeping() || (double)player.secondsSleeping >= (double)NPCAutoTurret.sleeperhostiledelay))));
List <NpcPlayerInfo> playersInRange = npc.AiDomain.NpcContext.PlayersInRange;
if (BearPlayersInRangeSensor.PlayerQueryResultCount > 0)
{
for (int index1 = 0; index1 < BearPlayersInRangeSensor.PlayerQueryResultCount; ++index1)
{
BasePlayer playerQueryResult = BearPlayersInRangeSensor.PlayerQueryResults[index1];
HTNPlayer htnPlayer = npc as HTNPlayer;
if (!Object.op_Inequality((Object)htnPlayer, (Object)null) || !Object.op_Equality((Object)playerQueryResult, (Object)htnPlayer))
{
Vector3 vector3 = Vector3.op_Subtraction(((Component)playerQueryResult).get_transform().get_position(), npc.transform.get_position());
if ((double)((Vector3) ref vector3).get_sqrMagnitude() <= (double)npc.AiDefinition.Sensory.SqrVisionRange)
{
bool flag = false;
for (int index2 = 0; index2 < playersInRange.Count; ++index2)
{
NpcPlayerInfo npcPlayerInfo = playersInRange[index2];
if (Object.op_Equality((Object)npcPlayerInfo.Player, (Object)playerQueryResult))
{
npcPlayerInfo.Time = time;
playersInRange[index2] = npcPlayerInfo;
flag = true;
break;
}
}
if (!flag)
{
playersInRange.Add(new NpcPlayerInfo()
{
Player = playerQueryResult,
Time = time
});
}
}
}
}
}
for (int index = 0; index < playersInRange.Count; ++index)
{
NpcPlayerInfo player = playersInRange[index];
if ((double)time - (double)player.Time > (double)npc.AiDefinition.Memory.ForgetInRangeTime && npc.AiDomain.NpcContext.BaseMemory.ShouldRemoveOnPlayerForgetTimeout(time, player))
{
playersInRange.RemoveAt(index);
--index;
}
}
}
private IEnumerator RadioChatter(HTNPlayer target)
{
while (this._isRadioEffectRunning && Object.op_Inequality((Object)target, (Object)null) && (Object.op_Inequality((Object)((Component)target).get_transform(), (Object)null) && !target.IsDestroyed) && !target.IsDead())
{
if (this.RadioEffect.isValid)
{
Effect.server.Run(this.RadioEffect.resourcePath, (BaseEntity)target, StringPool.Get("head"), Vector3.get_zero(), Vector3.get_zero(), (Connection)null, false);
}
yield return((object)CoroutineEx.waitForSeconds(Random.Range((float)this.RadioEffectRepeatRange.x, (float)(this.RadioEffectRepeatRange.y + 1.0))));
}
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
ScientistAStarContext npcContext = npc.AiDomain.NpcContext as ScientistAStarContext;
if (npcContext == null)
{
return;
}
npcContext.SetFact(Facts.HasNearbyCover, (npcContext.CoverPoints.Count > 0 ? 1 : 0), true, true, true);
if (!npcContext.IsFact(Facts.HasEnemyTarget))
{
npcContext.ReserveCoverPoint(null);
return;
}
HTNPlayer hTNPlayer = npc as HTNPlayer;
if (hTNPlayer == null)
{
return;
}
float single = 0f;
float single1 = 0f;
float single2 = 0f;
foreach (CoverPoint coverPoint in npcContext.CoverPoints)
{
if (coverPoint.IsCompromised || coverPoint.IsReserved && !coverPoint.ReservedFor.EqualNetID(hTNPlayer))
{
continue;
}
float single3 = -0.8f;
BaseNpcMemory.EnemyPlayerInfo primaryKnownEnemyPlayer = npcContext.Memory.PrimaryKnownEnemyPlayer;
if (!coverPoint.ProvidesCoverFromPoint(primaryKnownEnemyPlayer.LastKnownPosition, single3))
{
continue;
}
Vector3 position = coverPoint.Position - npc.BodyPosition;
Vector3 lastKnownPosition = primaryKnownEnemyPlayer.LastKnownPosition - npc.BodyPosition;
float single4 = Vector3.Dot(position.normalized, lastKnownPosition.normalized);
if (single < 1f)
{
CoverPointsReasoner.EvaluateAdvancement(npc, npcContext, ref single, ref primaryKnownEnemyPlayer, coverPoint, position, lastKnownPosition, single4);
}
if (single2 < 1f)
{
CoverPointsReasoner.EvaluateRetreat(npc, npcContext, ref single2, ref primaryKnownEnemyPlayer, coverPoint, position, lastKnownPosition, ref single4);
}
if (single1 >= 1f)
{
continue;
}
CoverPointsReasoner.EvaluateFlanking(npc, npcContext, ref single1, ref primaryKnownEnemyPlayer, coverPoint, position, lastKnownPosition, single4);
}
}
public override BaseCorpse OnCreateCorpse(HTNPlayer target)
{
if (this.DeathEffect.isValid)
{
Effect.server.Run(this.DeathEffect.resourcePath, (BaseEntity)target, 0U, Vector3.get_zero(), Vector3.get_zero(), (Connection)null, false);
}
using (TimeWarning.New("Create corpse", 0.1f))
{
NPCPlayerCorpse npcPlayerCorpse = target.DropCorpse("assets/prefabs/npc/murderer/murderer_corpse.prefab") as NPCPlayerCorpse;
if (Object.op_Implicit((Object)npcPlayerCorpse))
{
if (Object.op_Inequality((Object)target.AiDomain, (Object)null) && Object.op_Inequality((Object)target.AiDomain.NavAgent, (Object)null) && target.AiDomain.NavAgent.get_isOnNavMesh())
{
((Component)npcPlayerCorpse).get_transform().set_position(Vector3.op_Addition(((Component)npcPlayerCorpse).get_transform().get_position(), Vector3.op_Multiply(Vector3.get_down(), target.AiDomain.NavAgent.get_baseOffset())));
}
npcPlayerCorpse.SetLootableIn(2f);
npcPlayerCorpse.SetFlag(BaseEntity.Flags.Reserved5, target.HasPlayerFlag(BasePlayer.PlayerFlags.DisplaySash), false, true);
npcPlayerCorpse.SetFlag(BaseEntity.Flags.Reserved2, true, false, true);
for (int index = 0; index < target.inventory.containerWear.itemList.Count; ++index)
{
Item obj = target.inventory.containerWear.itemList[index];
if (obj != null && obj.info.shortname == "gloweyes")
{
target.inventory.containerWear.Remove(obj);
break;
}
}
npcPlayerCorpse.TakeFrom(target.inventory.containerMain, target.inventory.containerWear, target.inventory.containerBelt);
npcPlayerCorpse.playerName = target.displayName;
npcPlayerCorpse.playerSteamID = target.userID;
npcPlayerCorpse.Spawn();
npcPlayerCorpse.TakeChildren((BaseEntity)target);
foreach (ItemContainer container in npcPlayerCorpse.containers)
{
container.Clear();
}
if (this.Loot.Length != 0)
{
foreach (LootContainer.LootSpawnSlot lootSpawnSlot in this.Loot)
{
for (int index = 0; index < lootSpawnSlot.numberToSpawn; ++index)
{
if ((double)Random.Range(0.0f, 1f) <= (double)lootSpawnSlot.probability)
{
lootSpawnSlot.definition.SpawnIntoContainer(npcPlayerCorpse.containers[0]);
}
}
}
}
}
return((BaseCorpse)npcPlayerCorpse);
}
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
ScientistAStarContext npcContext = npc.AiDomain.NpcContext as ScientistAStarContext;
if (npcContext == null)
{
return;
}
npcContext.SetFact(Rust.Ai.HTN.ScientistAStar.Facts.HasNearbyCover, npcContext.CoverPoints.Count > 0 ? 1 : 0, true, true, true);
if (!npcContext.IsFact(Rust.Ai.HTN.ScientistAStar.Facts.HasEnemyTarget))
{
npcContext.ReserveCoverPoint((CoverPoint)null);
}
else
{
HTNPlayer htnPlayer = npc as HTNPlayer;
if (Object.op_Equality((Object)htnPlayer, (Object)null))
{
return;
}
float bestScore1 = 0.0f;
float bestScore2 = 0.0f;
float bestScore3 = 0.0f;
foreach (CoverPoint coverPoint in npcContext.CoverPoints)
{
if (!coverPoint.IsCompromised && (!coverPoint.IsReserved || coverPoint.ReservedFor.EqualNetID((BaseNetworkable)htnPlayer)))
{
float arcThreshold = -0.8f;
BaseNpcMemory.EnemyPlayerInfo knownEnemyPlayer = npcContext.Memory.PrimaryKnownEnemyPlayer;
if (coverPoint.ProvidesCoverFromPoint(knownEnemyPlayer.LastKnownPosition, arcThreshold))
{
Vector3 dirCover = Vector3.op_Subtraction(coverPoint.Position, npc.BodyPosition);
Vector3 dirDanger = Vector3.op_Subtraction(knownEnemyPlayer.LastKnownPosition, npc.BodyPosition);
float directness = Vector3.Dot(((Vector3) ref dirCover).get_normalized(), ((Vector3) ref dirDanger).get_normalized());
if ((double)bestScore1 < 1.0)
{
CoverPointsReasoner.EvaluateAdvancement(npc, npcContext, ref bestScore1, ref knownEnemyPlayer, coverPoint, dirCover, dirDanger, directness);
}
if ((double)bestScore3 < 1.0)
{
CoverPointsReasoner.EvaluateRetreat(npc, npcContext, ref bestScore3, ref knownEnemyPlayer, coverPoint, dirCover, dirDanger, ref directness);
}
if ((double)bestScore2 < 1.0)
{
CoverPointsReasoner.EvaluateFlanking(npc, npcContext, ref bestScore2, ref knownEnemyPlayer, coverPoint, dirCover, dirDanger, directness);
}
}
}
}
}
}
public override BaseCorpse OnCreateCorpse(HTNPlayer target)
{
int i;
BaseCorpse baseCorpse;
if (this.DeathEffect.isValid)
{
Effect.server.Run(this.DeathEffect.resourcePath, target, 0, Vector3.zero, Vector3.zero, null, false);
}
using (TimeWarning timeWarning = TimeWarning.New("Create corpse", 0.1f))
{
NPCPlayerCorpse navAgent = target.DropCorpse("assets/prefabs/npc/scientist/scientist_corpse.prefab") as NPCPlayerCorpse;
if (navAgent)
{
if (target.AiDomain != null && target.AiDomain.NavAgent != null && target.AiDomain.NavAgent.isOnNavMesh)
{
navAgent.transform.position = navAgent.transform.position + (Vector3.down * target.AiDomain.NavAgent.baseOffset);
}
navAgent.SetLootableIn(2f);
navAgent.SetFlag(BaseEntity.Flags.Reserved5, target.HasPlayerFlag(BasePlayer.PlayerFlags.DisplaySash), false, true);
navAgent.SetFlag(BaseEntity.Flags.Reserved2, true, false, true);
navAgent.TakeFrom(new ItemContainer[] { target.inventory.containerMain, target.inventory.containerWear, target.inventory.containerBelt });
navAgent.playerName = target.displayName;
navAgent.playerSteamID = target.userID;
navAgent.Spawn();
navAgent.TakeChildren(target);
ItemContainer[] itemContainerArray = navAgent.containers;
for (i = 0; i < (int)itemContainerArray.Length; i++)
{
itemContainerArray[i].Clear();
}
if (this.Loot.Length != 0)
{
LootContainer.LootSpawnSlot[] loot = this.Loot;
for (i = 0; i < (int)loot.Length; i++)
{
LootContainer.LootSpawnSlot lootSpawnSlot = loot[i];
for (int j = 0; j < lootSpawnSlot.numberToSpawn; j++)
{
if (UnityEngine.Random.Range(0f, 1f) <= lootSpawnSlot.probability)
{
lootSpawnSlot.definition.SpawnIntoContainer(navAgent.containers[0]);
}
}
}
}
}
baseCorpse = navAgent;
}
return(baseCorpse);
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
MurdererContext npcContext = npc.AiDomain.NpcContext as MurdererContext;
if (npcContext == null)
{
return;
}
HTNPlayer htnPlayer = npc as HTNPlayer;
if (Object.op_Equality((Object)htnPlayer, (Object)null))
{
return;
}
NpcOrientation npcOrientation = NpcOrientation.Heading;
if (npc.IsDestroyed || htnPlayer.IsDead() || htnPlayer.IsWounded())
{
npcOrientation = NpcOrientation.None;
}
else if (Object.op_Inequality((Object)npcContext.Memory.PrimaryKnownAnimal.Animal, (Object)null))
{
npcOrientation = !Object.op_Inequality((Object)npcContext.PrimaryEnemyPlayerInLineOfSight.Player, (Object)null) ? NpcOrientation.LookAtAnimal : ((double)npcContext.Memory.PrimaryKnownAnimal.SqrDistance >= (double)npcContext.PrimaryEnemyPlayerInLineOfSight.SqrDistance ? (npcContext.PrimaryEnemyPlayerInLineOfSight.BodyVisible ? NpcOrientation.PrimaryTargetBody : (npcContext.PrimaryEnemyPlayerInLineOfSight.HeadVisible ? NpcOrientation.PrimaryTargetHead : NpcOrientation.LastKnownPrimaryTargetLocation)) : NpcOrientation.LookAtAnimal);
}
else if (Object.op_Inequality((Object)npcContext.PrimaryEnemyPlayerInLineOfSight.Player, (Object)null))
{
npcOrientation = npcContext.PrimaryEnemyPlayerInLineOfSight.BodyVisible ? NpcOrientation.PrimaryTargetBody : (npcContext.PrimaryEnemyPlayerInLineOfSight.HeadVisible ? NpcOrientation.PrimaryTargetHead : NpcOrientation.LastKnownPrimaryTargetLocation);
}
else if (Object.op_Inequality((Object)htnPlayer.lastAttacker, (Object)null) && (double)htnPlayer.lastAttackedTime > 0.0 && (double)time - (double)htnPlayer.lastAttackedTime < 2.0)
{
npcOrientation = NpcOrientation.LastAttackedDirection;
}
else if (Object.op_Inequality((Object)npcContext.Memory.PrimaryKnownEnemyPlayer.PlayerInfo.Player, (Object)null))
{
npcOrientation = npcContext.GetFact(Rust.Ai.HTN.Murderer.Facts.IsSearching) <= (byte)0 || npcContext.GetFact(Rust.Ai.HTN.Murderer.Facts.IsNavigating) != (byte)0 ? (npcContext.GetFact(Rust.Ai.HTN.Murderer.Facts.IsIdle) <= (byte)0 ? NpcOrientation.LastKnownPrimaryTargetLocation : (!npcContext.IsFact(Rust.Ai.HTN.Murderer.Facts.CanHearEnemy) ? NpcOrientation.Heading : NpcOrientation.AudibleTargetDirection)) : NpcOrientation.LookAround;
}
else if (npcContext.IsFact(Rust.Ai.HTN.Murderer.Facts.CanHearEnemy))
{
npcOrientation = NpcOrientation.AudibleTargetDirection;
}
if (npcContext.IsFact(Rust.Ai.HTN.Murderer.Facts.IsRoaming) && !npcContext.IsFact(Rust.Ai.HTN.Murderer.Facts.HasEnemyTarget))
{
npcOrientation = NpcOrientation.Heading;
}
else if (npcContext.IsFact(Rust.Ai.HTN.Murderer.Facts.IsReturningHome) && !npcContext.IsFact(Rust.Ai.HTN.Murderer.Facts.HasEnemyTarget))
{
npcOrientation = NpcOrientation.Home;
}
npcContext.OrientationType = npcOrientation;
}
private IEnumerator RadioChatter(HTNPlayer target)
{
ScientistAStarDefinition scientistAStarDefinition = null;
while (scientistAStarDefinition._isRadioEffectRunning && target != null && target.transform != null && !target.IsDestroyed && !target.IsDead())
{
if (scientistAStarDefinition.RadioEffect.isValid)
{
Effect.server.Run(scientistAStarDefinition.RadioEffect.resourcePath, target, StringPool.Get("head"), Vector3.zero, Vector3.zero, null, false);
}
float single = UnityEngine.Random.Range(scientistAStarDefinition.RadioEffectRepeatRange.x, scientistAStarDefinition.RadioEffectRepeatRange.y + 1f);
yield return(CoroutineEx.waitForSeconds(single));
}
}
private IEnumerator EquipWeapon(HTNPlayer target)
{
yield return(CoroutineEx.waitForSeconds(0.25f));
if (target == null || target.IsDestroyed || target.IsDead() || target.IsWounded() || target.inventory == null || target.inventory.containerBelt == null)
{
yield break;
}
Item item = target.inventory.containerBelt.GetSlot(0);
if (item == null)
{
yield break;
}
target.UpdateActiveItem(item.uid);
yield return(CoroutineEx.waitForSeconds(0.25f));
ScientistAStarDomain aiDomain = target.AiDomain as ScientistAStarDomain;
if (aiDomain)
{
if (item.info.category == ItemCategory.Weapon)
{
BaseEntity heldEntity = item.GetHeldEntity();
if (heldEntity is BaseProjectile)
{
aiDomain.ScientistContext.SetFact(Facts.HeldItemType, ItemType.ProjectileWeapon, true, true, true);
aiDomain.ReloadFirearm();
}
else if (heldEntity is BaseMelee)
{
aiDomain.ScientistContext.SetFact(Facts.HeldItemType, ItemType.MeleeWeapon, true, true, true);
}
else if (heldEntity is ThrownWeapon)
{
aiDomain.ScientistContext.SetFact(Facts.HeldItemType, ItemType.ThrowableWeapon, true, true, true);
}
}
else if (item.info.category == ItemCategory.Medical)
{
aiDomain.ScientistContext.SetFact(Facts.HeldItemType, ItemType.HealingItem, true, true, true);
}
else if (item.info.category == ItemCategory.Tool)
{
aiDomain.ScientistContext.SetFact(Facts.HeldItemType, ItemType.LightSourceItem, true, true, true);
}
}
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
ScientistContext npcContext = npc.AiDomain.NpcContext as ScientistContext;
if (npcContext == null)
{
return;
}
HTNPlayer htnPlayer = npc as HTNPlayer;
if (Object.op_Equality((Object)htnPlayer, (Object)null))
{
return;
}
AttackEntity heldEntity = htnPlayer.GetHeldEntity() as AttackEntity;
if (Object.op_Implicit((Object)heldEntity))
{
BaseProjectile baseProjectile = heldEntity as BaseProjectile;
if (Object.op_Inequality((Object)baseProjectile, (Object)null))
{
float num = (float)baseProjectile.primaryMagazine.contents / (float)baseProjectile.primaryMagazine.capacity;
if ((double)num > 0.899999976158142)
{
npcContext.SetFact(Rust.Ai.HTN.Scientist.Facts.AmmoState, AmmoState.FullClip, true, true, true);
return;
}
if ((double)num > 0.600000023841858)
{
npcContext.SetFact(Rust.Ai.HTN.Scientist.Facts.AmmoState, AmmoState.HighClip, true, true, true);
return;
}
if ((double)num > 0.170000001788139)
{
npcContext.SetFact(Rust.Ai.HTN.Scientist.Facts.AmmoState, AmmoState.MediumClip, true, true, true);
return;
}
if ((double)num > 0.0)
{
npcContext.SetFact(Rust.Ai.HTN.Scientist.Facts.AmmoState, AmmoState.LowAmmo, true, true, true);
return;
}
npcContext.SetFact(Rust.Ai.HTN.Scientist.Facts.AmmoState, AmmoState.EmptyClip, true, true, true);
return;
}
}
npcContext.SetFact(Rust.Ai.HTN.Scientist.Facts.AmmoState, AmmoState.DontRequireAmmo, true, true, true);
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
ScientistContext npcContext = npc.AiDomain.NpcContext as ScientistContext;
if (npcContext == null)
{
return;
}
HTNPlayer hTNPlayer = npc as HTNPlayer;
if (hTNPlayer == null)
{
return;
}
AttackEntity heldEntity = hTNPlayer.GetHeldEntity() as AttackEntity;
if (heldEntity)
{
BaseProjectile baseProjectile = heldEntity as BaseProjectile;
if (baseProjectile != null)
{
float single = (float)baseProjectile.primaryMagazine.contents / (float)baseProjectile.primaryMagazine.capacity;
if (single > 0.9f)
{
npcContext.SetFact(Facts.AmmoState, AmmoState.FullClip, true, true, true);
return;
}
if (single > 0.6f)
{
npcContext.SetFact(Facts.AmmoState, AmmoState.HighClip, true, true, true);
return;
}
if (single > 0.17f)
{
npcContext.SetFact(Facts.AmmoState, AmmoState.MediumClip, true, true, true);
return;
}
if (single > 0f)
{
npcContext.SetFact(Facts.AmmoState, AmmoState.LowAmmo, true, true, true);
return;
}
npcContext.SetFact(Facts.AmmoState, AmmoState.EmptyClip, true, true, true);
return;
}
}
npcContext.SetFact(Facts.AmmoState, AmmoState.DontRequireAmmo, true, true, true);
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
ScientistJunkpileContext npcContext = npc.AiDomain.NpcContext as ScientistJunkpileContext;
if (npcContext == null)
{
return;
}
HTNPlayer hTNPlayer = npc as HTNPlayer;
if (hTNPlayer == null)
{
return;
}
FireTactic fireTactic = FireTactic.Single;
AttackEntity heldEntity = hTNPlayer.GetHeldEntity() as AttackEntity;
if (heldEntity)
{
BaseProjectile baseProjectile = heldEntity as BaseProjectile;
float sqrDistance = Single.MaxValue;
if (npcContext.PrimaryEnemyPlayerInLineOfSight.Player != null)
{
sqrDistance = npcContext.PrimaryEnemyPlayerInLineOfSight.SqrDistance;
if (Mathf.Approximately(sqrDistance, 0f))
{
sqrDistance = Single.MaxValue;
}
}
else if (npcContext.Memory.PrimaryKnownAnimal.Animal != null)
{
sqrDistance = npcContext.Memory.PrimaryKnownAnimal.SqrDistance;
if (Mathf.Approximately(sqrDistance, 0f))
{
sqrDistance = Single.MaxValue;
}
}
if (heldEntity.attackLengthMin < 0f || sqrDistance > npcContext.Body.AiDefinition.Engagement.SqrCloseRangeFirearm(baseProjectile))
{
fireTactic = (heldEntity.attackLengthMin <0f || sqrDistance> npcContext.Body.AiDefinition.Engagement.SqrMediumRangeFirearm(baseProjectile) ? FireTactic.Single : FireTactic.Burst);
}
else
{
fireTactic = FireTactic.FullAuto;
}
}
npcContext.SetFact(Facts.FireTactic, fireTactic, true, true, true);
}
public static Ray AimAtBody(IHTNAgent npc, ref NpcPlayerInfo info)
{
HTNPlayer npc1 = npc as HTNPlayer;
if (Object.op_Inequality((Object)npc1, (Object)null))
{
return(BearEnemyPlayersLineOfSightSensor.AimAtBody(npc1, ref info));
}
HTNAnimal npc2 = npc as HTNAnimal;
if (Object.op_Inequality((Object)npc2, (Object)null))
{
return(BearEnemyPlayersLineOfSightSensor.AimAtBody(npc2, ref info));
}
return((Ray)null);
}
public static Ray AimAtHead(IHTNAgent npc, ref NpcPlayerInfo info)
{
HTNPlayer hTNPlayer = npc as HTNPlayer;
if (hTNPlayer != null)
{
return(BearEnemyPlayersLineOfSightSensor.AimAtHead(hTNPlayer, ref info));
}
HTNAnimal hTNAnimal = npc as HTNAnimal;
if (hTNAnimal != null)
{
return(BearEnemyPlayersLineOfSightSensor.AimAtHead(hTNAnimal, ref info));
}
return(new Ray());
}
public ScientistJunkpileContext(HTNPlayer body, ScientistJunkpileDomain domain)
{
int length = System.Enum.GetValues(typeof(Facts)).Length;
if (this._worldState == null || this._worldState.Length != length)
{
this._worldState = new byte[length];
this._previousWorldState = new byte[length];
if (ScientistJunkpileContext._worldStateChanges == null)
{
ScientistJunkpileContext._worldStateChanges = new Stack <WorldStateInfo> [length];
for (int index = 0; index < length; ++index)
{
ScientistJunkpileContext._worldStateChanges[index] = new Stack <WorldStateInfo>(5);
}
}
}
this._decompositionScore = int.MaxValue;
this.Body = body;
this.Domain = domain;
this.PlanState = (PlanStateType)0;
if (this.Memory == null || this.Memory.ScientistJunkpileContext != this)
{
this.Memory = new ScientistJunkpileMemory(this);
}
if (!Object.op_Equality((Object)this.Location, (Object)null))
{
return;
}
float num = float.MaxValue;
foreach (AiLocationManager manager in AiLocationManager.Managers)
{
Vector3 vector3 = Vector3.op_Subtraction(((Component)manager).get_transform().get_position(), ((Component)this.Body).get_transform().get_position());
float sqrMagnitude = ((Vector3) ref vector3).get_sqrMagnitude();
if ((double)sqrMagnitude < (double)num)
{
num = sqrMagnitude;
this.Location = manager;
}
}
if (!Object.op_Inequality((Object)this.Location, (Object)null))
{
return;
}
this.Junkpile = (JunkPile)((Component)this.Location).GetComponent <JunkPile>();
}
void ClotheScarecrow(HTNPlayer scarecrow)
{
var inv_wear = scarecrow.inventory.containerWear;
var inv_belt = scarecrow.inventory.containerBelt;
Item gloweyes = ItemManager.CreateByName("gloweyes");
Item itemHeadwear = GetItem(_config.ScarecrowHeadwear);
Item itemTorso = GetItem(_config.ScarecrowTorso);
Item itemLegs = GetItem(_config.ScarecrowLegs);
Item itemFeet = GetItem(_config.ScarecrowFeet);
Item itemHands = GetItem(_config.ScarecrowHands);
inv_wear.Clear();
if (_config.GlowingScarecrowEyes)
{
gloweyes.MoveToContainer(inv_wear);
}
if (itemHeadwear != null)
{
itemHeadwear.MoveToContainer(inv_wear);
}
if (itemTorso != null)
{
itemTorso.MoveToContainer(inv_wear);
}
if (itemLegs != null)
{
itemLegs.MoveToContainer(inv_wear);
}
if (itemFeet != null)
{
itemFeet.MoveToContainer(inv_wear);
}
if (itemHands != null)
{
itemHands.MoveToContainer(inv_wear);
}
Item itemMelee = GetItem(_config.ScarecrowMeleeWeapon);
if (itemMelee != null)
{
inv_belt.Clear();
itemMelee.MoveToContainer(inv_belt);
}
}
