public void CalculateSplashCenterByStatic(CalculateSplashCenterByStaticHitEvent evt, SplashWeaponNode weapon)
{
SplashHitData splashHit = evt.SplashHit;
StaticHit staticHit = splashHit.StaticHit;
splashHit.SplashCenter = staticHit.Position + (staticHit.Normal * 0.01f);
}
public void PrepareSplashTargetsWhenBlockedWeapon(ShotPrepareEvent evt, BlockedWeaponNode weapon)
{
WeaponBlockedComponent weaponBlocked = weapon.weaponBlocked;
StaticHit staticHit = new StaticHit {
Position = weaponBlocked.BlockPoint,
Normal = weaponBlocked.BlockNormal
};
SplashHitData splashHit = SplashHitData.CreateSplashHitData(new List <HitTarget>(), staticHit, weapon.Entity);
base.ScheduleEvent(new CollectSplashTargetsEvent(splashHit), weapon);
}
public void SendHit(SendHitToServerIfNeedEvent evt, UnblockedWeaponNode weapon)
{
WeaponHitComponent weaponHit = weapon.weaponHit;
StaticHit staticHit = null;
List <HitTarget> targets = new List <HitTarget>(4);
if (evt.TargetingData.HasTargetHit())
{
if (!weaponHit.RemoveDuplicateTargets)
{
targets = HitTargetAdapter.Adapt(evt.TargetingData.BestDirection.Targets);
}
else
{
HashSet <Entity> set = new HashSet <Entity>();
int num = 0;
while (num < evt.TargetingData.Directions.Count)
{
DirectionData data = evt.TargetingData.Directions[num];
int num2 = 0;
while (true)
{
if (num2 >= data.Targets.Count)
{
num++;
break;
}
TargetData targetData = data.Targets[num2];
if (set.Add(targetData.TargetEntity))
{
targets.Add(HitTargetAdapter.Adapt(targetData));
}
num2++;
}
}
}
}
if (weaponHit.SendStaticHit && evt.TargetingData.HasStaticHit())
{
staticHit = evt.TargetingData.BestDirection.StaticHit;
}
if ((staticHit == null) && (targets.Count == 0))
{
base.ScheduleEvent <SelfHitSkipEvent>(weapon);
}
else
{
base.ScheduleEvent(new SendHitToServerEvent(evt.TargetingData, targets, staticHit), weapon);
}
}
public static void ExecuteSplashExplosion(Entity mine, Entity tank, Vector3 splashCenter)
{
StaticHit staticHit = new StaticHit {
Normal = Vector3.up,
Position = splashCenter
};
SplashHitData splashHit = SplashHitData.CreateSplashHitData(new List <HitTarget>(), staticHit, mine);
HashSet <Entity> set = new HashSet <Entity> {
tank
};
splashHit.ExcludedEntityForSplashHit = set;
EngineService.Engine.ScheduleEvent <SendTankMovementEvent>(tank);
EngineService.Engine.ScheduleEvent(new CollectSplashTargetsEvent(splashHit), mine);
}
private void UpdateHitData(HitNode weapon, TargetingData targetingData, bool skipTimeoutCheck)
{
StreamHitConfigComponent streamHitConfig = weapon.streamHitConfig;
StreamHitCheckingComponent streamHitChecking = weapon.streamHitChecking;
StreamHitComponent streamHit = weapon.streamHit;
HitTarget tankHit = GetTankHit(targetingData);
DirectionData bestDirection = targetingData.BestDirection;
weapon.streamHitChecking.LastCheckTime = UnityTime.time;
streamHit.TankHit = tankHit;
streamHit.StaticHit = bestDirection.StaticHit;
StaticHit staticHit = !streamHitConfig.DetectStaticHit ? null : bestDirection.StaticHit;
bool flag = false;
bool flag2 = false;
if (!this.IsSameTank(tankHit, streamHitChecking.LastSentTankHit))
{
flag = true;
}
else if (skipTimeoutCheck || ((streamHitChecking.LastSendToServerTime + streamHitConfig.SendToServerPeriod) < UnityTime.time))
{
if (!IsAlmostEqual(staticHit, streamHitChecking.LastSentStaticHit))
{
flag2 = true;
}
else if (!this.IsAlmostEqual(tankHit, streamHitChecking.LastSentTankHit))
{
flag2 = true;
}
}
if (flag)
{
weapon.Entity.RemoveComponent <StreamHitComponent>();
this.AddStreamHit(weapon.Entity, targetingData, streamHitConfig, streamHitChecking);
}
else if (flag2)
{
base.ScheduleEvent(new SelfUpdateStreamHitEvent(tankHit, staticHit), weapon);
this.SaveHitSentToServer(streamHitChecking, streamHit);
}
}
public void CollectSplashTarget(StartSplashEffectEvent e, SplashEffectNode effect, [JoinByTank] SelfTankNode selfTank, [JoinByTeam] ICollection <RemoteTankNode> remoteTanks)
{
StaticHit staticHit = new StaticHit {
Normal = Vector3.up,
Position = selfTank.rigidbody.Rigidbody.position + (this.SPLASH_CENTER_HEIGHT * (selfTank.rigidbody.Rigidbody.rotation * Vector3.up))
};
SplashHitData splashHit = SplashHitData.CreateSplashHitData(new List <HitTarget>(), staticHit, effect.Entity);
HashSet <Entity> set = new HashSet <Entity> {
selfTank.Entity
};
splashHit.ExcludedEntityForSplashHit = set;
if (!effect.splashEffect.CanTargetTeammates)
{
foreach (RemoteTankNode node in remoteTanks)
{
splashHit.ExcludedEntityForSplashHit.Add(node.Entity);
}
}
base.ScheduleEvent <SendTankMovementEvent>(selfTank);
base.ScheduleEvent(new CollectSplashTargetsEvent(splashHit), effect);
}
public void Collect(TargetValidator validator, float fullDistance, DirectionData direction, int layerMask = 0)
{
Ray ray = new Ray {
origin = direction.Origin,
direction = direction.Dir
};
float num = 0f;
validator.Begin();
Entity entity = null;
HashSet <Entity> set = new HashSet <Entity>();
int num2 = SAFE_ITERATION_LIMIT;
int num3 = (layerMask == 0) ? validator.LayerMask : layerMask;
while (true)
{
RaycastHit hit;
if ((num2 > 0) && Physics.Raycast(ray, out hit, fullDistance - num, num3))
{
StaticHit hit2;
num2--;
float distance = hit.distance;
num += distance;
Rigidbody rigidbody = hit.rigidbody;
TargetBehaviour behaviour = !rigidbody ? null : rigidbody.GetComponentInParent <TargetBehaviour>();
Vector3 normal = hit.normal;
if (!rigidbody || ((behaviour == null) || (behaviour.TargetEntity == null)))
{
hit2 = new StaticHit {
Position = PhysicsUtil.GetPulledHitPoint(hit),
Normal = hit.normal
};
direction.StaticHit = hit2;
if (!validator.BreakOnStaticHit())
{
ray = validator.ContinueOnStaticHit(ray, normal, distance);
continue;
}
}
else
{
Entity targetEntity = behaviour.TargetEntity;
if (set.Contains(targetEntity) || targetEntity.Equals(entity))
{
ray = validator.Continue(ray, hit.distance);
continue;
}
entity = targetEntity;
if (validator.CanSkip(targetEntity) || behaviour.CanSkip(this.ownerEntity))
{
ray = validator.Continue(ray, hit.distance);
continue;
}
if (validator.AcceptAsTarget(targetEntity) && behaviour.AcceptAsTarget(this.ownerEntity))
{
TargetData targetData = BattleCache.targetData.GetInstance().Init(behaviour.TargetEntity, behaviour.TargetIcarnationEntity);
validator.FillTargetData(targetData, hit, behaviour.gameObject, ray, num);
direction.Targets.Add(targetData);
set.Add(targetEntity);
if (!validator.BreakOnTargetHit(targetEntity))
{
ray = validator.ContinueOnTargetHit(ray, normal, distance);
continue;
}
}
else
{
hit2 = new StaticHit {
Position = PhysicsUtil.GetPulledHitPoint(hit),
Normal = hit.normal
};
direction.StaticHit = hit2;
if (!validator.BreakOnStaticHit())
{
ray = validator.ContinueOnStaticHit(ray, normal, distance);
continue;
}
}
}
}
return;
}
}
private void ProcessRicochet(BulletComponent bullet, StaticHit staticHit)
{
bullet.Position = staticHit.Position - (bullet.Direction * bullet.Radius);
Vector3 direction = bullet.Direction;
bullet.Direction = (direction - ((2f * Vector3.Dot(direction, staticHit.Normal)) * staticHit.Normal)).normalized;
}
private static bool IsAlmostEqual(StaticHit staticHit, StaticHit lastSentStaticHit) => ((staticHit != null) || (lastSentStaticHit != null)) ? ((staticHit != null) && ((lastSentStaticHit != null) && MathUtil.NearlyEqual(staticHit.Position, lastSentStaticHit.Position, NEAR_HIT_POSITION_EPSILON))) : true;
private void CalculateAndSendSplashImpactEffectByBaseEvent(List <HitTarget> splashTargets, StaticHit staticHit, List <HitTarget> targets, SplashImpactNode weapon, TankPhysicsNode tank)
{
SplashImpactComponent splashImpact = weapon.splashImpact;
SplashWeaponComponent splashWeapon = weapon.splashWeapon;
Vector3 vector = (staticHit == null) ? targets[0].TargetPosition : staticHit.Position;
float impactWeakeningByRange = 1f;
if (weapon.Entity.HasComponent <DamageWeakeningByDistanceComponent>())
{
float magnitude = (tank.rigidBody.Rigidbody.position - vector).magnitude;
impactWeakeningByRange = base.GetImpactWeakeningByRange(magnitude, weapon.Entity.GetComponent <DamageWeakeningByDistanceComponent>());
}
foreach (HitTarget target in splashTargets)
{
float hitDistance = target.HitDistance;
float splashImpactWeakeningByRange = this.GetSplashImpactWeakeningByRange(hitDistance, splashWeapon);
ImpactEvent eventInstance = new ImpactEvent();
Vector3 vector4 = (Vector3.Normalize(target.HitDirection) * splashImpact.ImpactForce) * WeaponConstants.WEAPON_FORCE_MULTIPLIER;
eventInstance.Force = (vector4 * impactWeakeningByRange) * splashImpactWeakeningByRange;
eventInstance.LocalHitPoint = target.LocalHitPoint;
eventInstance.WeakeningCoeff = splashImpactWeakeningByRange;
Entity[] entities = new Entity[] { weapon.Entity, target.Entity };
base.NewEvent(eventInstance).AttachAll(entities).Schedule();
}
}
public SelfUpdateStreamHitEvent(HitTarget tankHit, StaticHit staticHit) : base(tankHit, staticHit)
{
}
