public void BuildWeapon(WeaponInstanceIsReadyEvent evt, WeaponNode weapon)
{
GameObject weaponInstance = evt.WeaponInstance;
weapon.Entity.AddComponent(new WeaponInstanceComponent(weaponInstance));
weaponInstance.AddComponent <NanFixer>().Init(null, weaponInstance.transform, weapon.Entity.GetComponent <UserGroupComponent>().Key);
}
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);
}
}
}
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 EvaluateTeamTank(IsisEvaluateTeamTankEvent e, WeaponNode weapon, TeamTankNode targetTank)
{
TargetData targetData = e.TargetData;
if (e.ShooterTeamKey != targetTank.teamGroup.Key)
{
base.Log.Debug("EvaluateTeamTank: enemy team");
targetData.Priority += 2f;
}
else
{
base.Log.Debug("EvaluateTeamTank: same team");
targetData.Priority++;
HealthComponent health = targetTank.health;
if (health.CurrentHealth != health.MaxHealth)
{
base.Log.Debug("EvaluateTeamTank: not full health");
targetData.Priority += 2f;
}
TemperatureComponent temperature = targetTank.temperature;
if (temperature.Temperature > 0f)
{
base.Log.Debug("EvaluateTeamTank: positive temperature");
targetData.Priority += 5f;
}
else if (temperature.Temperature < 0f)
{
base.Log.Debug("EvaluateTeamTank: negative temperature");
targetData.Priority += 4f;
}
}
}
public void Control(FixedUpdateEvent e, AutopilotTankNode tank, [JoinByTank] WeaponNode weapon)
{
if (tank.rigidbody.Rigidbody)
{
Vector3 destination;
if (!tank.autopilotMovementController.MoveToTarget)
{
destination = tank.autopilotMovementController.Destination;
}
else
{
Entity target = tank.autopilotMovementController.Target;
if ((target == null) && tank.autopilotMovementController.MoveToTarget)
{
return;
}
if (!target.HasComponent <RigidbodyComponent>() || !target.HasComponent <TankCollidersComponent>())
{
return;
}
AutopilotMovementControllerComponent autopilotMovementController = tank.autopilotMovementController;
destination = target.GetComponent <RigidbodyComponent>().Rigidbody.position;
}
if (tank.navigationData.PathData == null)
{
PathData data = new PathData {
timeToRecalculatePath = Time.timeSinceLevelLoad
};
tank.navigationData.PathData = data;
}
this.ControlMove(tank, destination);
}
}
private void Snap(WeaponNode weapon)
{
Transform transform = weapon.weaponVisualRoot.transform;
transform.SetLocalRotationSafe(weapon.weaponInstance.WeaponInstance.transform.localRotation);
transform.localPosition = Vector3.zero;
}
private void CollectCommandsAndSend(TankNode tankNode, WeaponNode weaponNode, MoveCommandType commandType)
{
TankMovementSenderComponent tankMovementSender = tankNode.tankMovementSender;
if (((commandType & MoveCommandType.TANK) != MoveCommandType.NONE) && (tankMovementSender.LastSentMovementTime >= PreciseTime.Time))
{
commandType ^= MoveCommandType.TANK;
}
if (((commandType & MoveCommandType.WEAPON) != MoveCommandType.NONE) && (tankMovementSender.LastSentWeaponRotationTime >= PreciseTime.Time))
{
commandType ^= MoveCommandType.WEAPON;
}
Movement?nullable = null;
float? nullable3 = null;
if ((commandType & MoveCommandType.TANK) != MoveCommandType.NONE)
{
nullable = new Movement?(this.GetMovement(tankNode));
}
if ((commandType & MoveCommandType.WEAPON) != MoveCommandType.NONE)
{
nullable3 = new float?(weaponNode.weaponRotationControl.Rotation);
}
MoveCommand moveCommand = new MoveCommand {
Movement = nullable,
WeaponRotation = nullable3,
TankControlVertical = this.GetMoveAxis(tankNode),
TankControlHorizontal = this.GetTurnAxis(tankNode),
WeaponRotationControl = this.GetWeaponControl(weaponNode),
ClientTime = (int)(PreciseTime.Time * 1000.0)
};
this.SendCommand(tankNode, moveCommand);
}
public void BuildWeapon(NodeAddedEvent evt, [Combine] WeaponSkinNode skin, [Context, JoinByTank] WeaponNode weapon, SingleNode <MapInstanceComponent> map)
{
WeaponInstanceIsReadyEvent eventInstance = new WeaponInstanceIsReadyEvent {
WeaponInstance = this.CreateInstance(skin.resourceData)
};
base.NewEvent(eventInstance).Attach(weapon).ScheduleDelayed(0.3f);
}
public void InitEnemyWeapon(NodeAddedEvent e, [Combine] WeaponNode weapon, [JoinByUser, Context] RemoteTankNode remoteTank, SingleNode <GameTankSettingsComponent> settings)
{
if (settings.component.SelfTargetHitFeedbackEnabled)
{
weapon.Entity.AddComponent(new WeaponSelfTargetHitFeedbackTimerComponent(Time.time - 0.5f));
weapon.Entity.CreateGroup <WeaponSelfTargetHitFeedbackGroupComponent>();
}
}
public void UpdateWeaponRotation(UpdateEvent e, WeaponNode weapon, [JoinByTank] TankNode tank)
{
WeaponVisualRootComponent weaponVisualRoot = weapon.weaponVisualRoot;
WeaponInstanceComponent weaponInstance = weapon.weaponInstance;
weaponVisualRoot.transform.SetLocalRotationSafe(weaponInstance.WeaponInstance.transform.localRotation);
weaponVisualRoot.transform.SetLocalPositionSafe(Vector3.zero);
}
private void ApplyWeaponRotation(WeaponNode weapon, float?weaponRotation)
{
if (weaponRotation != null)
{
this.ApplyWeaponRotation(weapon.weaponInstance, weaponRotation.Value);
weapon.weaponRotationControl.Rotation = weaponRotation.Value;
}
}
public void FollowNewUser(NodeAddedEvent e, WeaponNode weapon, [JoinByUser] FollowedBattleUserNode followedBattleUser)
{
if (!weapon.Entity.HasComponent <CameraTargetComponent>())
{
CameraTargetComponent component = new CameraTargetComponent(weapon.weaponInstance.WeaponInstance);
weapon.Entity.AddComponent(component);
}
}
public void PrepareCleaningForTankParts(NodeRemoveEvent evt, WeaponNode weapon, [JoinByTank] TankNode tank, [JoinAll] SoundListenerNode listener)
{
Transform tankPartTransform = weapon.weaponSoundRoot.transform;
Transform soundRootTransform = tank.tankSoundRoot.SoundRootTransform;
float tankPartCleanTimeSec = listener.soundListenerCleaner.TankPartCleanTimeSec;
this.PrepareCleaningForTankPart(soundRootTransform, tankPartCleanTimeSec);
this.PrepareCleaningForTankPart(tankPartTransform, tankPartCleanTimeSec);
}
public void InitCollidersForChecking(NodeAddedEvent evt, TankNode tank, [Context, JoinByTank] WeaponNode weapon)
{
VisualTriggerMarkerComponent visualTriggerMarker = tank.tankVisualRoot.VisualTriggerMarker;
VisualTriggerMarkerComponent trigger = weapon.weaponVisualRoot.VisualTriggerMarker;
TankPartIntersectionWithCameraData[] map = new TankPartIntersectionWithCameraData[2];
this.AttachColliderToIntersectionMap(visualTriggerMarker, tank.Entity, map, 0);
this.AttachColliderToIntersectionMap(trigger, weapon.Entity, map, 1);
tank.Entity.AddComponent(new TankPartIntersectionWithCameraMapComponent(map));
}
public void ShotTrail(BaseShotEvent evt, WeaponNode weapon)
{
RailgunTrailComponent railgunTrail = weapon.railgunTrail;
Vector3 worldPosition = new MuzzleVisualAccessor(weapon.muzzlePoint).GetWorldPosition();
Vector3 shotDirection = evt.ShotDirection;
DirectionData data = weapon.targetCollector.Collect(worldPosition, shotDirection, 1000f, LayerMasks.VISUAL_STATIC);
Vector3 hitPosition = !data.HasAnyHit() ? (worldPosition + (shotDirection * 1000f)) : data.FirstAnyHitPosition();
this.DrawShotTrailEffect(worldPosition, hitPosition, railgunTrail.Prefab, railgunTrail.TipPrefab);
}
public void AddCameraTarget(NodeAddedEvent e, WeaponNode weapon, [Context, JoinByTank] SelfTankReadyForCameraNode tank)
{
if (!weapon.Entity.HasComponent <CameraTargetComponent>())
{
CameraTargetComponent component = new CameraTargetComponent {
TargetObject = weapon.weaponInstance.WeaponInstance.gameObject
};
weapon.Entity.AddComponent(component);
}
}
public void BuildSelf(NodeAddedEvent evt, SelfTankNode selfTank, [Context, JoinByUser] WeaponNode weaponNode, [Context, JoinByUser] UserNode user)
{
Entity entity = weaponNode.Entity;
entity.AddComponent <CooldownTimerComponent>();
entity.AddComponent <StreamWeaponControllerComponent>();
entity.AddComponent <ConicTargetingComponent>();
entity.AddComponent(new WeaponHitComponent(false, true));
entity.AddComponent(new StreamWeaponSimpleFeedbackControllerComponent());
entity.AddComponent(new TargetCollectorComponent(new TargetCollector(selfTank.Entity), new PenetrationTargetValidator(selfTank.Entity)));
}
public void OnTankInactive(NodeRemoveEvent e, SelfTankNode selfTank, [JoinByTank] WeaponNode weapon)
{
WeaponRotationControlComponent weaponRotationControl = weapon.weaponRotationControl;
if (weaponRotationControl.EffectiveControl != 0f)
{
weaponRotationControl.PrevEffectiveControl = 0f;
weaponRotationControl.EffectiveControl = 0f;
base.ScheduleEvent <WeaponRotationControlChangedEvent>(weapon);
}
}
public void UpdateActivatePossibility(UpdateEvent e, WeaponNode weaponNode, [JoinByTank, Combine] SlotNode slot, [JoinByModule] ForceFieldModuleNode module)
{
if (ForceFieldTransformUtil.CanFallToTheGround(weaponNode.weaponInstance.WeaponInstance.transform))
{
this.EnableActivation(slot.Entity);
}
else
{
this.DisableActivation(slot.Entity);
}
}
public void BuildSelf(NodeAddedEvent evt, SelfTankNode selfTank, [Context, JoinByUser] WeaponNode weaponNode, [Context, JoinByUser] UserNode user)
{
Entity entity = weaponNode.Entity;
entity.AddComponent <CooldownTimerComponent>();
entity.AddComponent <ShaftStateControllerComponent>();
entity.AddComponent <VerticalSectorsTargetingComponent>();
entity.AddComponent <DirectionEvaluatorComponent>();
entity.AddComponent <WeaponShotComponent>();
entity.AddComponent <DistanceAndAngleTargetEvaluatorComponent>();
}
public void BuildSelf(NodeAddedEvent e, SelfTankNode tank, [Context, JoinByUser] WeaponNode weapon)
{
weapon.Entity.AddComponent <CooldownTimerComponent>();
weapon.Entity.AddComponent <StreamWeaponControllerComponent>();
weapon.Entity.AddComponent <ConicTargetingComponent>();
weapon.Entity.AddComponent(new WeaponHitComponent(false, false));
weapon.Entity.AddComponent <DirectionEvaluatorComponent>();
weapon.Entity.AddComponent <DistanceAndAngleTargetEvaluatorComponent>();
TargetCollectorComponent component = new TargetCollectorComponent(new TargetCollector(tank.Entity), new TargetValidator(tank.Entity));
weapon.Entity.AddComponent(component);
}
public void BuildSelf(NodeAddedEvent evt, SelfTankNode selfTank, [Context, JoinByUser] WeaponNode weaponNode, [Context, JoinByUser] UserNode user)
{
Entity entity = weaponNode.Entity;
entity.AddComponent <CooldownTimerComponent>();
entity.AddComponent <VerticalSectorsTargetingComponent>();
entity.AddComponent(new WeaponHitComponent(false, false));
entity.AddComponent <DirectionEvaluatorComponent>();
entity.AddComponent <WeaponShotComponent>();
entity.AddComponent <DistanceAndAngleTargetEvaluatorComponent>();
entity.AddComponent(new TargetCollectorComponent(new TargetCollector(selfTank.Entity), new TargetValidator(selfTank.Entity)));
}
private void BuildWeapon(Entity tank, WeaponNode weaponNode)
{
Entity entity = weaponNode.Entity;
entity.AddComponent <CooldownTimerComponent>();
entity.AddComponent <DiscreteWeaponControllerComponent>();
entity.AddComponent <VerticalTargetingComponent>();
entity.AddComponent <DirectionEvaluatorComponent>();
entity.AddComponent <WeaponShotComponent>();
entity.AddComponent <DistanceAndAngleTargetEvaluatorComponent>();
entity.AddComponent(new TargetCollectorComponent(new TargetCollector(tank), new TargetValidator(tank)));
}
// Set the image of the primary weapon that the player owns
void setPrimary(WeaponNode primary)
{
String name = primary.Name;
String picPath = System.AppDomain.CurrentDomain.BaseDirectory + "imgs/" + name + ".png";
if (File.Exists(picPath))
{
primaryPicBox.Image = Image.FromFile(picPath);
Char.ToUpper(name[7]);
primaryLabel.Text = name.Substring(7);
}
}
public void PrepareTargets(UpdateEvent e, BulletNode bulletNode, [JoinByTank] WeaponNode weaponNode)
{
BulletComponent bullet = bulletNode.bullet;
float num = UnityTime.time - bullet.LastUpdateTime;
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
targetingData.Origin = bullet.Position - (bullet.Direction * 0.1f);
targetingData.Dir = bullet.Direction;
targetingData.FullDistance = Math.Min(Math.Max((float)0f, (float)(bulletNode.bulletConfig.FullDistance - bullet.Distance)), bullet.Speed * num);
base.ScheduleEvent(BattleCache.targetingEvent.GetInstance().Init(targetingData), bulletNode);
base.ScheduleEvent(BattleCache.updateBulletEvent.GetInstance().Init(targetingData), bulletNode);
}
private void BuildWeapon(Entity tank, WeaponNode weaponNode)
{
Entity entity = weaponNode.Entity;
entity.AddComponent <CooldownTimerComponent>();
entity.AddComponent <ChargingWeaponControllerComponent>();
entity.AddComponent <ReadyRailgunChargingWeaponComponent>();
entity.AddComponent <VerticalSectorsTargetingComponent>();
entity.AddComponent <DirectionEvaluatorComponent>();
entity.AddComponent <WeaponShotComponent>();
entity.AddComponent(new WeaponHitComponent(true, false));
entity.AddComponent <DistanceAndAngleTargetEvaluatorComponent>();
}
public void StopTankShaderEffect(StopTankShaderEffectEvent e, TankNode tank, [JoinByTank] WeaponNode weapon)
{
if (e.EnableException && !tank.tankOpaqueShaderBlockers.Blockers.Contains(e.Key))
{
throw new TankShaderEffectNotFoundException(e.Key);
}
tank.tankOpaqueShaderBlockers.Blockers.Remove(e.Key);
if (tank.tankOpaqueShaderBlockers.Blockers.Count <= 0)
{
ClientGraphicsUtil.ApplyShaderToRenderer(tank.baseRenderer.Renderer, tank.tankShader.OpaqueShader);
ClientGraphicsUtil.ApplyShaderToRenderer(weapon.baseRenderer.Renderer, tank.tankShader.OpaqueShader);
}
}
private void CheckIsTargetAchievable(AutopilotTankNode tank, WeaponNode weapon)
{
Vector3 position = tank.autopilotWeaponController.TargetRigidbody.position;
Vector3 origin = weapon.weaponInstance.WeaponInstance.transform.position;
Vector3 normalized = (position - origin).normalized;
bool flag = !weapon.targetCollector.Collect(origin, new Vector3(normalized.x, 0f, normalized.z), Vector3.Distance(origin, position), 0).HasTargetHit();
if (tank.autopilotWeaponController.TragerAchievable != flag)
{
tank.autopilotWeaponController.TragerAchievable = flag;
tank.autopilotWeaponController.OnChange();
}
}
public void OnAfterFixedUpdate(AfterFixedUpdateEvent e, TankNode tankNode, [JoinByTank] WeaponNode weaponNode)
{
TankMovementSenderComponent tankMovementSender = tankNode.tankMovementSender;
Rigidbody rigidbody = tankNode.rigidbody.Rigidbody;
Vector3 velocity = rigidbody.velocity;
float num = this.SqrMagnitudeXZ(velocity);
Vector3 vector = tankMovementSender.LastPhysicsMovement.Velocity;
if (((((tankMovementSender.LastSentMovement == null) || (((Mathf.Clamp(velocity.y, 0f, float.MaxValue) - Mathf.Clamp(vector.y, 0f, float.MaxValue)) / Time.fixedDeltaTime) > 20f)) || ((this.SqrMagnitudeXZ(vector) > (num + 0.01)) && ((this.SqrMagnitudeXZ(tankMovementSender.LastSentMovement.Value.Velocity) + 0.01) < this.SqrMagnitudeXZ(vector)))) || this.IsXZDistanceTooLarge(tankMovementSender.LastSentMovement.Value.Position, rigidbody.position)) || this.IsYDistanceTooLarge(tankMovementSender.LastSentMovement.Value.Position, rigidbody.position))
{
this.CollectCommandsAndSend(tankNode, weaponNode, MoveCommandType.TANK);
}
}
private DiscreteTankControl GetControl(TankNode tankNode, WeaponNode weaponNode)
{
DiscreteTankControl control = new DiscreteTankControl();
ChassisComponent chassis = tankNode.chassis;
MoveControl control2 = new MoveControl {
MoveAxis = chassis.EffectiveMoveAxis,
TurnAxis = chassis.EffectiveTurnAxis
};
control.TurnAxis = Mathf.RoundToInt(control2.TurnAxis);
control.MoveAxis = Mathf.RoundToInt(control2.MoveAxis);
control.WeaponControl = Mathf.RoundToInt(weaponNode.weaponRotationControl.EffectiveControl);
return(control);
}