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 CollectTargetSectors(CollectTargetSectorsEvent e, WeaponNode weaponNode, [JoinByBattle] ICollection <TargetTankNode> targetTankNodes, WeaponNode weaponNode1, [JoinByTank] OwnerTankNode ownerTankNode, [JoinByTeam] Optional <TeamNode> team) { MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weaponNode.muzzlePoint, weaponNode.weaponInstance); bool flag = team.IsPresent(); long num = !flag ? 0L : team.Get().teamGroup.Key; LookAt lookAt = new LookAt { Position = accessor.GetBarrelOriginWorld(), Forward = accessor.GetFireDirectionWorld(), Left = accessor.GetLeftDirectionWorld(), Up = accessor.GetUpDirectionWorld() }; IEnumerator <TargetTankNode> enumerator = targetTankNodes.GetEnumerator(); while (enumerator.MoveNext()) { TargetTankNode current = enumerator.Current; if (!ownerTankNode.Entity.Equals(current.Entity) && (!flag || (num != current.Entity.GetComponent <TeamGroupComponent>().Key))) { BoxCollider tankToTankCollider = (BoxCollider)current.tankColliders.TankToTankCollider; LookTo lookTo = new LookTo { Position = tankToTankCollider.bounds.center, Radius = this.CalculateTankMinimalRadius(lookAt.Forward, tankToTankCollider) }; this.AddTargetSector(lookAt, lookTo, e.TargetingCone, e.TargetSectors, e.VAllowableAngleAcatter, e.HAllowableAngleAcatter); } } }
private bool IsWeaponBlocked(MuzzleLogicAccessor muzzlePoint, int mask, out RaycastHit hitInfo, GameObject[] raycastExclusionGameObjects) { Vector3 worldPosition = muzzlePoint.GetWorldPosition(); Vector3 barrelOriginWorld = muzzlePoint.GetBarrelOriginWorld(); float distance = (worldPosition - barrelOriginWorld).magnitude + 0.1f; return(PhysicsUtil.RaycastWithExclusion(barrelOriginWorld, worldPosition - barrelOriginWorld, out hitInfo, distance, mask, raycastExclusionGameObjects)); }
private bool IsWeaponUnderground(MuzzleLogicAccessor muzzlePoint, int mask, TankNode tank, GameObject[] raycastExclusionGameObjects) { RaycastHit hit; Vector3 center = tank.tankColliders.BoundsCollider.bounds.center; Vector3 dir = muzzlePoint.GetBarrelOriginWorld() - center; return(PhysicsUtil.RaycastWithExclusion(center, dir, out hit, dir.magnitude, mask, raycastExclusionGameObjects)); }
public void ApplyKickback(FixedUpdateEvent evt, KickbackNode weapon, [JoinByTank] TankNode tank) { KickbackComponent kickback = weapon.kickback; MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance); float deltaTime = evt.DeltaTime; VulcanPhysicsUtils.ApplyVulcanForce(((-accessor.GetFireDirectionWorld() * kickback.KickbackForce) * WeaponConstants.WEAPON_FORCE_MULTIPLIER) * deltaTime, tank.rigidbody.Rigidbody, accessor.GetWorldMiddlePosition(), tank.tankFalling, tank.track); }
public void StartKickback(BaseShotEvent evt, KickbackNode weapon, [JoinByTank] TankNode tank) { KickbackComponent kickback = weapon.kickback; MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance); Vector3 vector = -accessor.GetFireDirectionWorld() * kickback.KickbackForce; Vector3 worldPosition = accessor.GetWorldPosition(); tank.rigidbody.Rigidbody.AddForceAtPositionSafe(vector * WeaponConstants.WEAPON_FORCE_MULTIPLIER, worldPosition); }
public void PrepareTargetsAtFirstFrame(NodeAddedEvent e, BulletNode bulletNode, [JoinByTank] WeaponNode weaponNode) { MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weaponNode.muzzlePoint, weaponNode.weaponInstance); Vector3 barrelOriginWorld = accessor.GetBarrelOriginWorld(); TargetingData targetingData = BattleCache.targetingData.GetInstance().Init(); targetingData.Origin = barrelOriginWorld; targetingData.Dir = bulletNode.bullet.Direction; targetingData.FullDistance = (accessor.GetWorldPosition() - barrelOriginWorld).magnitude * 1.2f; base.ScheduleEvent(BattleCache.targetingEvent.GetInstance().Init(targetingData), bulletNode); base.ScheduleEvent(BattleCache.updateBulletEvent.GetInstance().Init(targetingData), bulletNode); }
public void UpdateVerticalTargetingAngle(WeaponRotationUpdateVerticalEvent e, AimingVerticalTargetingControllerNode weapon, [JoinByUser] SingleNode <MouseControlStateHolderComponent> mouseControlStateHolder) { float min = -weapon.verticalSectorsTargeting.VAngleDown; float vAngleUp = weapon.verticalSectorsTargeting.VAngleUp; float maxVerticalSpeed = weapon.shaftAimingSpeed.MaxVerticalSpeed; float verticalAcceleration = weapon.shaftAimingSpeed.VerticalAcceleration; int shaftElevationDirectionByKeyboard = weapon.weaponRotationControl.ShaftElevationDirectionByKeyboard; bool mouseControlEnable = mouseControlStateHolder.component.MouseControlEnable; if (!mouseControlEnable) { weapon.weaponRotationControl.MouseShaftAimCumulativeVerticalAngle = 0f; } else { shaftElevationDirectionByKeyboard = (int)Mathf.Sign(weapon.weaponRotationControl.MouseShaftAimCumulativeVerticalAngle); weapon.weaponRotationControl.MouseShaftAimCumulativeVerticalAngle = Mathf.Clamp(weapon.weaponRotationControl.MouseShaftAimCumulativeVerticalAngle, min - weapon.shaftAimingWorkingState.VerticalAngle, vAngleUp - weapon.shaftAimingWorkingState.VerticalAngle); } bool isInputActive = false; if (weapon.shaftAimingWorkingState.VerticalElevationDir != shaftElevationDirectionByKeyboard) { weapon.shaftAimingWorkingState.VerticalSpeed = 0f; weapon.shaftAimingWorkingState.VerticalElevationDir = shaftElevationDirectionByKeyboard; isInputActive = shaftElevationDirectionByKeyboard != 0; } else { weapon.shaftAimingWorkingState.VerticalElevationDir = shaftElevationDirectionByKeyboard; weapon.shaftAimingWorkingState.VerticalSpeed += verticalAcceleration * e.DeltaTime; weapon.shaftAimingWorkingState.VerticalSpeed = Mathf.Clamp(weapon.shaftAimingWorkingState.VerticalSpeed, 0f, maxVerticalSpeed); float num6 = (shaftElevationDirectionByKeyboard * weapon.shaftAimingWorkingState.VerticalSpeed) * e.DeltaTime; if (!mouseControlEnable) { isInputActive = num6 != 0f; weapon.shaftAimingWorkingState.VerticalAngle += num6; weapon.shaftAimingWorkingState.VerticalAngle = Mathf.Clamp(weapon.shaftAimingWorkingState.VerticalAngle, min, vAngleUp); } else if (!weapon.weaponRotationControl.BlockRotate) { num6 = (shaftElevationDirectionByKeyboard <= 0) ? Mathf.Clamp(num6, weapon.weaponRotationControl.MouseShaftAimCumulativeVerticalAngle, 0f) : Mathf.Clamp(num6, 0f, weapon.weaponRotationControl.MouseShaftAimCumulativeVerticalAngle); isInputActive = num6 != 0f; weapon.weaponRotationControl.MouseShaftAimCumulativeVerticalAngle -= num6; weapon.shaftAimingWorkingState.VerticalAngle += num6; weapon.shaftAimingWorkingState.VerticalAngle = Mathf.Clamp(weapon.shaftAimingWorkingState.VerticalAngle, min, vAngleUp); } } MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance); weapon.shaftAimingWorkingState.WorkingDirection = (Vector3)(Quaternion.AngleAxis(weapon.shaftAimingWorkingState.VerticalAngle, accessor.GetLeftDirectionWorld()) * accessor.GetFireDirectionWorld()); weapon.shaftAimingWorkingState.IsActive = this.CheckManualTargetingActivity(weapon.weaponRotationControl, weapon.verticalSectorsTargeting, weapon.shaftAimingWorkingState, isInputActive); }
public void CheckTargetPoint(FixedUpdateEvent evt, ShaftAimingTargetPointWorkingStateNode weapon, [JoinByTank] SelfTankNode selfTank, [JoinAll] ICollection <SingleNode <TankPartIntersectedWithCameraStateComponent> > intersectedTankParts) { ShaftAimingTargetPointComponent shaftAimingTargetPoint = weapon.shaftAimingTargetPoint; ShaftAimingTargetPointContainerComponent shaftAimingTargetPointContainer = weapon.shaftAimingTargetPointContainer; MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance); bool isInsideTankPart = weapon.shaftAimingTargetPoint.IsInsideTankPart; Vector3 barrelOriginWorld = accessor.GetBarrelOriginWorld(); float verticalAngle = weapon.shaftAimingWorkingState.VerticalAngle; Vector3 point = weapon.shaftAimingTargetPoint.Point; shaftAimingTargetPointContainer.Point = this.GetTargetPoint(barrelOriginWorld, weapon.shaftAimingWorkingState.WorkingDirection, weapon.verticalSectorsTargeting.WorkDistance, weapon.targetCollector); shaftAimingTargetPointContainer.IsInsideTankPart = intersectedTankParts.Count > 1; this.CheckTargetPointDiff(point, verticalAngle, shaftAimingTargetPoint, shaftAimingTargetPointContainer, isInsideTankPart, !weapon.shaftAimingWorkingState.IsActive ? this.EPS_INACTIVE : this.EPS_ACTIVE); }
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, 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 CollectDirections(CollectDirectionsEvent evt, TargetingNode conicTargeting) { TargetingData targetingData = evt.TargetingData; ConicTargetingComponent component = conicTargeting.conicTargeting; CollectDirection(targetingData.Origin, targetingData.Dir, 0f, targetingData); float angleStep = component.HalfConeAngle / ((float)component.HalfConeNumRays); Vector3 leftDirectionWorld = new MuzzleLogicAccessor(conicTargeting.muzzlePoint, conicTargeting.weaponInstance).GetLeftDirectionWorld(); for (int i = 0; i < component.NumSteps; i++) { base.CollectSectorDirections(targetingData.Origin, targetingData.Dir, leftDirectionWorld, angleStep, component.HalfConeNumRays, targetingData); base.CollectSectorDirections(targetingData.Origin, targetingData.Dir, leftDirectionWorld, -angleStep, component.HalfConeNumRays, targetingData); leftDirectionWorld = (Vector3)(Quaternion.AngleAxis(180f / ((float)component.NumSteps), targetingData.Dir) * leftDirectionWorld); } }
public void CollectDirections(CollectDirectionsEvent evt, VerticalTargetingNode verticalTargeting) { TargetingData targetingData = evt.TargetingData; VerticalTargetingComponent component = verticalTargeting.verticalTargeting; CollectDirection(targetingData.Origin, targetingData.Dir, 0f, targetingData); Vector3 leftDirectionWorld = new MuzzleLogicAccessor(verticalTargeting.muzzlePoint, verticalTargeting.weaponInstance).GetLeftDirectionWorld(); if (component.NumRaysUp > 0) { base.CollectSectorDirections(targetingData.Origin, targetingData.Dir, leftDirectionWorld, component.AngleUp / ((float)component.NumRaysUp), component.NumRaysUp, targetingData); } if (component.NumRaysDown > 0) { base.CollectSectorDirections(targetingData.Origin, targetingData.Dir, leftDirectionWorld, -component.AngleDown / ((float)component.NumRaysDown), component.NumRaysDown, targetingData); } }
private void ValidateShot(Entity weapon, MuzzleLogicAccessor muzzlePoint, TankNode tank, ShotValidateComponent shotValidate) { if (this.IsWeaponUnderground(muzzlePoint, shotValidate.UnderGroundValidateMask, tank, shotValidate.RaycastExclusionGameObjects)) { StateUtils.SwitchEntityState <WeaponUndergroundComponent>(weapon, this.weaponStates); } else { RaycastHit hit; if (this.IsWeaponBlocked(muzzlePoint, shotValidate.BlockValidateMask, out hit, shotValidate.RaycastExclusionGameObjects)) { this.AddOrChangeWeaponBlockedComponent(weapon, hit); } else { StateUtils.SwitchEntityState <WeaponUnblockedComponent>(weapon, this.weaponStates); } } }
public void CreateTargetPoint(NodeAddedEvent evt, ShaftAimingWorkingStateNode weapon, [JoinByTank] SelfTankNode selfTank, [JoinAll] ICollection <SingleNode <TankPartIntersectedWithCameraStateComponent> > intersectedTankParts) { bool flag = intersectedTankParts.Count > 1; Vector3 barrelOriginWorld = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance).GetBarrelOriginWorld(); Vector3 vector3 = this.GetTargetPoint(barrelOriginWorld, weapon.shaftAimingWorkingState.WorkingDirection, weapon.verticalSectorsTargeting.WorkDistance, weapon.targetCollector); ShaftAimingTargetPointContainerComponent component = new ShaftAimingTargetPointContainerComponent { Point = vector3, IsInsideTankPart = flag, PrevVerticalAngle = weapon.shaftAimingWorkingState.VerticalAngle }; weapon.Entity.AddComponent(component); ShaftAimingTargetPointComponent component3 = new ShaftAimingTargetPointComponent { Point = vector3, IsInsideTankPart = flag }; weapon.Entity.AddComponent(component3); }
public void CollectSectorDirectionsEvent(Tanks.Battle.ClientCore.API.CollectSectorDirectionsEvent evt, VerticalSectorTargetingNode verticalSectorTargeting, [JoinByTank] WeaponNode weapon) { TargetingData targetingData = evt.TargetingData; VerticalSectorsTargetingComponent verticalSectorsTargeting = verticalSectorTargeting.verticalSectorsTargeting; CollectDirection(evt.TargetingData.Origin, evt.TargetingData.Dir, 0f, targetingData); if (evt.TargetSectors.Count != 0) { Vector3 leftDirectionWorld = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance).GetLeftDirectionWorld(); TargetSectorUtils.CutSectorsByOverlap((LinkedList <TargetSector>)evt.TargetSectors, 1f / verticalSectorsTargeting.RaysPerDegree); IEnumerator <TargetSector> enumerator = evt.TargetSectors.GetEnumerator(); while (enumerator.MoveNext()) { TargetSector current = enumerator.Current; float num = current.Length(); int numRays = (int)Math.Floor((double)(verticalSectorsTargeting.RaysPerDegree * num)); this.CollectSectorDirections(targetingData, leftDirectionWorld, current, numRays); } } }
public void CheckWorkActivationState(TimeUpdateEvent evt, ShaftAimingWorkActivationWeaponControllerNode weapon) { if (!this.CheckHandleWeaponIntersectionStatus(weapon.Entity)) { if (!InputManager.CheckAction(ShotActions.SHOT)) { this.MakeQuickShot(weapon.Entity); } else if (weapon.shaftAimingWorkActivationState.ActivationTimer < weapon.shaftStateConfig.ActivationToWorkingTransitionTimeSec) { weapon.shaftAimingWorkActivationState.ActivationTimer += evt.DeltaTime; } else { MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance); ShaftAimingWorkingStateComponent component = new ShaftAimingWorkingStateComponent { InitialEnergy = weapon.weaponEnergy.Energy, WorkingDirection = accessor.GetFireDirectionWorld() }; StateUtils.SwitchEntityState(weapon.Entity, component, this.weaponStates); } } }
public void SendShot(ShotPrepareEvent evt, BlockedWeaponNode weaponNode) { MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weaponNode.muzzlePoint, weaponNode.weaponInstance); base.ScheduleEvent(new SelfShotEvent(accessor.GetFireDirectionWorld()), weaponNode); }
public void SendShot(ShaftAimingShotPrepareEvent evt, UndergroundShaftNode weapon) { MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance); base.ScheduleEvent(new SelfShotEvent(accessor.GetFireDirectionWorld()), weapon); }