public void ApplyCameraTransform(ApplyCameraTransformEvent e, BattleCameraNode battleCamera)
{
CameraComponent camera = battleCamera.camera;
CameraTransformDataComponent cameraTransformData = battleCamera.cameraTransformData;
Transform root = battleCamera.cameraRootTransform.Root;
Vector3 position = cameraTransformData.Data.Position;
Quaternion rotation = cameraTransformData.Data.Rotation;
float t = 1f;
float num2 = 1f;
if (e.DeltaTimeValid)
{
float deltaTime = e.DeltaTime;
t = !e.PositionSmoothingRatioValid ? battleCamera.applyCameraTransform.positionSmoothingRatio : e.PositionSmoothingRatio;
num2 = !e.RotationSmoothingRatioValid ? battleCamera.applyCameraTransform.rotationSmoothingRatio : e.RotationSmoothingRatio;
battleCamera.applyCameraTransform.positionSmoothingRatio = t;
battleCamera.applyCameraTransform.rotationSmoothingRatio = num2;
t *= deltaTime;
num2 *= deltaTime;
}
root.SetPositionSafe(Vector3.Lerp(root.position, position, t));
Vector3 eulerAngles = rotation.eulerAngles;
Vector3 vector3 = root.rotation.eulerAngles;
root.rotation = Quaternion.Euler(new Vector3(Mathf.LerpAngle(vector3.x, eulerAngles.x, num2), Mathf.LerpAngle(vector3.y, eulerAngles.y, num2), 0f));
base.ScheduleEvent <TransformTimeSmoothingEvent>(battleCamera);
}
public void InitBattleCameraForHealthFeedback(NodeAddedEvent e, BattleCameraNode camera, SingleNode <HealthFeedbackMapEffectMaterialComponent> mapEffect, SingleNode <GameTankSettingsComponent> settings)
{
if (settings.component.HealthFeedbackEnabled)
{
HealthFeedbackPostEffect healthFeedbackPostEffect = camera.camera.UnityCamera.gameObject.AddComponent <HealthFeedbackPostEffect>();
healthFeedbackPostEffect.Init(mapEffect.component.SourceMaterial);
camera.Entity.AddComponent(new HealthFeedbackCameraPreparedComponent(healthFeedbackPostEffect));
}
}
public void InitTimeSmoothing(NodeAddedEvent evt, BattleCameraNode battleCamera)
{
CameraComponent camera = battleCamera.camera;
TransformTimeSmoothingComponent component = new TransformTimeSmoothingComponent {
Transform = battleCamera.cameraRootTransform.Root,
UseCorrectionByFrameLeader = true
};
battleCamera.Entity.AddComponent(component);
}
public void UpdateAlliesBasePointer(UpdateEvent e, SingleNode <AlliesBasePointerComponent> pointer, [JoinAll] SelfBattleUser user, [JoinByTeam] FlagPedestalNode pedestal, [JoinAll] BattleCameraNode battleCamera, [JoinAll] SingleNode <CTFComponent> ctfGameNode)
{
this.SetBasePosition(pointer.component, pedestal.flagPedestal.Position, battleCamera.camera.UnityCamera);
}
public void UpdateAlliasFlagPointer(UpdateEvent e, SingleNode <AlliesFlagPointerComponent> pointer, [JoinAll] HUDNodes.SelfTankNode selfTank, [JoinByTeam] FlagNotHomeNode flag, [JoinAll] BattleCameraNode battleCamera, [JoinAll] SingleNode <CTFComponent> ctfGameNode)
{
if (this.NotFlagCarrier(selfTank, flag))
{
this.SetFlagPointerPosition(flag, pointer.component, battleCamera.camera.UnityCamera);
}
else
{
pointer.component.Hide();
}
}
public void ResetTimeSmoothing(NodeRemoveEvent evt, BattleCameraNode battleCamera)
{
battleCamera.Entity.RemoveComponent <TransformTimeSmoothingComponent>();
}
public void UpdateCharacterShadows(TimeUpdateEvent evt, SingleNode <CharacterShadowCommonSettingsComponent> characterShadowCommonSettingsNode, [JoinAll] ICollection <CharacterShadowNode> characters, [JoinAll] BattleCameraNode battleCamera)
{
CharacterShadowCommonSettingsComponent settings = characterShadowCommonSettingsNode.component;
this.UpdateBoundsAndCullCharacters(this.visibleCharacters, characters, battleCamera.camera, settings);
this.UpdateShadowMapSize(settings, this.visibleCharacters, characters);
if (settings.shadowMap != null)
{
Camera camera = settings.Camera;
this.CalculateProjectionData(settings, this.visibleCharacters, camera);
this.GenerateDrawCommandBuffer(settings, this.visibleCharacters);
camera.Render();
}
this.visibleCharacters.Clear();
}
public void UpdateSelfTargetHitEffect(UpdateEvent e, EffectInstanceFullNode effect, [JoinAll] SelfTankNode selfTank, [JoinByTank] ShaftAimingWeaponNode selfWeapon, [JoinAll] BattleCameraNode camera, [JoinAll] SingleNode <ScreensLayerComponent> canvasNode)
{
this.UpdateSelfTargetHitEffect(effect, selfTank, camera, canvasNode, true);
}
public void InitSoundListenerInBattle(NodeAddedEvent evt, SingleNode <SoundListenerComponent> soundListener, [Context, JoinAll] BattleCameraNode node)
{
this.ApplyListenerTransformToCamera(soundListener.component, node.cameraRootTransform.Root);
}
private SelfTargetHitEffectHUDData?GetDataForSelfTargetHitEffect(Vector3 enemyWeaponWorldPosition, SelfTankNode selfTank, BattleCameraNode camera, SingleNode <ScreensLayerComponent> canvasNode, bool isShaft)
{
bool flag;
Vector2 viewportPos = new Vector2(0.5f, 0.5f);
Vector2 hitVecViewportSpace = viewportPos - WorldToViewportPointProjected(camera.camera.UnityCamera, enemyWeaponWorldPosition, out flag);
if (isShaft)
{
hitVecViewportSpace.y = !flag ? -Mathf.Abs(hitVecViewportSpace.y) : Mathf.Abs(hitVecViewportSpace.y);
Vector2 vector = viewportPos - hitVecViewportSpace;
}
Vector2?boundPosition = selfTank.selfTargetHitFeedbackHUDConfig.GetBoundPosition((Vector3)viewportPos, hitVecViewportSpace);
if (boundPosition == null)
{
return(null);
}
Vector2 vector4 = boundPosition.Value;
Vector2 localPositionForCanvasByViewport = GetLocalPositionForCanvasByViewport(vector4, canvasNode);
Vector2 vector6 = GetLocalPositionForCanvasByViewport(viewportPos, canvasNode) - localPositionForCanvasByViewport;
Vector3 vector7 = new Vector3(vector6.x, vector6.y, 0f);
float magnitude = vector7.magnitude;
Vector3 vector9 = new Vector3(vector6.x, vector6.y, 0f);
return(new SelfTargetHitEffectHUDData(enemyWeaponWorldPosition, vector4, localPositionForCanvasByViewport, vector9.normalized, canvasNode.component.selfRectTransform.sizeDelta, magnitude));
}
public void BuildWeaponGraphics(NodeAddedEvent e, [Combine] WeaponGraphicsRendererNode weapon, BattleCameraNode camera)
{
Renderer renderer = weapon.baseRenderer.Renderer;
if (weapon.Entity.HasComponent <CameraVisibleTriggerComponent>())
{
weapon.Entity.GetComponent <CameraVisibleTriggerComponent>().MainCameraTransform = camera.cameraRootTransform.Root;
}
else
{
CameraVisibleTriggerComponent component = renderer.gameObject.AddComponentIfMissing <CameraVisibleTriggerComponent>();
component.MainCameraTransform = camera.cameraRootTransform.Root;
weapon.Entity.AddComponent(component);
}
}
private SelfTargetHitEffectHUDData?GetDataForSelfTargetHitEffect(ReadyWeaponNode enemyWeapon, SelfTankNode selfTank, BattleCameraNode camera, SingleNode <ScreensLayerComponent> canvasNode, bool isShaft) => this.GetDataForSelfTargetHitEffect(enemyWeapon.weaponVisualRoot.transform.position, selfTank, camera, canvasNode, isShaft);
private void CreateSelfTargetHitHUDFeedback(ReadyWeaponNode enemyWeapon, RemoteTankNode remoteTank, SelfTankNode selfTank, BattleCameraNode camera, SingleNode <ScreensLayerComponent> canvasNode, bool isShaft)
{
if (CheckPossibilityForEffectInstancing(enemyWeapon))
{
SelfTargetHitEffectHUDData?nullable = this.GetDataForSelfTargetHitEffect(enemyWeapon, selfTank, camera, canvasNode, isShaft);
if (nullable != null)
{
enemyWeapon.weaponSelfTargetHitFeedbackTimer.LastTime = Time.time;
SelfTargetHitFeedbackHUDInstanceComponent component = Object.Instantiate <SelfTargetHitFeedbackHUDInstanceComponent>(selfTank.selfTargetHitFeedbackHUDConfig.EffectPrefab, canvasNode.component.transform);
Entity entity = base.CreateEntity("SelfTargetHitHUDEffectInstance");
remoteTank.tankGroup.Attach(entity);
enemyWeapon.weaponSelfTargetHitFeedbackGroup.Attach(entity);
component.Init(entity, nullable.Value);
}
}
}
public void CheckSelfTargetHit(DamageInfoTargetEvent e, StreamWeaponNode enemyWeapon, [JoinByUser] RemoteTankNode remoteTank, SelfTankNode selfTank, [JoinByTank] ShaftAimingWeaponNode selfWeapon, [JoinAll] BattleCameraNode camera, [JoinAll] SingleNode <ScreensLayerComponent> canvasNode)
{
this.CreateSelfTargetHitHUDFeedback(enemyWeapon, remoteTank, selfTank, camera, canvasNode, true);
}
public void UpdateEnemyBasePointer(UpdateEvent e, EnemyBasePointer pointer, [JoinAll] SelfBattleUser user, [JoinAll] ICollection <FlagPedestalNode> pedestals, [JoinAll] BattleCameraNode battleCamera, [JoinAll] SingleNode <CTFComponent> ctfGameNode)
{
if (pedestals.Count >= 2)
{
FlagPedestalNode oppositeTeamPedestal = this.GetOppositeTeamPedestal(pedestals, user);
this.SetBasePosition(pointer.enemyBasePointer, oppositeTeamPedestal.flagPedestal.Position, battleCamera.camera.UnityCamera);
}
}
public void UpdateSoundListenerInBattle(UpdateEvent evt, SingleNode <SoundListenerComponent> soundListener, [JoinAll] BattleCameraNode node, [JoinAll] SingleNode <MapInstanceComponent> map)
{
this.ApplyListenerTransformToCamera(soundListener.component, node.cameraRootTransform.Root);
}
public void UpdateEnemyFlagPointer(UpdateEvent e, EnemyFlagPointerNode pointer, [JoinAll] SelfBattleUser user, [JoinByUser] HUDNodes.SelfTankNode selfTank, [JoinByBattle] ICollection <FlagNotHomeNode> flags, [JoinAll] BattleCameraNode battleCamera, [JoinAll] SingleNode <CTFComponent> ctfGameNode)
{
if (flags.Count >= 2)
{
FlagNotHomeNode oppositeTeamFlag = this.GetOppositeTeamFlag(flags, user);
if ((oppositeTeamFlag != null) && this.NotFlagCarrier(selfTank, oppositeTeamFlag))
{
this.SetFlagPointerPosition(oppositeTeamFlag, pointer.enemyFlagPointer, battleCamera.camera.UnityCamera);
}
else
{
pointer.enemyFlagPointer.Hide();
}
}
}
private void UpdateSelfTargetHitEffect(EffectInstanceFullNode effect, SelfTankNode selfTank, BattleCameraNode camera, SingleNode <ScreensLayerComponent> canvasNode, bool isShaftAiming)
{
SelfTargetHitEffectHUDData?nullable = this.GetDataForSelfTargetHitEffect(effect.selfTargetHitFeedbackHUDInstance.InitialData.EnemyWeaponWorldSpace, selfTank, camera, canvasNode, isShaftAiming);
if (nullable != null)
{
effect.selfTargetHitFeedbackHUDInstance.UpdateTransform(nullable.Value);
}
}
