public void TurnOffEffectsOnDeath(NodeRemoveEvent e, TankNode tank)
{
tank.moduleVisualEffectObjects.JumpImpactEffect.SetActive(false);
tank.moduleVisualEffectObjects.ExternalImpactEffect.SetActive(false);
tank.moduleVisualEffectObjects.FireRingEffect.SetActive(false);
tank.moduleVisualEffectObjects.ExplosiveMassEffect.SetActive(false);
}
private Transform CreateTankSoundRoot(TankNode tank)
{
Transform transform = tank.tankVisualRoot.transform.gameObject.GetComponentsInChildren <TankSoundRootBehaviour>(true)[0].gameObject.transform;
tank.Entity.AddComponent(new TankSoundRootComponent(transform));
return(transform);
}
public Tank CreateTank(TankSyncInfo syncInfo, int playerId = 0)
{
GamePlayerController player;
GameManager.AllPlayers.TryGetValue(playerId, out player);
GameObject obj = GameObjectPool.instance.Instantiate(unitPrefab);
TankNode node = obj.GetComponent <TankNode>();
Tank unit = obj.GetComponent <Tank>();
//TankController ctrl = obj.GetComponent<TankController>();
ResourceManager.instance.LoadUnitModel(syncInfo.baseInfo.model); // high time cost
ResourceManager.instance.AssignModelToUnitNode(syncInfo.baseInfo.model, node);
unit.m_id = syncInfo.id;
node.m_id = syncInfo.id;
AddUnit(unit);
//unit.m_client = player;
unit.m_model = syncInfo.baseInfo.model;
if (localClient.isServer)
{
unit.AI = UnitAI.instance;
}
unit.Name = syncInfo.baseInfo.name;
unit.MaxHpBase = (float)syncInfo.baseInfo.maxHp;
if (syncInfo.baseInfo.attackSkill.valid)
{
AttackAct atk = new AttackAct(syncInfo.baseInfo.attackSkill.name, (float)syncInfo.baseInfo.attackSkill.cd, new AttackValue(AttackValue.NameToType(syncInfo.baseInfo.attackSkill.type), (float)syncInfo.baseInfo.attackSkill.value), (float)syncInfo.baseInfo.attackSkill.vrange);
atk.CastRange = (float)syncInfo.baseInfo.attackSkill.range;
atk.CastHorizontal = syncInfo.baseInfo.attackSkill.horizontal;
foreach (var ani in syncInfo.baseInfo.attackSkill.animations)
{
atk.AddCastAnimation(ModelNode.NameToId(ani));
}
atk.ProjectileTemplate = ResourceManager.instance.LoadProjectile(syncInfo.baseInfo.attackSkill.projectile);
atk.ProjectileTemplate.fire = "Straight";
unit.AddActiveSkill(atk);
}
node.position = syncInfo.position;
node.rotation = syncInfo.rotation;
unit.Hp = syncInfo.hp;
unit.force.Force = syncInfo.force;
unit.MoveSpeedBase = (float)syncInfo.baseInfo.move;
unit.Revivable = syncInfo.baseInfo.revivable;
unit.Fixed = syncInfo.baseInfo.isfixed;
for (int i = 0; i < syncInfo.guns.Count; ++i)
{
unit.AddGun(i);
unit.SetGunPosition(i, syncInfo.guns[i].position);
unit.SetGunRotation(i, syncInfo.guns[i].rotation);
//syncInfo.guns[i].rotateSpeed;
}
return(unit);
}
public void PlayKillSound(KillEvent e, SelfBattleUserNode battleUser, [JoinByUser] TankNode tank, [JoinAll] SingleNode <SoundListenerComponent> listener)
{
if (KillTankSoundEffectBehaviour.CreateKillTankSound(tank.killTankSoundEffect.EffectPrefab))
{
base.ScheduleEvent <KillTankSoundEffectCreatedEvent>(listener);
}
}
public void StartPrepareHull(NodeAddedEvent e, TankNode tank, [Context, JoinByTank] HullSkin hullSkin)
{
Entity entity = tank.Entity;
entity.AddComponent <ChassisConfigComponent>();
base.NewEvent <RequestHullPrefabsEvent>().Attach(entity).Attach(hullSkin.Entity).ScheduleDelayed(0.2f);
}
private void StartReducing(AimingWorkActivationNode weapon, TankNode tank, ICollection <RendererNode> renderers, bool switchShader)
{
base.ScheduleEvent(new AddTankShaderEffectEvent(ClientGraphicsConstants.SHAFT_AIMING_EFFECT, false), tank);
if (switchShader)
{
Shader transparentShader = tank.tankShader.TransparentShader;
this.SetTransparentMode(renderers, tank, transparentShader, -1f);
}
if (weapon.Entity.HasComponent <ShaftAimingRendererRecoveringAlphaComponent>())
{
weapon.Entity.RemoveComponent <ShaftAimingRendererRecoveringAlphaComponent>();
}
float alpha = TankMaterialsUtil.GetAlpha(tank.trackRenderer.Renderer);
weapon.Entity.AddComponent(new ShaftAimingRendererReducingAlphaComponent(alpha));
ShaftAimingRendererQueueMapComponent component = new ShaftAimingRendererQueueMapComponent();
foreach (RendererNode node in renderers)
{
foreach (Material material in node.baseRenderer.Renderer.materials)
{
component.QueueMap.Add(material, material.renderQueue);
material.renderQueue = weapon.shaftAimingRendererEffect.TransparentRenderQueue;
}
}
weapon.Entity.AddComponent(component);
}
public void SetOpaqueModeOnExitTankActiveState(NodeRemoveEvent evt, TankNode tank, [JoinByTank] ShaftAimingRendererEffectNode weapon, [JoinByTank] ICollection <RendererNode> renderers)
{
float alpha = ClientGraphicsConstants.OPAQUE_ALPHA;
this.SetTransparentMode(renderers, tank, null, alpha);
base.ScheduleEvent(new StopTankShaderEffectEvent(ClientGraphicsConstants.SHAFT_AIMING_EFFECT, false), tank);
}
public void HideFlag(NodeRemoveEvent e, CarriedFlagNode flag1, [JoinByTank] TankNode user, [JoinByUser] FlagIndicatorNode flagIndicator, CarriedFlagNode flag2, [JoinByTank] ICollection <CarriedFlagNode> flags)
{
if (flags.Count <= 1)
{
flagIndicator.scoreTableFlagIndicator.SetFlagIconActivity(false);
}
}
public void InitDoubleArmorEffect(NodeAddedEvent evt, [Combine] TankNode tank, SingleNode <SoundListenerBattleStateComponent> soundListener)
{
if (!tank.Entity.HasComponent <TankDeadStateComponent>())
{
tank.Entity.AddComponent <DoubleArmorEffectReadyComponent>();
}
}
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 PlayEMPEffect(PlayEMPHitTargetTankEvent e, TankNode tank)
{
ParticleSystem system = Object.Instantiate <ParticleSystem>(tank.empHitVisualEffect.EmpHitPrefab, tank.tankSoundRoot.SoundRootTransform.position, tank.tankSoundRoot.SoundRootTransform.rotation, tank.tankSoundRoot.SoundRootTransform.transform);
system.shape.mesh = tank.baseRenderer.Mesh;
Object.Destroy(system.gameObject, 2f);
}
public void TryMarkTargetLoaded(NodeAddedEvent e, TankNode tank, [JoinByBattle] ICollection <StreamHitNode> streamHits)
{
foreach (StreamHitNode node in streamHits)
{
this.AddIfMatches(tank, node);
}
}
private void ApplyMoveControl(TankNode tank, MoveControl?moveControl)
{
if (moveControl != null)
{
this.ApplyMoveControl(tank.chassis, moveControl.Value.MoveAxis, moveControl.Value.TurnAxis);
}
}
public void UpdateRegionOpacityByDistance(TimeUpdateEvent e, TankNode tank, [JoinAll, Combine] VisibleBonusRegionNode region, [JoinAll] SingleNode <BonusRegionClientConfigComponent> configNode, [JoinAll] SingleNode <RoundActiveStateComponent> round)
{
BonusRegionClientConfigComponent component = configNode.component;
float num = Vector3.Distance(tank.tankColliders.BoundsCollider.transform.position, region.spatialGeometry.Position);
region.opacityBonusRegion.Opacity = Mathf.Clamp01(1f - ((num - component.maxOpacityRadius) / (component.minOpacityRadius - component.maxOpacityRadius)));
}
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);
}
private void SendCommand(TankNode tankNode, MoveCommand moveCommand)
{
TankMovementSenderComponent tankMovementSender = tankNode.tankMovementSender;
Movement?movement = moveCommand.Movement;
if (movement != null)
{
if (!PhysicsUtil.ValidateMovement(movement.Value))
{
return;
}
tankMovementSender.LastSentMovement = movement;
tankMovementSender.LastSentMovementTime = PreciseTime.Time;
base.Log.Debug("SEND MOVEMENT");
}
if (moveCommand.WeaponRotation != null)
{
if (!PhysicsUtil.IsValidFloat(moveCommand.WeaponRotation.Value))
{
LoggerProvider.GetLogger(typeof(PhysicsUtil)).ErrorFormat("Invalid WeaponRotation. StackTrace:[{0}]", Environment.StackTrace);
return;
}
tankMovementSender.LastSentWeaponRotationTime = PreciseTime.Time;
base.Log.Debug("SEND WEAPON_ROTATION");
}
base.ScheduleEvent(new MoveCommandEvent(moveCommand), tankNode.Entity);
base.Log.Debug("SEND DISCRETE");
}
public void Impact(ImpactEvent evt, TankNode tank)
{
Rigidbody rigidbody = tank.rigidbody.Rigidbody;
Vector3 position = MathUtil.LocalPositionToWorldPosition(evt.LocalHitPoint, rigidbody.gameObject);
rigidbody.AddForceAtPositionSafe(evt.Force, position);
}
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));
}
private void UpdateGyroscopeData(WeaponGyroscopeNode weaponGyroscope, TankNode tank)
{
WeaponGyroscopeRotationComponent weaponGyroscopeRotation = weaponGyroscope.weaponGyroscopeRotation;
Transform transform = tank.hullInstance.HullInstance.transform;
weaponGyroscopeRotation.ForwardDir = transform.forward;
weaponGyroscopeRotation.UpDir = transform.up;
}
private void PlayLowEnergyFeedback(TankNode tank)
{
this.StopSound(tank);
WeaponFeedbackSoundBehaviour behaviour = Object.Instantiate <WeaponFeedbackSoundBehaviour>(tank.shootingEnergyFeedbackSound.LowEnergyFeedbackSoundAsset);
tank.shootingEnergyFeedbackSound.Instance = behaviour;
behaviour.Play(-1f, 1f, true);
}
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 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);
}
public void RequestPrefabs(RequestHullPrefabsEvent e, TankNode tank, HullSkin hullSkin)
{
Entity entity = tank.Entity;
entity.AddComponent <TankCommonPrefabComponent>();
entity.AddComponent(new AssetReferenceComponent(new AssetReference(entity.GetComponent <TankCommonPrefabComponent>().AssetGuid)));
entity.AddComponent <AssetRequestComponent>();
}
public void ShowFire(NodeAddedEvent evt, TankNode tank, [JoinByTank] NormalTurretNode turret)
{
if (tank.cameraVisibleTrigger.IsVisible)
{
float timeToPlay = (float)(tank.tankDeadState.EndDate - Date.Now);
this.PlayEffect(tank.tankDeathExplosionPrefabs.FirePrefab, tank.tankVisualRoot.transform, tank.mountPoint.MountPoint, timeToPlay, tank);
}
}
public void ShowExplosion(NodeAddedEvent evt, TankNode tank)
{
if (tank.cameraVisibleTrigger.IsVisible)
{
float timeToPlay = tank.tankDeadState.EndDate.UnityTime - Time.time;
this.PlayEffect(tank.tankDeathExplosionPrefabs.ExplosionPrefab, tank.tankVisualRoot.transform, tank.mountPoint.MountPoint, timeToPlay, tank);
}
}
public void AddTankShaderEffect(AddTankShaderEffectEvent e, TankNode tank)
{
if (e.EnableException && tank.tankOpaqueShaderBlockers.Blockers.Contains(e.Key))
{
throw new TankShaderEffectAlreadyAddedException(e.Key);
}
tank.tankOpaqueShaderBlockers.Blockers.Add(e.Key);
}
public void SelfDetachWeapon(DetachWeaponIfPossibleEvent e, TankNode tank, [JoinByTank] UnblockedWeaponNode weapon)
{
Rigidbody rigidbody = this.DetachWeapon(tank, weapon);
rigidbody.SetVelocitySafe(rigidbody.velocity + new Vector3(Random.Range((float)-1.5f, (float)1.5f), Random.Range((float)2f, (float)3f), Random.Range((float)-1.5f, (float)1.5f)));
rigidbody.SetAngularVelocitySafe(rigidbody.angularVelocity + Vector3.Scale(Random.onUnitSphere, new Vector3(Random.Range((float)2f, (float)4f), Random.Range((float)0.5f, (float)1f), Random.Range((float)2f, (float)4f))));
base.ScheduleEvent(new DetachWeaponEvent(rigidbody.velocity, rigidbody.angularVelocity), tank);
}
public void AddMessageLog(FlagEvent e, FlagNode flag, [JoinByTank] TankNode tank2Team, [JoinByTeam] TeamNode tankTeam, FlagNode flag2User, [JoinByTank] TankNode tank2User, [JoinByUser] UserNode user, FlagNode flag2Team, [JoinByTeam] TeamNode flagTeam, [JoinAll] SingleNode <SelfBattleUserComponent> selfUser, [JoinByTeam] Optional <TeamNode> selfTeam, [JoinAll] CombatLogNode combatLog)
{
CombatLogCTFMessagesComponent combatLogCTFMessages = combatLog.combatLogCTFMessages;
string newValue = GetOwnFlag(selfTeam, flagTeam, combatLogCTFMessages);
Color teamColor = CombatEventLogUtil.GetTeamColor(tankTeam.colorInBattle.TeamColor, combatLog.combatEventLog);
string messageText = CombatEventLogUtil.ApplyPlaceholder(GetMessage(e, flag.Entity, combatLogCTFMessages).Replace(CombatLogCTFMessagesComponent.OWN, newValue), "{user}", user.userRank.Rank, user.userUid.Uid, teamColor);
combatLog.uiLog.UILog.AddMessage(messageText);
}
private void StopSound(TankNode tank)
{
WeaponFeedbackSoundBehaviour instance = tank.shootingEnergyFeedbackSound.Instance;
if (instance)
{
instance.GetComponent <WeaponEnergyFeedbackFadeBehaviour>().enabled = true;
}
}
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);
}
