949 lines
35 KiB
C#
949 lines
35 KiB
C#
using GamePath;
|
|
using System.Collections.Generic;
|
|
|
|
public class EAIApproachAndAttackTargetZombieRebirth : EAIBase
|
|
{
|
|
public struct TargetClass
|
|
{
|
|
public Type type;
|
|
public float chaseTimeMax;
|
|
}
|
|
|
|
public const float cSleeperChaseTime = 90f;
|
|
public List<EAIApproachAndAttackTargetZombieRebirth.TargetClass> targetClasses;
|
|
public float chaseTimeMax;
|
|
public bool hasHome;
|
|
public bool isGoingHome;
|
|
public float homeTimeout;
|
|
public EntityAlive entityTarget;
|
|
public Vector3 entityTargetPos;
|
|
public Vector3 entityTargetVel;
|
|
public int attackTimeout;
|
|
public int pathCounter;
|
|
public Vector2 seekPosOffset;
|
|
public bool isTargetToEat;
|
|
public bool isEating;
|
|
public EAIBlockingTargetTask blockTargetTask;
|
|
public int relocateTicks;
|
|
public int eatCount;
|
|
|
|
public override void Init(EntityAlive _theEntity)
|
|
{
|
|
base.Init(_theEntity);
|
|
MutexBits = 3;
|
|
executeDelay = 0.1f;
|
|
}
|
|
|
|
public override void SetData(DictionarySave<string, string> data)
|
|
{
|
|
base.SetData(data);
|
|
targetClasses = new List<EAIApproachAndAttackTargetZombieRebirth.TargetClass>();
|
|
string str;
|
|
if (!data.TryGetValue("class", out str))
|
|
return;
|
|
string[] strArray = str.Split(',', StringSplitOptions.None);
|
|
for (int index = 0; index < strArray.Length; index += 2)
|
|
{
|
|
EAIApproachAndAttackTargetZombieRebirth.TargetClass targetClass = new EAIApproachAndAttackTargetZombieRebirth.TargetClass();
|
|
targetClass.type = EntityFactory.GetEntityType(strArray[index]);
|
|
targetClass.chaseTimeMax = 0.0f;
|
|
if (index + 1 < strArray.Length)
|
|
targetClass.chaseTimeMax = StringParsers.ParseFloat(strArray[index + 1]);
|
|
targetClasses.Add(targetClass);
|
|
if (targetClass.type == typeof(EntityEnemyAnimal))
|
|
{
|
|
targetClass.type = typeof(EntityAnimalSnake);
|
|
targetClasses.Add(targetClass);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SetTargetOnlyPlayers()
|
|
{
|
|
targetClasses.Clear();
|
|
targetClasses.Add(new EAIApproachAndAttackTargetZombieRebirth.TargetClass()
|
|
{
|
|
type = typeof(EntityPlayer)
|
|
});
|
|
}
|
|
|
|
public override bool CanExecute()
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute START");
|
|
|
|
if (RebirthUtilities.canAttack(theEntity))
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 1");
|
|
return false;
|
|
}
|
|
|
|
//if (entityTarget != null)
|
|
//{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute BEFORE entityTarget: " + entityTarget.EntityClass.entityClassName);
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute BEFORE theEntity.GetAttackTarget(): " + theEntity.GetAttackTarget());
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute BEFORE theEntity.GetRevengeTarget(): " + theEntity.GetRevengeTarget());
|
|
//}
|
|
|
|
entityTarget = theEntity.GetAttackTarget();
|
|
if (entityTarget == null)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 2");
|
|
return false;
|
|
}
|
|
//else
|
|
//{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute AFTER entityTarget: " + entityTarget.EntityClass.entityClassName);
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute AFTER theEntity.GetAttackTarget(): " + theEntity.GetAttackTarget());
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute AFTER theEntity.GetRevengeTarget(): " + theEntity.GetRevengeTarget());
|
|
//}
|
|
|
|
bool bMindControlled = theEntity.Buffs.HasBuff("FuriousRamsayRangedMindControlBuffTier1") || theEntity.Buffs.HasBuff("FuriousRamsayRangedMindControlBuffTier2") || theEntity.Buffs.HasBuff("FuriousRamsayRangedMindControlBuffTier3");
|
|
|
|
if (bMindControlled)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 3");
|
|
if (entityTarget != null)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 4");
|
|
if (entityTarget is EntityPlayer || (entityTarget is EntityNPCRebirth && (entityTarget.HasAnyTags(FastTags<TagGroup.Global>.Parse("survivor")) || entityTarget.HasAnyTags(FastTags<TagGroup.Global>.Parse("ally")))))
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 5");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
string rebirthFeralSense = RebirthVariables.customFeralSense;
|
|
int currentDay = GameUtils.WorldTimeToDays(GameManager.Instance.World.worldTime);
|
|
|
|
bool randomValid = rebirthFeralSense == "random" &&
|
|
currentDay == RebirthManager.nextFeralSenseDay;
|
|
|
|
if (randomValid && GameManager.Instance.World.IsDaytime() && RebirthManager.nextFeralSensePeriod == 1)
|
|
{
|
|
randomValid = false;
|
|
}
|
|
if (randomValid && !GameManager.Instance.World.IsDaytime() && RebirthManager.nextFeralSensePeriod == 2)
|
|
{
|
|
randomValid = false;
|
|
}
|
|
|
|
bool isValidFeralSense = (rebirthFeralSense == "always") ||
|
|
(GameManager.Instance.World.IsDaytime() && rebirthFeralSense == "dayonly") ||
|
|
(!GameManager.Instance.World.IsDaytime() && rebirthFeralSense == "nightonly") ||
|
|
randomValid;
|
|
|
|
string rebirthPOISense = RebirthVariables.customPOISense;
|
|
bool POISense = (rebirthPOISense == "always") ||
|
|
(GameManager.Instance.World.IsDaytime() && rebirthPOISense == "dayonly") ||
|
|
(!GameManager.Instance.World.IsDaytime() && rebirthPOISense == "nightonly");
|
|
|
|
bool persist = theEntity.HasAnyTags(FastTags<TagGroup.Global>.Parse("event")) || isValidFeralSense || (theEntity.IsSleeper && POISense);
|
|
|
|
if (persist && !bMindControlled)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 6");
|
|
if (!theEntity.GetRevengeTarget())
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 7");
|
|
EntityPlayer closestPlayer = null;
|
|
float num = 200 * 200;
|
|
float num2 = float.MaxValue;
|
|
for (int i = theEntity.world.Players.list.Count - 1; i >= 0; i--)
|
|
{
|
|
EntityPlayer entityPlayer = theEntity.world.Players.list[i];
|
|
if (!entityPlayer.IsDead() && entityPlayer.Spawned && !entityPlayer.IsSpectator)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 8");
|
|
//Log.Out("FOUND PLAYER: " + entityPlayer.EntityName);
|
|
float distanceSq = entityPlayer.GetDistanceSq(theEntity.position);
|
|
if (distanceSq < num2 && distanceSq <= num)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 9");
|
|
num2 = distanceSq;
|
|
closestPlayer = entityPlayer;
|
|
}
|
|
}
|
|
}
|
|
if (closestPlayer != null)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 10");
|
|
theEntity.SetAttackTarget(closestPlayer, 200);
|
|
entityTarget = closestPlayer;
|
|
//Log.Out("CanExecute GOT CLOSEST PLAYER");
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 11");
|
|
entityTarget = theEntity.GetAttackTarget();
|
|
//Log.Out("CanExecute NO CLOSEST PLAYER");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 12");
|
|
entityTarget = theEntity.GetRevengeTarget();
|
|
}
|
|
}
|
|
|
|
Type type = entityTarget.GetType();
|
|
for (int i = 0; i < targetClasses.Count; i++)
|
|
{
|
|
EAIApproachAndAttackTargetZombieRebirth.TargetClass targetClass = targetClasses[i];
|
|
if (targetClass.type != null && targetClass.type.IsAssignableFrom(type))
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-CanExecute 13");
|
|
chaseTimeMax = targetClass.chaseTimeMax;
|
|
|
|
if (persist)
|
|
{
|
|
chaseTimeMax = 1000;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override void Start()
|
|
{
|
|
entityTargetPos = entityTarget.position;
|
|
entityTargetVel = Vector3.zero;
|
|
isTargetToEat = entityTarget.IsDead() && !(entityTarget is EntityZombie);
|
|
isEating = false;
|
|
theEntity.IsEating = false;
|
|
homeTimeout = (theEntity.IsSleeper ? cSleeperChaseTime : 0f);
|
|
|
|
//Log.Out("Start, homeTimeout" + homeTimeout);
|
|
|
|
hasHome = (homeTimeout > 0f);
|
|
isGoingHome = false;
|
|
if (theEntity.ChaseReturnLocation == Vector3.zero)
|
|
{
|
|
theEntity.ChaseReturnLocation = (theEntity.IsSleeper ? theEntity.SleeperSpawnPosition : theEntity.position);
|
|
}
|
|
pathCounter = 0;
|
|
relocateTicks = 0;
|
|
attackTimeout = 5;
|
|
}
|
|
|
|
public override bool Continue()
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Continue START");
|
|
if (RebirthUtilities.canAttack(theEntity))
|
|
{
|
|
return false;
|
|
}
|
|
EntityAlive attackTarget = theEntity.GetAttackTarget();
|
|
if (isGoingHome)
|
|
{
|
|
return !attackTarget && theEntity.ChaseReturnLocation != Vector3.zero;
|
|
}
|
|
return attackTarget && !(attackTarget != entityTarget) && attackTarget.IsDead() == isTargetToEat;
|
|
}
|
|
|
|
public override void Reset()
|
|
{
|
|
theEntity.IsEating = false;
|
|
theEntity.moveHelper.Stop();
|
|
if (blockTargetTask != null)
|
|
{
|
|
blockTargetTask.canExecute = false;
|
|
}
|
|
}
|
|
|
|
/*public override void Update()
|
|
{
|
|
if (hasHome && !isTargetToEat)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 1");
|
|
if (isGoingHome)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 2");
|
|
Vector3 vector = theEntity.ChaseReturnLocation - theEntity.position;
|
|
float y = vector.y;
|
|
vector.y = 0f;
|
|
if (vector.sqrMagnitude <= 0.16000001132488251 && Utils.FastAbs(y) < 2f)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 3");
|
|
Vector3 chaseReturnLocation = theEntity.ChaseReturnLocation;
|
|
chaseReturnLocation.y = theEntity.position.y;
|
|
theEntity.SetPosition(chaseReturnLocation, true);
|
|
theEntity.ChaseReturnLocation = Vector3.zero;
|
|
if (theEntity.IsSleeper)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 4");
|
|
theEntity.ResumeSleeperPose();
|
|
}
|
|
return;
|
|
}
|
|
int num = pathCounter - 1;
|
|
pathCounter = num;
|
|
if (num <= 0 && !PathFinderThread.Instance.IsCalculatingPath(theEntity.entityId))
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 5");
|
|
pathCounter = 60;
|
|
float moveSpeed = theEntity.GetMoveSpeedAggro() * 0.8f;
|
|
theEntity.FindPath(theEntity.ChaseReturnLocation, moveSpeed, false, this);
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 6");
|
|
homeTimeout -= 0.05f;
|
|
if (homeTimeout <= 0f)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 7");
|
|
if (blockTargetTask == null)
|
|
{
|
|
List<EAIBlockingTargetTask> targetTasks = manager.GetTargetTasks<EAIBlockingTargetTask>();
|
|
if (targetTasks != null)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 8");
|
|
blockTargetTask = targetTasks[0];
|
|
}
|
|
}
|
|
if (blockTargetTask != null)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 9");
|
|
blockTargetTask.canExecute = true;
|
|
}
|
|
////Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update REMOVE ATTACK TARGET");
|
|
theEntity.attackTarget = (EntityAlive) null;
|
|
theEntity.SetLookPosition(Vector3.zero);
|
|
theEntity.PlayGiveUpSound();
|
|
pathCounter = 0;
|
|
isGoingHome = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (entityTarget == null)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 10");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update entityTarget: " + entityTarget.EntityClass.entityClassName);
|
|
}
|
|
if (relocateTicks > 0)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 11");
|
|
if (!theEntity.navigator.noPathAndNotPlanningOne())
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 12");
|
|
relocateTicks--;
|
|
theEntity.moveHelper.SetFocusPos(entityTarget.position);
|
|
return;
|
|
}
|
|
relocateTicks = 0;
|
|
}
|
|
Vector3 vector2 = entityTarget.position;
|
|
if (isTargetToEat)
|
|
{
|
|
vector2 = entityTarget.getBellyPosition();
|
|
}
|
|
Vector3 a = vector2 - entityTargetPos;
|
|
if (a.sqrMagnitude < 1f)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 13");
|
|
entityTargetVel = entityTargetVel * 0.7f + a * 0.3f;
|
|
}
|
|
entityTargetPos = vector2;
|
|
attackTimeout--;
|
|
if (isEating)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 14");
|
|
if (theEntity.bodyDamage.HasLimbs)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 15");
|
|
theEntity.RotateTo(vector2.x, vector2.y, vector2.z, 30f, 30f);
|
|
}
|
|
if (attackTimeout <= 0)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update 16");
|
|
attackTimeout = 25 + base.GetRandom(10);
|
|
if ((eatCount & 1) == 0)
|
|
{
|
|
theEntity.PlayOneShot("eat_player", false);
|
|
entityTarget.DamageEntity(DamageSource.eat, 35, false, 1f);
|
|
}
|
|
Vector3 pos = new Vector3(0f, 0.04f, 0.08f);
|
|
ParticleEffect pe = new ParticleEffect("blood_eat", pos, 1f, Color.white, null, theEntity.entityId, ParticleEffect.Attachment.Head);
|
|
GameManager.Instance.SpawnParticleEffectServer(pe, theEntity.entityId, false, false);
|
|
eatCount++;
|
|
}
|
|
return;
|
|
}
|
|
theEntity.moveHelper.CalcIfUnreachablePos();
|
|
float num2;
|
|
float num3;
|
|
if (!isTargetToEat)
|
|
{
|
|
ItemValue holdingItemItemValue = theEntity.inventory.holdingItemItemValue;
|
|
int holdingItemIdx = theEntity.inventory.holdingItemIdx;
|
|
ItemAction itemAction = holdingItemItemValue.ItemClass.Actions[holdingItemIdx];
|
|
num2 = 1.095f;
|
|
if (itemAction != null)
|
|
{
|
|
num2 = itemAction.Range;
|
|
if (num2 == 0f)
|
|
{
|
|
num2 = EffectManager.GetItemValue(PassiveEffects.MaxRange, holdingItemItemValue, 0f);
|
|
}
|
|
}
|
|
num3 = Utils.FastMax(0.7f, num2 - 0.35f);
|
|
}
|
|
else
|
|
{
|
|
num2 = theEntity.GetHeight() * 0.9f;
|
|
num3 = num2 - 0.05f;
|
|
}
|
|
float num4 = num3 * num3;
|
|
float num5 = 4f;
|
|
if (theEntity.IsFeral)
|
|
{
|
|
num5 = 8f;
|
|
}
|
|
num5 = base.RandomFloat * num5;
|
|
float targetXZDistanceSq = GetTargetXZDistanceSq(num5);
|
|
float num6 = vector2.y - theEntity.position.y;
|
|
float num7 = Utils.FastAbs(num6);
|
|
bool flag = targetXZDistanceSq <= num4 && num7 < 1f;
|
|
if (!flag)
|
|
{
|
|
if (num7 < 3f && !PathFinderThread.Instance.IsCalculatingPath(theEntity.entityId))
|
|
{
|
|
PathEntity path = theEntity.navigator.getPath();
|
|
if (path != null && path.NodeCountRemaining() <= 2)
|
|
{
|
|
pathCounter = 0;
|
|
}
|
|
}
|
|
int num = pathCounter - 1;
|
|
pathCounter = num;
|
|
if (num <= 0 && theEntity.CanNavigatePath() && !PathFinderThread.Instance.IsCalculatingPath(theEntity.entityId))
|
|
{
|
|
pathCounter = 6 + base.GetRandom(10);
|
|
Vector3 moveToLocation = GetMoveToLocation(num3);
|
|
if (moveToLocation.y - theEntity.position.y < -8f)
|
|
{
|
|
pathCounter += 40;
|
|
if (base.RandomFloat < 0.2f)
|
|
{
|
|
seekPosOffset.x = seekPosOffset.x + (base.RandomFloat * 0.6f - 0.3f);
|
|
seekPosOffset.y = seekPosOffset.y + (base.RandomFloat * 0.6f - 0.3f);
|
|
}
|
|
moveToLocation.x += seekPosOffset.x;
|
|
moveToLocation.z += seekPosOffset.y;
|
|
}
|
|
else
|
|
{
|
|
float numDistance = 0;
|
|
try
|
|
{
|
|
numDistance = Mathf.Abs(theEntity.inventory.GetBareHandItem().Actions[0].Range - entityTarget.inventory.GetBareHandItem().Actions[0].Range);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//Log.Out("============================ ERROR ==================================");
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update ENTITY NAME: " + theEntity.EntityClass.entityClassName);
|
|
//Log.Out("============================ ERROR ==================================");
|
|
}
|
|
|
|
float num8 = (moveToLocation - theEntity.position).magnitude - 5f;
|
|
|
|
float numDifference = num8 - numDistance;
|
|
|
|
if (numDistance <= 0)
|
|
{
|
|
num8 = 0;
|
|
}
|
|
|
|
if (num8 > 0f)
|
|
{
|
|
if (num8 > 60f)
|
|
{
|
|
num8 = 60f;
|
|
}
|
|
pathCounter += (int)(num8 / 20f * 20f);
|
|
}
|
|
}
|
|
theEntity.FindPath(moveToLocation, theEntity.GetMoveSpeedAggro(), false, this);
|
|
}
|
|
}
|
|
if (theEntity.Climbing)
|
|
{
|
|
return;
|
|
}
|
|
bool flag2 = theEntity.CanSee(entityTarget);
|
|
theEntity.SetLookPosition((flag2 && !theEntity.IsBreakingBlocks) ? entityTarget.getHeadPosition() : Vector3.zero);
|
|
if (!flag)
|
|
{
|
|
if (theEntity.navigator.noPathAndNotPlanningOne() && pathCounter > 0 && num6 < 2.1f)
|
|
{
|
|
Vector3 moveToLocation2 = GetMoveToLocation(num3);
|
|
theEntity.moveHelper.SetMoveTo(moveToLocation2, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
theEntity.moveHelper.Stop();
|
|
pathCounter = 0;
|
|
}
|
|
float num9 = isTargetToEat ? num2 : (num2 - 0.1f);
|
|
float num10 = num9 * num9;
|
|
if (targetXZDistanceSq > num10 || num7 >= 1.25f)
|
|
{
|
|
return;
|
|
}
|
|
theEntity.IsBreakingBlocks = false;
|
|
theEntity.IsBreakingDoors = false;
|
|
if (theEntity.bodyDamage.HasLimbs && !theEntity.Electrocuted)
|
|
{
|
|
theEntity.RotateTo(vector2.x, vector2.y, vector2.z, 30f, 30f);
|
|
}
|
|
if (isTargetToEat)
|
|
{
|
|
isEating = true;
|
|
theEntity.IsEating = true;
|
|
attackTimeout = 20;
|
|
eatCount = 0;
|
|
return;
|
|
}
|
|
if (theEntity.GetDamagedTarget() == entityTarget || (entityTarget != null && entityTarget.GetDamagedTarget() == theEntity))
|
|
{
|
|
homeTimeout = (theEntity.IsSleeper ? 90f : chaseTimeMax);
|
|
if (blockTargetTask != null)
|
|
{
|
|
blockTargetTask.canExecute = false;
|
|
}
|
|
theEntity.ClearDamagedTarget();
|
|
if (entityTarget)
|
|
{
|
|
entityTarget.ClearDamagedTarget();
|
|
}
|
|
}
|
|
if (attackTimeout > 0)
|
|
{
|
|
return;
|
|
}
|
|
if (manager.groupCircle > 0f)
|
|
{
|
|
Entity targetIfAttackedNow = theEntity.GetTargetIfAttackedNow();
|
|
if (targetIfAttackedNow != entityTarget && (!entityTarget.AttachedToEntity || entityTarget.AttachedToEntity != targetIfAttackedNow))
|
|
{
|
|
if (targetIfAttackedNow != null)
|
|
{
|
|
relocateTicks = 46;
|
|
Vector3 vector3 = (theEntity.position - vector2).normalized * (num9 + 1.1f);
|
|
float num11 = base.RandomFloat * 28f + 18f;
|
|
if (base.RandomFloat < 0.5f)
|
|
{
|
|
num11 = -num11;
|
|
}
|
|
vector3 = Quaternion.Euler(0f, num11, 0f) * vector3;
|
|
Vector3 targetPos = vector2 + vector3;
|
|
theEntity.FindPath(targetPos, theEntity.GetMoveSpeedAggro(), false, this);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
theEntity.SleeperSupressLivingSounds = false;
|
|
if (theEntity.Attack(false))
|
|
{
|
|
attackTimeout = theEntity.GetAttackTimeoutTicks();
|
|
theEntity.Attack(true);
|
|
}
|
|
}*/
|
|
|
|
public override void Update()
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-Update START");
|
|
|
|
if (hasHome && !isTargetToEat)
|
|
{
|
|
if (isGoingHome)
|
|
{
|
|
Vector3 vector3 = theEntity.ChaseReturnLocation - theEntity.position;
|
|
float y = vector3.y;
|
|
vector3.y = 0.0f;
|
|
if (vector3.sqrMagnitude <= 0.16000001f && Utils.FastAbs(y) < 2.0f)
|
|
{
|
|
Vector3 chaseReturnLocation = theEntity.ChaseReturnLocation;
|
|
chaseReturnLocation.y = theEntity.position.y;
|
|
theEntity.SetPosition(chaseReturnLocation);
|
|
theEntity.ChaseReturnLocation = Vector3.zero;
|
|
if (theEntity.IsSleeper)
|
|
theEntity.ResumeSleeperPose();
|
|
}
|
|
else if (--pathCounter <= 0 || !PathFinderThread.Instance.IsCalculatingPath(theEntity.entityId))
|
|
{
|
|
pathCounter = 60;
|
|
theEntity.FindPath(theEntity.ChaseReturnLocation, theEntity.GetMoveSpeedAggro() * 0.8f, false, this);
|
|
}
|
|
|
|
return;
|
|
}
|
|
homeTimeout -= 0.05f;
|
|
if (homeTimeout <= 0.0f && hasHome)
|
|
{
|
|
if (blockTargetTask == null)
|
|
{
|
|
List<EAIBlockingTargetTask> targetTasks = manager.GetTargetTasks<EAIBlockingTargetTask>();
|
|
if (targetTasks != null)
|
|
blockTargetTask = targetTasks[0];
|
|
}
|
|
if (blockTargetTask != null)
|
|
blockTargetTask.canExecute = true;
|
|
theEntity.SetAttackTarget((EntityAlive)null, 0);
|
|
theEntity.SetLookPosition(Vector3.zero);
|
|
theEntity.PlayGiveUpSound();
|
|
pathCounter = 0;
|
|
isGoingHome = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// NEW CODE - in the event they were attacking a turned zombie that turned back
|
|
bool shouldAttack = RebirthUtilities.VerifyFactionStanding(theEntity, entityTarget);
|
|
|
|
if (!shouldAttack)
|
|
{
|
|
theEntity.attackTarget = (EntityAlive) null;
|
|
theEntity.SetRevengeTarget((EntityAlive) null);
|
|
return;
|
|
}
|
|
// NEW CODE
|
|
|
|
if (entityTarget == null)
|
|
return;
|
|
if (relocateTicks > 0)
|
|
{
|
|
if (theEntity.navigator.noPathAndNotPlanningOne())
|
|
{
|
|
relocateTicks = 0;
|
|
}
|
|
else
|
|
{
|
|
--relocateTicks;
|
|
theEntity.moveHelper.SetFocusPos(entityTarget.position);
|
|
return;
|
|
}
|
|
}
|
|
Vector3 vector3_1 = entityTarget.position;
|
|
if (isTargetToEat)
|
|
vector3_1 = entityTarget.getBellyPosition();
|
|
Vector3 vector3_2 = vector3_1 - entityTargetPos;
|
|
if (vector3_2.sqrMagnitude < 1.0f)
|
|
entityTargetVel = entityTargetVel * 0.7f + vector3_2 * 0.3f;
|
|
entityTargetPos = vector3_1;
|
|
--attackTimeout;
|
|
if (isEating)
|
|
{
|
|
if (theEntity.bodyDamage.HasLimbs)
|
|
theEntity.RotateTo(vector3_1.x, vector3_1.y, vector3_1.z, 8f, 5f);
|
|
if (attackTimeout > 0)
|
|
return;
|
|
attackTimeout = 25 + GetRandom(10);
|
|
if ((eatCount & 1) == 0)
|
|
{
|
|
theEntity.PlayOneShot("eat_player");
|
|
entityTarget.DamageEntity(DamageSource.eat, 35, false, 1f);
|
|
}
|
|
ParticleEffect _pe = new ParticleEffect("blood_eat", new Vector3(0.0f, 0.04f, 0.08f), 1f, Color.white, string.Empty, theEntity.entityId, ParticleEffect.Attachment.Head);
|
|
GameManager.Instance.SpawnParticleEffectServer(_pe, theEntity.entityId, false, false);
|
|
++eatCount;
|
|
}
|
|
else
|
|
{
|
|
theEntity.moveHelper.CalcIfUnreachablePos();
|
|
float num1;
|
|
float maxDist;
|
|
if (!isTargetToEat)
|
|
{
|
|
ItemValue holdingItemItemValue = theEntity.inventory.holdingItemItemValue;
|
|
int holdingItemIdx = theEntity.inventory.holdingItemIdx;
|
|
ItemAction action = holdingItemItemValue.ItemClass.Actions[holdingItemIdx];
|
|
num1 = 1.095f;
|
|
if (action != null)
|
|
{
|
|
num1 = action.Range;
|
|
if (num1 == 0.0f)
|
|
num1 = EffectManager.GetItemValue(PassiveEffects.MaxRange, holdingItemItemValue);
|
|
}
|
|
maxDist = Utils.FastMax(0.7f, num1 - 0.35f);
|
|
}
|
|
else
|
|
{
|
|
num1 = theEntity.GetHeight() * 0.9f;
|
|
maxDist = num1 - 0.05f;
|
|
}
|
|
float num2 = maxDist * maxDist;
|
|
float num3 = 4f;
|
|
if (theEntity.IsFeral)
|
|
num3 = 8f;
|
|
float targetXzDistanceSq = GetTargetXZDistanceSq(RandomFloat * num3);
|
|
float _x = vector3_1.y - theEntity.position.y;
|
|
float num4 = Utils.FastAbs(_x);
|
|
bool flag = targetXzDistanceSq <= num2 && num4 < 1.0f;
|
|
if (!flag)
|
|
{
|
|
if (num4 < 3.0f && !PathFinderThread.Instance.IsCalculatingPath(theEntity.entityId))
|
|
{
|
|
PathEntity path = theEntity.navigator.getPath();
|
|
if (path != null && path.NodeCountRemaining() <= 2)
|
|
pathCounter = 0;
|
|
}
|
|
if (--pathCounter <= 0 && theEntity.CanNavigatePath() && !PathFinderThread.Instance.IsCalculatingPath(theEntity.entityId))
|
|
{
|
|
pathCounter = 6 + GetRandom(10);
|
|
Vector3 moveToLocation = GetMoveToLocation(maxDist);
|
|
if (moveToLocation.y - theEntity.position.y < -8.0f)
|
|
{
|
|
pathCounter += 40;
|
|
if (RandomFloat < 0.2f)
|
|
{
|
|
seekPosOffset.x += RandomFloat * 0.6f - 0.3f;
|
|
seekPosOffset.y += RandomFloat * 0.6f - 0.3f;
|
|
}
|
|
moveToLocation.x += seekPosOffset.x;
|
|
moveToLocation.z += seekPosOffset.y;
|
|
}
|
|
else
|
|
{
|
|
float num5 = (moveToLocation - theEntity.position).magnitude - 5f;
|
|
if (num5 > 0.0f)
|
|
{
|
|
if (num5 > 60.0f)
|
|
num5 = 60f;
|
|
pathCounter += (int)(num5 / 20.0f * 20.0f);
|
|
}
|
|
}
|
|
theEntity.FindPath(moveToLocation, theEntity.GetMoveSpeedAggro(), true, this);
|
|
}
|
|
}
|
|
if (theEntity.Climbing)
|
|
return;
|
|
theEntity.SetLookPosition(!theEntity.CanSee(entityTarget) || theEntity.IsBreakingBlocks ? Vector3.zero : entityTarget.getHeadPosition());
|
|
if (!flag)
|
|
{
|
|
if (theEntity.navigator.noPathAndNotPlanningOne() && pathCounter > 0 && _x < 2.1f)
|
|
theEntity.moveHelper.SetMoveTo(GetMoveToLocation(maxDist), true);
|
|
}
|
|
else
|
|
{
|
|
theEntity.moveHelper.Stop();
|
|
pathCounter = 0;
|
|
}
|
|
float num6 = isTargetToEat ? num1 : num1 - 0.1f;
|
|
float num7 = num6 * num6;
|
|
if ((targetXzDistanceSq > num7 ? 0 : (num4 < 1.25f ? 1 : 0)) == 0)
|
|
{
|
|
RebirthUtilities.CheckForOpenDoor(theEntity);
|
|
return;
|
|
}
|
|
theEntity.IsBreakingBlocks = false;
|
|
theEntity.IsBreakingDoors = false;
|
|
if (theEntity.bodyDamage.HasLimbs && !theEntity.Electrocuted)
|
|
theEntity.RotateTo(vector3_1.x, vector3_1.y, vector3_1.z, 30f, 30f);
|
|
if (isTargetToEat)
|
|
{
|
|
isEating = true;
|
|
theEntity.IsEating = true;
|
|
attackTimeout = 20;
|
|
eatCount = 0;
|
|
}
|
|
else
|
|
{
|
|
if ((theEntity.GetDamagedTarget() == entityTarget ? 1 : (!(entityTarget != null) ? 0 : (entityTarget.GetDamagedTarget() == theEntity ? 1 : 0))) != 0)
|
|
{
|
|
homeTimeout = theEntity.IsSleeper ? cSleeperChaseTime : 0;// chaseTimeMax;
|
|
if (blockTargetTask != null)
|
|
blockTargetTask.canExecute = false;
|
|
theEntity.ClearDamagedTarget();
|
|
if (entityTarget)
|
|
entityTarget.ClearDamagedTarget();
|
|
}
|
|
if (attackTimeout > 0)
|
|
return;
|
|
if (manager.groupCircle > 0.0f)
|
|
{
|
|
Entity targetIfAttackedNow = theEntity.GetTargetIfAttackedNow();
|
|
if (targetIfAttackedNow != entityTarget && (!(bool)entityTarget.AttachedToEntity || entityTarget.AttachedToEntity != targetIfAttackedNow))
|
|
{
|
|
if (!(targetIfAttackedNow != null))
|
|
return;
|
|
relocateTicks = 46;
|
|
Vector3 vector3_3 = (theEntity.position - vector3_1).normalized * (num6 + 1.1f);
|
|
float y = RandomFloat * 28.0f + 18.0f;
|
|
if (RandomFloat < 0.5f)
|
|
y = -y;
|
|
Vector3 vector3_4 = Quaternion.Euler(0.0f, y, 0.0f) * vector3_3;
|
|
theEntity.FindPath(vector3_1 + vector3_4, theEntity.GetMoveSpeedAggro(), true, (EAIBase)this);
|
|
return;
|
|
}
|
|
}
|
|
theEntity.SleeperSupressLivingSounds = false;
|
|
if (!theEntity.Attack(false))
|
|
return;
|
|
attackTimeout = theEntity.GetAttackTimeoutTicks();
|
|
theEntity.Attack(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
private float GetTargetXZDistanceSq(float estimatedTicks)
|
|
{
|
|
Vector3 vector = entityTarget.position;
|
|
vector += entityTargetVel * estimatedTicks;
|
|
if (isTargetToEat)
|
|
{
|
|
vector = entityTarget.getBellyPosition();
|
|
}
|
|
Vector3 vector2 = theEntity.position + theEntity.motion * estimatedTicks - vector;
|
|
vector2.y = 0f;
|
|
return vector2.sqrMagnitude;
|
|
}
|
|
|
|
/*private Vector3 GetMoveToLocation(float maxDist)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation entityTarget: " + entityTarget.EntityClass.entityClassName);
|
|
Vector3 vector = entityTarget.position;
|
|
|
|
vector += entityTargetVel * 6f;
|
|
if (isTargetToEat)
|
|
{
|
|
vector = entityTarget.getBellyPosition();
|
|
}
|
|
vector = entityTarget.world.FindSupportingBlockPos(vector);
|
|
if (maxDist > 0f)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation 1");
|
|
Vector3 vector2 = new Vector3(theEntity.position.x, vector.y, theEntity.position.z);
|
|
Vector3 vector3 = vector - vector2;
|
|
float magnitude = vector3.magnitude;
|
|
if (magnitude < 3f)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation 2");
|
|
if (magnitude <= maxDist)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation 3");
|
|
float num = vector.y - theEntity.position.y;
|
|
if (num < -3f || num > 1.5f)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation 4");
|
|
return vector;
|
|
}
|
|
return vector2;
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation 5");
|
|
vector3 *= maxDist / magnitude;
|
|
Vector3 vector4 = vector - vector3;
|
|
vector4.y += 0.51f;
|
|
Vector3i pos = World.worldToBlockPos(vector4);
|
|
BlockValue block = entityTarget.world.GetBlock(pos);
|
|
Block block2 = block.Block;
|
|
if (block2.PathType <= 0)
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation 6");
|
|
RaycastHit raycastHit;
|
|
if (Physics.Raycast(vector4 - Origin.position, Vector3.down, out raycastHit, 1.02f, 1082195968))
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation 7");
|
|
vector4.y = raycastHit.point.y + Origin.position.y;
|
|
return vector4;
|
|
}
|
|
if (block2.IsElevator((int)block.rotation))
|
|
{
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation 8");
|
|
vector4.y = vector.y;
|
|
return vector4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//Log.Out("EAIApproachAndAttackTargetZombieRebirth-GetMoveToLocation 9");
|
|
return vector;
|
|
}*/
|
|
|
|
public Vector3 GetMoveToLocation(float maxDist)
|
|
{
|
|
Vector3 pos = entityTarget.position + entityTargetVel * 6f;
|
|
if (isTargetToEat)
|
|
pos = entityTarget.getBellyPosition();
|
|
Vector3 supportingBlockPos = entityTarget.world.FindSupportingBlockPos(pos);
|
|
if (maxDist > 0.0f)
|
|
{
|
|
Vector3 vector3_1 = new Vector3(theEntity.position.x, supportingBlockPos.y, theEntity.position.z);
|
|
Vector3 vector3_2 = supportingBlockPos - vector3_1;
|
|
float magnitude = vector3_2.magnitude;
|
|
if (magnitude < 3.0f)
|
|
{
|
|
if (magnitude <= maxDist)
|
|
{
|
|
float num = supportingBlockPos.y - theEntity.position.y;
|
|
return num < -3.0f || num > 1.5f ? supportingBlockPos : vector3_1;
|
|
}
|
|
Vector3 vector3_3 = vector3_2 * (maxDist / magnitude);
|
|
Vector3 _worldPos = supportingBlockPos - vector3_3;
|
|
_worldPos.y += 0.51f;
|
|
BlockValue block1 = entityTarget.world.GetBlock(World.worldToBlockPos(_worldPos));
|
|
Block block2 = block1.Block;
|
|
if (block2.PathType <= 0)
|
|
{
|
|
RaycastHit hitInfo;
|
|
if (Physics.Raycast(_worldPos - Origin.position, Vector3.down, out hitInfo, 1.02f, 1082195968))
|
|
{
|
|
_worldPos.y = hitInfo.point.y + Origin.position.y;
|
|
return _worldPos;
|
|
}
|
|
if (block2.IsElevator((int)block1.rotation))
|
|
{
|
|
_worldPos.y = supportingBlockPos.y;
|
|
return _worldPos;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return supportingBlockPos;
|
|
}
|
|
public override string ToString()
|
|
{
|
|
ItemValue holdingItemItemValue = theEntity.inventory.holdingItemItemValue;
|
|
int holdingItemIdx = theEntity.inventory.holdingItemIdx;
|
|
ItemAction itemAction = holdingItemItemValue.ItemClass.Actions[holdingItemIdx];
|
|
float num = 1.095f;
|
|
if (!isTargetToEat && itemAction != null)
|
|
{
|
|
num = itemAction.Range;
|
|
if (num == 0f)
|
|
{
|
|
num = EffectManager.GetItemValue(PassiveEffects.MaxRange, holdingItemItemValue, 0f);
|
|
}
|
|
}
|
|
float value = isTargetToEat ? num : (num - 0.1f);
|
|
float targetXZDistanceSq = GetTargetXZDistanceSq(0f);
|
|
return string.Format("{0}, {1}{2}{3}{4}{5} dist {6} rng {7} timeout {8}", new object[]
|
|
{
|
|
base.ToString(),
|
|
entityTarget ? entityTarget.EntityName : "",
|
|
theEntity.CanSee(entityTarget) ? "(see)" : "",
|
|
theEntity.navigator.noPathAndNotPlanningOne() ? "(-path)" : (theEntity.navigator.noPath() ? "(!path)" : ""),
|
|
isTargetToEat ? "(eat)" : "",
|
|
isGoingHome ? "(Going home)" : "",
|
|
Mathf.Sqrt(targetXZDistanceSq).ToCultureInvariantString("0.000"),
|
|
value.ToCultureInvariantString("0.000"),
|
|
homeTimeout.ToCultureInvariantString("0.00")
|
|
});
|
|
}
|
|
|
|
}
|