public void SendHitEvent(TargetingEvent e, SingleNode <BulletComponent> bulletNode, [JoinByTank] UnblockedWeaponNode weaponNode, [JoinByTank] SingleNode <TankSyncComponent> tankNode)
{
if (!e.TargetingData.HasBaseStaticHit())
{
foreach (DirectionData data in e.TargetingData.Directions)
{
if (data.HasTargetHit())
{
TargetData targetData = data.Targets.First <TargetData>();
if (targetData.TargetEntity.HasComponent <TankActiveStateComponent>())
{
this.PrepareTargetData(targetData, bulletNode.component);
SelfHitEvent event3 = new SelfHitEvent();
List <HitTarget> list = new List <HitTarget> {
HitTargetAdapter.Adapt(targetData)
};
event3.Targets = list;
event3.ShotId = bulletNode.component.ShotId;
SelfHitEvent eventInstance = event3;
base.ScheduleEvent(eventInstance, weaponNode.Entity);
break;
}
}
}
}
}
private bool IsTargetVisable(SelfDroneWeapon droneWeapon)
{
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
TargetingEvent eventInstance = BattleCache.targetingEvent.GetInstance().Init(targetingData);
base.ScheduleEvent(eventInstance, droneWeapon);
if (targetingData.HasTargetHit())
{
using (List <DirectionData> .Enumerator enumerator = targetingData.Directions.GetEnumerator())
{
while (true)
{
if (!enumerator.MoveNext())
{
break;
}
DirectionData current = enumerator.Current;
if (current.HasTargetHit() && current.Targets[0].ValidTarget)
{
return(true);
}
}
}
}
return(false);
}
public void Targeting(UnitSelectTargetEvent evt, UnitTargetingNode unit, [JoinSelf] Optional <SingleNode <UnitTargetComponent> > unitTargetNode)
{
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
TargetingEvent eventInstance = BattleCache.targetingEvent.GetInstance().Init(targetingData);
base.ScheduleEvent(eventInstance, unit);
if ((targetingData.BestDirection != null) && targetingData.BestDirection.HasTargetHit())
{
Entity targetEntity = targetingData.BestDirection.Targets[0].TargetEntity;
Entity targetIncorantionEntity = targetingData.BestDirection.Targets[0].TargetIncorantionEntity;
if (targetEntity.HasComponent <EnemyComponent>())
{
if (unitTargetNode.IsPresent())
{
if (unitTargetNode.Get().component.Target.Equals(targetEntity))
{
return;
}
unit.Entity.RemoveComponent <UnitTargetComponent>();
}
UnitTargetComponent component = new UnitTargetComponent {
Target = targetEntity,
TargetIncarnation = targetIncorantionEntity
};
unit.Entity.AddComponent(component);
}
}
}
public void PrepareTargeting(TargetingEvent evt, WeaponNode weapon, [JoinByTank] TankNode tank)
{
TargetingData targetingData = evt.TargetingData;
VerticalSectorsTargetingComponent verticalSectorsTargeting = weapon.verticalSectorsTargeting;
MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance);
targetingData.Origin = accessor.GetBarrelOriginWorld();
targetingData.Dir = accessor.GetFireDirectionWorld();
targetingData.FullDistance = verticalSectorsTargeting.WorkDistance;
targetingData.MaxAngle = (verticalSectorsTargeting.VAngleUp <= verticalSectorsTargeting.VAngleDown) ? verticalSectorsTargeting.VAngleDown : verticalSectorsTargeting.VAngleUp;
LinkedList <TargetSector> instance = BattleCache.targetSectors.GetInstance();
instance.Clear();
CollectTargetSectorsEvent eventInstance = BattleCache.collectTargetSectorsEvent.GetInstance().Init();
eventInstance.TargetSectors = instance;
TargetingCone cone = new TargetingCone {
VAngleUp = verticalSectorsTargeting.VAngleUp,
VAngleDown = verticalSectorsTargeting.VAngleDown,
HAngle = verticalSectorsTargeting.HAngle,
Distance = verticalSectorsTargeting.WorkDistance
};
eventInstance.TargetingCone = cone;
base.ScheduleEvent(eventInstance, weapon);
CollectSectorDirectionsEvent event3 = BattleCache.collectSectorDirectionsEvent.GetInstance().Init();
event3.TargetSectors = instance;
event3.TargetingData = targetingData;
base.ScheduleEvent(event3, weapon);
base.ScheduleEvent(BattleCache.collectTargetsEvent.GetInstance().Init(targetingData), weapon);
base.ScheduleEvent(BattleCache.targetEvaluateEvent.GetInstance().Init(targetingData), weapon);
}
public void SaveLastDirection(TargetingEvent e, EvaluatorNode weapon)
{
if (e.TargetingData.HasTargetHit())
{
base.Log.Debug("SaveLastDirection");
weapon.isisTargetEvaluator.LastDirectionIndex = new int?(e.TargetingData.BestDirectionIndex);
}
}
public void PrepareTargeting(TargetingEvent evt, TargetingNode conicTargeting)
{
TargetingData targetingData = evt.TargetingData;
ConicTargetingComponent component = conicTargeting.conicTargeting;
MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(conicTargeting.muzzlePoint, conicTargeting.weaponInstance);
targetingData.Origin = accessor.GetWorldPositionShiftDirectionBarrel(component.FireOriginOffsetCoeff);
targetingData.Dir = accessor.GetFireDirectionWorld();
targetingData.FullDistance = component.WorkDistance;
targetingData.MaxAngle = component.HalfConeAngle;
base.ScheduleEvent(BattleCache.collectDirectionsEvent.GetInstance().Init(targetingData), conicTargeting);
base.ScheduleEvent(BattleCache.collectTargetsEvent.GetInstance().Init(targetingData), conicTargeting);
base.ScheduleEvent(BattleCache.targetEvaluateEvent.GetInstance().Init(targetingData), conicTargeting);
}
public void PrepareTargeting(TargetingEvent evt, TargetingNode verticalTargeting)
{
TargetingData targetingData = evt.TargetingData;
VerticalTargetingComponent component = verticalTargeting.verticalTargeting;
MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(verticalTargeting.muzzlePoint, verticalTargeting.weaponInstance);
targetingData.Origin = accessor.GetWorldPosition();
targetingData.Dir = accessor.GetFireDirectionWorld();
targetingData.FullDistance = component.WorkDistance;
targetingData.MaxAngle = (component.AngleUp <= component.AngleDown) ? component.AngleDown : component.AngleUp;
base.ScheduleEvent(BattleCache.collectDirectionsEvent.GetInstance().Init(targetingData), verticalTargeting);
base.ScheduleEvent(BattleCache.collectTargetsEvent.GetInstance().Init(targetingData), verticalTargeting);
base.ScheduleEvent(BattleCache.targetEvaluateEvent.GetInstance().Init(targetingData), verticalTargeting);
}
public void PrepareTargeting(TargetingEvent evt, BulletTargetingNode barelTargetingNode)
{
TargetingData targetingData = evt.TargetingData;
BulletTargetingComponent bulletTargeting = barelTargetingNode.bulletTargeting;
CollectDirection(targetingData.Origin, targetingData.Dir, 0f, targetingData);
Vector3 normalized = Vector3.Cross(targetingData.Dir, Vector3.up).normalized;
float num = 360f / bulletTargeting.RadialRaysCount;
for (int i = 0; i < bulletTargeting.RadialRaysCount; i++)
{
Vector3 vector3 = (Vector3)(Quaternion.AngleAxis(num * i, targetingData.Dir) * normalized);
Vector3 origin = targetingData.Origin + (vector3 * bulletTargeting.Radius);
CollectDirection(origin, targetingData.Dir, 0f, targetingData);
}
base.ScheduleEvent(BattleCache.collectTargetsEvent.GetInstance().Init(targetingData), barelTargetingNode);
base.ScheduleEvent(BattleCache.targetEvaluateEvent.GetInstance().Init(targetingData), barelTargetingNode);
}
public void CollectDirections(TargetingEvent evt, TargetingNode targeting, [JoinAll] ICollection <ActiveRemoteTank> enemyTankNodes)
{
Rigidbody rigidbody = targeting.rigidbody.Rigidbody;
Vector3 origin = rigidbody.position + (Vector3.up * 1.5f);
TargetingData targetingData = evt.TargetingData;
targetingData.FullDistance = targeting.unitTargetingConfig.WorkDistance;
foreach (ActiveRemoteTank tank in enemyTankNodes)
{
Rigidbody rigidbody2 = tank.rigidbody.Rigidbody;
Vector3 forward = rigidbody.transform.forward;
Vector3 vector3 = rigidbody2.position - origin;
if (vector3.magnitude <= targeting.unitTargetingConfig.WorkDistance)
{
Vector3 normalized = (rigidbody2.position - origin).normalized;
CollectDirection(origin, normalized, Mathf.Acos(Vector3.Dot(forward, normalized)), targetingData);
}
}
base.ScheduleEvent(AbstractDirectionsCollectorSystem.BattleCache.collectTargetsEvent.GetInstance().Init(targetingData), targeting);
base.ScheduleEvent(AbstractDirectionsCollectorSystem.BattleCache.targetEvaluateEvent.GetInstance().Init(targetingData), targeting);
}
