BaseGameScreen.cs

using System;
using UnityEngine;
 
// Token: 0x02000165 RID: 357
public class BaseGameScreen : EMono
{
    // Token: 0x170002A6 RID: 678
    // (get) Token: 0x06000A75 RID: 2677 RVA: 0x0003F3E0 File Offset: 0x0003D5E0
    public bool fixFocus
    {
        get
        {
            ActionMode actionMode = EMono.scene.actionMode;
            return actionMode != null && actionMode.FixFocus;
        }
    }
 
    // Token: 0x170002A7 RID: 679
    // (get) Token: 0x06000A76 RID: 2678 RVA: 0x0003F3F7 File Offset: 0x0003D5F7
    public virtual float TargetZoom
    {
        get
        {
            return EMono.scene.actionMode.TargetZoom;
        }
    }
 
    // Token: 0x170002A8 RID: 680
    // (get) Token: 0x06000A77 RID: 2679 RVA: 0x0003F408 File Offset: 0x0003D608
    protected CameraSupport camSupport
    {
        get
        {
            return EMono.scene.camSupport;
        }
    }
 
    // Token: 0x170002A9 RID: 681
    // (get) Token: 0x06000A78 RID: 2680 RVA: 0x0003F414 File Offset: 0x0003D614
    protected Transform transFocus
    {
        get
        {
            return EMono.scene.transFocus;
        }
    }
 
    // Token: 0x170002AA RID: 682
    // (get) Token: 0x06000A79 RID: 2681 RVA: 0x0003F420 File Offset: 0x0003D620
    public virtual float SkyRate
    {
        get
        {
            return Mathf.Clamp((1.2f - this.Zoom) * 2f - (EMono._zone.IsSnowCovered ? 0.38f : 0f), 0f, 2f);
        }
    }
 
    // Token: 0x170002AB RID: 683
    // (get) Token: 0x06000A7A RID: 2682 RVA: 0x0003F45C File Offset: 0x0003D65C
    public virtual float ViewHeight
    {
        get
        {
            return this.SkyRate * 10f + 5f;
        }
    }
 
    // Token: 0x170002AC RID: 684
    // (get) Token: 0x06000A7B RID: 2683 RVA: 0x0003F470 File Offset: 0x0003D670
    public virtual bool IsGameScreen
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x170002AD RID: 685
    // (get) Token: 0x06000A7C RID: 2684 RVA: 0x0003F473 File Offset: 0x0003D673
    public virtual bool IsLocalMap
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x06000A7D RID: 2685 RVA: 0x0003F478 File Offset: 0x0003D678
    public void Activate()
    {
        if (EMono.core.screen == this)
        {
            return;
        }
        if (EMono.core.screen != null)
        {
            EMono.core.screen.Deactivate();
        }
        this.SetUnitSize();
        EMono.core.screen = this;
        Point._screen = this;
        base.gameObject.SetActive(true);
        EMono.scene.flock.SetActive(this.IsLocalMap);
        EMono.scene.fireflyNight.SetActive(this.IsLocalMap);
        EMono.scene.firefly.SetActive(this.IsLocalMap);
        EMono.scene.star.SetActive(this.IsLocalMap);
        EMono.scene.sfxRain.SetActive(this.IsGameScreen);
        EMono.scene.sfxSea.SetActive(this.IsGameScreen);
        EMono.scene.sfxWind.SetActive(this.IsGameScreen);
        EMono.scene.sfxFire.SetActive(this.IsGameScreen);
        this.OnActivate();
        EMono.scene.rain.main.prewarm = (EMono.scene.snow.main.prewarm = (EMono.scene.ether.main.prewarm = true));
        ParticleSystem[] blossoms = EMono.scene.blossoms;
        for (int i = 0; i < blossoms.Length; i++)
        {
            blossoms[i].main.prewarm = true;
        }
        if (this.overlayShadow)
        {
            this.overlayShadow.SetActive(EMono.scene.profile.matOverlay);
            this.overlayShadow.sharedMaterial = EMono.scene.profile.matOverlay;
        }
        EMono.scene.camSupport.grading.material = EMono.scene.profile.matGrading;
        if (this.IsGameScreen)
        {
            EMono.scene.OnChangeHour();
            EMono.scene.ApplyZoneConfig();
            this.RefreshAll();
            this.tileMap.OnActivate(this);
            WidgetHotbar.RefreshHighlights();
            return;
        }
        if (EMono.core.config != null)
        {
            EMono.core.config.RefreshUIBrightness();
        }
    }
 
    // Token: 0x06000A7E RID: 2686 RVA: 0x0003F6C3 File Offset: 0x0003D8C3
    public virtual void OnActivate()
    {
    }
 
    // Token: 0x06000A7F RID: 2687 RVA: 0x0003F6C5 File Offset: 0x0003D8C5
    public void Deactivate()
    {
        this.OnDeactivate();
        base.gameObject.SetActive(false);
        EMono.core.screen = null;
    }
 
    // Token: 0x06000A80 RID: 2688 RVA: 0x0003F6E4 File Offset: 0x0003D8E4
    public virtual void OnDeactivate()
    {
    }
 
    // Token: 0x06000A81 RID: 2689 RVA: 0x0003F6E6 File Offset: 0x0003D8E6
    public virtual void SetUnitSize()
    {
    }
 
    // Token: 0x06000A82 RID: 2690 RVA: 0x0003F6E8 File Offset: 0x0003D8E8
    public virtual void OnEndPlayerTurn()
    {
    }
 
    // Token: 0x06000A83 RID: 2691 RVA: 0x0003F6EC File Offset: 0x0003D8EC
    public unsafe void Draw()
    {
        if (!this.IsGameScreen)
        {
            return;
        }
        if (this.Zoom != this.targetZoom)
        {
            bool flag = EMono.scene.actionMode == ActionMode.Bird;
            CoreConfig.CameraConfig camera = EMono.core.config.camera;
            float num = camera.zoomSpeed * (flag ? 0.05f : (camera.linearZoom ? 2f : 1f)) * Core.delta;
            this.zoomTimer += num * 0.3f;
            float t = (flag || !camera.linearZoom) ? num : this.zoomTimer;
            float num2 = Mathf.Lerp(EMono.screen.Zoom, this.targetZoom, t);
            if (Mathf.Abs(num2 - this.targetZoom) < (flag ? 0.0005f : 0.003f))
            {
                num2 = this.targetZoom;
            }
            if (camera.zoomToMouse && this.zoomPos != Vector3.zero)
            {
                this.position = Vector3.Lerp(this.position, this.zoomPos, t);
            }
            EMono.core.config.ApplyZoom(num2);
        }
        RenderObject.gameSpeed = EMono.scene.actionMode.gameSpeed;
        RenderObject.gameDelta = Core.gameDeltaNoPause;
        if (EMono.pc.currentZone == EMono._zone && !EMono._zone.IsRegion && this.focusOption == null && this.focusPos == null && !this.transFocus && this.fixFocus && (this.instantFocus || !EMono.core.config.camera.smoothFollow))
        {
            if (this.Zoom != this.targetZoom)
            {
                EMono.core.config.ApplyZoom(this.TargetZoom);
            }
            Vector3 vector = (EMono.pc.isSynced ? EMono.player.position : (*EMono.pc.pos.Position())) + this.focusFix;
            this.position = vector;
            this.scrollX = Mathf.FloorToInt(this.position.x / this.tileWorldSize.x) - this.width / 2 + (int)this.paddingOffset.x;
            this.scrollY = Mathf.FloorToInt(this.position.y / this.tileWorldSize.y) - this.height / 4 + (int)this.paddingOffset.y;
        }
        this.tileMap.Draw();
        if (this.instantFocus)
        {
            this.instantFocus = false;
        }
        this.RefreshPosition();
        if (EMono.game.activeZone != null)
        {
            for (int i = EMono._map.pointAnimes.Count - 1; i >= 0; i--)
            {
                if (EMono._map.pointAnimes[i].Update())
                {
                    EMono._map.pointAnimes.RemoveAt(i);
                }
            }
        }
        this.UpdateShaders(EMono.scene.timeRatio);
        if (Scene.skipAnime)
        {
            EffectManager.Instance.KillAll();
            Scene.skipAnime = false;
        }
        EffectManager.Instance.UpdateEffects();
        FlockController flock = EMono.scene.flock;
        bool visible;
        if (this.targetZoom <= 1.25f)
        {
            Room room = EMono.pc.pos.cell.room;
            visible = (room == null || !room.HasRoof);
        }
        else
        {
            visible = false;
        }
        flock.UpdateVisible(visible);
        if (EMono.pc.isSynced && EMono.pc.renderer.orbit)
        {
            EMono.pc.renderer.orbit.Refresh();
        }
    }
 
    // Token: 0x06000A84 RID: 2692 RVA: 0x0003FA98 File Offset: 0x0003DC98
    public void UpdateShaders(float time = 0f)
    {
        SceneProfile profile = EMono.scene.profile;
        SceneColorProfile color = profile.color;
        SceneLightProfile light = profile.light;
        Color color2 = color.fog.Evaluate(time);
        float value = light.nightRatioCurve.Evaluate(time);
        Shader.SetGlobalFloat(this._Snow, EMono._zone.IsSnowCovered ? 1f : 0f);
        Shader.SetGlobalFloat(this._BackDrawPower, (float)(ActionMode.Cinema.IsActive ? 0 : EMono.game.config.backDrawAlpha));
        Shader.SetGlobalFloat(this._SkyLevel, this.SkyRate);
        Shader.SetGlobalFloat(this._NightRate, value);
        Shader.SetGlobalFloat(this._ViewHeight, this.ViewHeight);
        Shader.SetGlobalFloat(this._FogStrength, color2.a * 0.1f);
        Shader.SetGlobalColor(this._FogColor, color2);
        FowProfile fowProfile = EMono._zone.biome.fowProfile;
        if (EMono._map.fowProfile)
        {
            fowProfile = EMono._map.fowProfile;
        }
        if (fowProfile)
        {
            FOWType type = fowProfile.type;
            if (type != FOWType.Color)
            {
                if (type != FOWType.ColorAdd)
                {
                    Shader.SetGlobalColor(this._FowColor, color.fow.Evaluate(time));
                }
                else
                {
                    Shader.SetGlobalColor(this._FowColor, fowProfile.color * color.fow.Evaluate(time));
                }
            }
            else
            {
                Shader.SetGlobalColor(this._FowColor, fowProfile.color);
            }
        }
        else
        {
            Shader.SetGlobalColor(this._FowColor, color.fow.Evaluate(time));
        }
        Shader.SetGlobalColor(this._SunColor, EMono._zone.IsSnowCovered ? color.sunSnow.Evaluate(time) : color.sun.Evaluate(time));
        Shader.SetGlobalColor(this._SeaColor, color.sea.Evaluate(time));
        Shader.SetGlobalColor(this._SkyColor, color.sky.Evaluate(time));
        Shader.SetGlobalColor(this._SkyBGColor, color.skyBG.Evaluate(time));
        Shader.SetGlobalVector(this._Offset, EMono.core.config.camera.extendZoomMin ? (this.position * 0.3f) : (this.position * 0.5f));
        Shader.SetGlobalFloat(this._Zoom, this.Zoom);
        Shader.SetGlobalFloat(this._LightPower, light.lightPower.Evaluate(time) * light.lightPowerMod);
        Shader.SetGlobalFloat(this._AnimeSpeedGlobal, (float)EMono.game.config.animeSpeed);
        Shader.SetGlobalColor(this._ScreenFlash, ScreenFlash.currentColor);
        EMono.scene.godray.main.startColor = (EMono._zone.IsSnowCovered ? color.godraySnow.Evaluate(time) : color.godray.Evaluate(time));
        this.camSupport.grading.vignettePower = light.vignetteCurve.Evaluate(time);
        this.camSupport.grading.UpdateVignette(0f);
        this.camSupport.bloom.threshold = light.bloomCurve.Evaluate(time);
        this.camSupport.beautify.bloomIntensity = light.bloomCurve2.Evaluate(time);
    }
 
    // Token: 0x06000A85 RID: 2693 RVA: 0x0003FDED File Offset: 0x0003DFED
    public virtual void OnChangeHour()
    {
    }
 
    // Token: 0x06000A86 RID: 2694 RVA: 0x0003FDF0 File Offset: 0x0003DFF0
    public unsafe virtual void RefreshPosition()
    {
        if (EMono.pc.currentZone != EMono._zone)
        {
            return;
        }
        if (this.focusOption != null)
        {
            Vector3 vector = this.focusOption.player ? (*EMono.pc.pos.Position() + this.focusFix) : (*this.focusOption.pos.PositionCenter());
            vector.z = this.position.z;
            if (this.focusOption.linear)
            {
                this.position = Vector3.MoveTowards(this.position, vector, this.focusOption.speed * Core.delta);
            }
            else
            {
                this.position = Vector3.Lerp(this.position, vector, this.focusOption.speed * Core.delta);
            }
        }
        else if (this.focusPos != null)
        {
            this.focusPos = new Vector3?(new Vector3((this.focusPos ?? this.position).x, (this.focusPos ?? this.position).y, this.position.z));
            this.position = Vector3.Lerp(this.position, this.focusPos ?? this.position, this.focusSpeedSlow * Core.delta);
            if (Vector3.Distance(this.position, this.focusPos ?? this.position) < 0.1f)
            {
                this.focusPos = null;
            }
        }
        else if (this.transFocus)
        {
            this.pushBack = Vector3.zero;
            this.position.x = this.transFocus.position.x;
            this.position.y = this.transFocus.position.y;
        }
        else if (this.fixFocus)
        {
            float z = this.position.z;
            this.targetZoom = this.TargetZoom;
            for (int i = 0; i < EMono.core.config.camera.zooms.Length; i++)
            {
                if (this.targetZoom == EMono.core.config.camera.zooms[i])
                {
                    this.targetZoomIndex = i;
                }
            }
            Vector3 b = (EMono.pc.isSynced ? EMono.player.position : (*EMono.pc.pos.Position())) + this.focusFix;
            if (this.instantFocus)
            {
                this.position = b;
            }
            else if (EMono.core.config.camera.smoothFollow)
            {
                this.position = Vector3.Lerp(this.position, b, this.focusSpeed * Core.delta * Mathf.Lerp(0.2f, 1f, 1f - Mathf.Clamp(ActionMode.Adv.rightMouseTimer, 0f, 1f)));
            }
            else
            {
                this.position = b;
            }
            this.position.z = z;
            this.pcOrbit.transform.position = EMono.pc.renderer.position;
        }
        else
        {
            if (ActionMode.Adv.IsActive)
            {
                this.targetZoom = ActionMode.Adv.TargetZoom;
            }
            this.pushBack = Vector3.zero;
            int num = this.scrollX - this.scrollY;
            int num2 = this.scrollY + this.scrollX;
            if ((float)num <= this.mapLimit.x)
            {
                this.pushBack.x = this.mapLimit.x - (float)num;
            }
            if ((float)num2 <= this.mapLimit.y)
            {
                this.pushBack.y = this.mapLimit.y - (float)num2;
            }
            if ((float)num >= (float)EMono._map.Size + this.mapLimit.width - (float)(this.width / 2))
            {
                this.pushBack.x = (float)EMono._map.Size + this.mapLimit.width - (float)(this.width / 2) - (float)num;
            }
            if ((float)num2 >= (float)EMono._map.Size + this.mapLimit.height - (float)(this.height / 2))
            {
                this.pushBack.y = (float)EMono._map.Size + this.mapLimit.height - (float)(this.height / 2) - (float)num2;
            }
            this.position += Quaternion.Euler(this.planeAngle) * this.pushBack * Core.delta * this.pushbackSpeed;
        }
        this.scrollX = Mathf.FloorToInt(this.position.x / this.tileWorldSize.x) - this.width / 2 + (int)this.paddingOffset.x;
        this.scrollY = Mathf.FloorToInt(this.position.y / this.tileWorldSize.y) - this.height / 4 + (int)this.paddingOffset.y;
        if (this.lastPos.x != (float)this.scrollX || this.lastPos.y != (float)this.scrollY)
        {
            this.lastPos.x = (float)this.scrollX;
            this.lastPos.y = (float)this.scrollY;
        }
        this.camPos.x = this.position.x;
        this.camPos.y = this.position.y;
        this.SnapScreen(ref this.camPos, this.Zoom);
        this.camPos.z = -500f;
        this._camPos.x = this.camPos.x + this.screenFixX2 + this.screenFixX4;
        this._camPos.y = this.camPos.y + this.screenFixY2 + this.screenFixY4;
        this._camPos.z = this.camPos.z;
        EMono.scene.cam.transform.localPosition = this._camPos;
        this.camPos.z = 0f;
        EMono.scene.transAudio.position = this.camPos;
        if (WidgetMinimap.Instance)
        {
            WidgetMinimap.Instance.OnUpdate();
        }
    }
 
    // Token: 0x06000A87 RID: 2695 RVA: 0x000404A8 File Offset: 0x0003E6A8
    public void RefreshAll()
    {
        this.RefreshScreenSize();
        bool indoor = EMono._map.config.indoor;
        ScreenGrading grading = this.camSupport.grading;
        EMono.scene.flock.SetActive(!indoor);
        if (indoor)
        {
            grading.material.DisableKeyword("CLOUD_ON");
        }
        else
        {
            grading.material.EnableKeyword("CLOUD_ON");
        }
        grading.profile.vignette.enable = EMono.scene.profile.light.vignette;
        grading.profile.vignette.vignetteColor = EMono.scene.profile.light.vignetteColor;
        this.RefreshSky();
        this.RefreshTilt();
    }
 
    // Token: 0x06000A88 RID: 2696 RVA: 0x00040564 File Offset: 0x0003E764
    public void RefreshScreenSize()
    {
        this.Zoom = EMono.scene.camSupport.Zoom;
        this.width = (int)((float)Screen.width / this.tileSize.x / this.Zoom) + (int)this.paddings.x + 2;
        this.height = (int)((float)Screen.height / (this.tileSize.y / 2f) / this.Zoom) + (int)this.paddings.y + 4;
        this.camSupport.divier = EMono.core.config.fix.divider;
        this.camSupport.ResizeCameraToPixelPerfect();
        Vector3 localScale = new Vector3(EMono.scene.cam.orthographicSize * ((float)Screen.width / (float)Screen.height) * 2.5f, EMono.scene.cam.orthographicSize * 2.5f, 1f);
        if (EMono.core.IsGameStarted)
        {
            EMono.scene.skyBG.transform.localScale = localScale;
            float num = (ActionMode.IsAdv || this.Zoom >= 1f || EMono._map.IsIndoor) ? 0f : (0.4f / this.Zoom);
            if (EMono.world.weather.CurrentCondition == Weather.Condition.SnowHeavy)
            {
                num += 0.8f;
            }
            if (!EMono.player.simulatingZone)
            {
                EMono.scene.sfxWind.SetVolume(Mathf.Min(num, 1f));
            }
        }
        Vector3 vector = EMono.scene.cam.transform.position;
        EMono.scene.cam.transform.position = Vector3.zero;
        Vector3 vector2 = EMono.scene.cam.WorldToScreenPoint(Vector3.zero);
        this.screenFixX2 = vector2.x % this.screenFixX * this.screenFixX3;
        this.screenFixY2 = vector2.y % this.screenFixY * this.screenFixY3;
        EMono.scene.cam.transform.position = vector;
    }
 
    // Token: 0x06000A89 RID: 2697 RVA: 0x0004077C File Offset: 0x0003E97C
    public Point GetRandomPoint()
    {
        int num = EMono.screen.scrollX - EMono.screen.scrollY + this.width / 2 - (this.height / 2 + 1) / 2;
        int num2 = EMono.screen.scrollY + EMono.screen.scrollX + this.width / 2 + this.height / 2 / 2;
        num = num - 20 + EMono.rnd(40);
        num2 = num2 - 20 + EMono.rnd(40);
        return this._randomPoint.Set(num, num2);
    }
 
    // Token: 0x06000A8A RID: 2698 RVA: 0x00040808 File Offset: 0x0003EA08
    public void RefreshSky()
    {
        CoreConfig.GraphicSetting graphic = EMono.core.config.graphic;
        bool indoor = EMono._map.config.indoor;
        EMono.scene.firefly.baseParticleCount = graphic.fireflyCount;
        EMono.scene.fireflyNight.baseParticleCount = graphic.fireflyCount * 10;
        EMono.scene.star.baseParticleCount = graphic.starCount;
        EMono.scene.star.gameObject.GetComponent<ParticleSystemRenderer>().enabled = EMono.world.date.IsNight;
        EMono.scene.star.SetActive(this.IsLocalMap && !indoor);
        EMono.scene.firefly.SetActive(this.IsLocalMap && graphic.firefly && !indoor);
        EMono.scene.fireflyNight.SetActive(this.IsLocalMap && graphic.firefly && !indoor);
        if (this.overlayShadow && EMono.scene.profile.matOverlay && this is GameScreen)
        {
            this.overlayShadow.sharedMaterial.SetFloat("_ShadowStrength", EMono._map.config.shadowStrength * (EMono._zone.IsSnowCovered ? 0.5f : 1f) * EMono.setting.render.shadowStrength);
        }
        this.RefreshWeather();
        this.RefreshGrading();
    }
 
    // Token: 0x06000A8B RID: 2699 RVA: 0x00040990 File Offset: 0x0003EB90
    public virtual void RefreshWeather()
    {
        bool flag;
        if (!EMono._map.config.indoor)
        {
            if (EMono.pc.IsInActiveZone)
            {
                Room room = EMono.pc.pos.cell.room;
                flag = (room != null && room.HasRoof);
            }
            else
            {
                flag = false;
            }
        }
        else
        {
            flag = true;
        }
        bool flag2 = flag;
        Room room2 = EMono.pc.pos.cell.room;
        bool flag3 = room2 != null && room2.data.atrium;
        Weather weather = EMono.world.weather;
        Weather.Condition currentCondition = weather.CurrentCondition;
        EMono.scene.filterRain.enabled = (!flag2 && weather.IsRaining && EMono.core.config.graphic.enhanceRain);
        EMono.scene.filterRain.Fade = ((currentCondition == Weather.Condition.RainHeavy) ? 0.4f : 0.3f);
        EMono.scene.rain.enableEmission = (!flag2 && weather.IsRaining);
        EMono.scene.rain.emission.rateOverTime = (float)((currentCondition == Weather.Condition.RainHeavy) ? 750 : 200);
        EMono.scene.snow.enableEmission = (!flag2 && currentCondition == Weather.Condition.Snow);
        EMono.scene.ether.enableEmission = (!flag2 && weather.IsEther);
        bool enableEmission = !flag2 && weather.IsBlossom;
        ParticleSystem[] array = EMono.scene.blossoms;
        for (int i = 0; i < array.Length; i++)
        {
            array[i].enableEmission = enableEmission;
        }
        enableEmission = (!flag2 && currentCondition == Weather.Condition.SnowHeavy && EMono.core.config.graphic.blizzard);
        array = EMono.scene.blizzards;
        for (int i = 0; i < array.Length; i++)
        {
            array[i].enableEmission = enableEmission;
        }
        EMono.scene.transBlizzard.localScale = new Vector3(1f, 1f, 1f);
        bool flag4 = (EMono._map.config.forceGodRay || (EMono.core.config.graphic.godray && !flag2 && (currentCondition == Weather.Condition.Fine || currentCondition == Weather.Condition.Snow))) && !BuildMenu.Instance;
        EMono.scene.godray.SetActive(flag4, delegate(bool enabled)
        {
            if (!enabled)
            {
                EMono.scene.godray.Clear();
            }
        });
        EMono.scene.godrayDust.SetActive(flag4 && EMono.world.date.IsNight);
        EMono.scene.snow.SetActive(true);
        EMono.scene.rain.SetActive(true);
        EMono.scene.ether.SetActive(true);
        EMono.scene.blossom.SetActive(true);
        float num = (EMono._zone.lv <= -2) ? 0f : ((EMono._zone.lv <= -1) ? 0.3f : ((flag2 && !flag3) ? 0.6f : 1f));
        EMono.scene.sfxRain.SetVolume(weather.IsRaining ? num : 0f);
        EMono.scene.sfxSea.SetVolume(EMono._zone.VolumeSea * num);
        EMono.scene.camSupport.grading.profile.fog = EMono.setting.render.fogs[EMono._map.config.fog];
        EMono.scene.camSupport.grading.userFog = ((!EMono._map.config.indoor && flag2) ? 0f : 1f);
        float num2 = (!EMono._map.IsIndoor && EMono.world.weather.IsRaining) ? ((currentCondition == Weather.Condition.RainHeavy) ? -0.08f : -0.04f) : 0f;
        if (EMono._zone.IsSnowCovered)
        {
            num2 += EMono.scene.profile.global.snowBrightness;
        }
        this.camSupport.grading.sceneBrightness = num2;
        EMono.scene.rain.main.prewarm = (EMono.scene.snow.main.prewarm = (EMono.scene.ether.main.prewarm = false));
        array = EMono.scene.blossoms;
        for (int i = 0; i < array.Length; i++)
        {
            array[i].main.prewarm = false;
        }
        this.camSupport.grading.SetGrading();
    }
 
    // Token: 0x06000A8C RID: 2700 RVA: 0x00040E54 File Offset: 0x0003F054
    public void RefreshGrading()
    {
        float timeRatio = EMono.core.IsGameStarted ? EMono.scene.timeRatio : 0f;
        if (this.camSupport.grading.profile.overlay)
        {
            this.camSupport.grading.profile.overlay.Refresh(timeRatio, EMono._zone.IsSnowCovered);
        }
        ScreenGrading.blind = EMono.pc.isBlind;
        this.camSupport.grading.profile.sharpen.enable = (EMono.core.config.graphic.sharpen > 0);
        this.camSupport.grading.profile.sharpen.Strength = Mathf.Clamp(0.1f * (float)EMono.core.config.graphic.sharpen, 0f, (this is GameScreen) ? 10f : 1f);
        this.camSupport.beautify.sharpen = Mathf.Clamp(0.01f * (float)EMono.core.config.graphic.sharpen2, 0f, (this is GameScreen) ? 10f : 0.5f);
        this.camSupport.grading.SetGrading();
        SceneTemplate sceneTemplate = SceneTemplate.Load(EMono._map.config.idSceneTemplate.IsEmpty(EMono._zone.IDSceneTemplate));
        Color color = EMono._map.config.colorScreen.Get();
        if (color.a == 0f)
        {
            color = sceneTemplate.colorScreen;
        }
        this.camSupport.beautify.tintColor = color;
        color = EMono._map.config.colorSea.Get();
        MATERIAL.sourceWaterSea.matColor = ((color.a == 0f) ? MATERIAL.sourceWaterSea.GetColor() : color);
        EMono.core.config.RefreshUIBrightness();
        float num = 0f;
        if (!EMono._map.IsIndoor)
        {
            num += 0.01f * EMono.core.config.test.brightnessNight * EMono.scene.profile.light.nightRatioCurve.Evaluate(EMono.scene.timeRatio);
        }
        this.camSupport.grading.nightBrightness = num;
    }
 
    // Token: 0x06000A8D RID: 2701 RVA: 0x000410B8 File Offset: 0x0003F2B8
    public void RefreshTilt()
    {
        this.camSupport.tiltShift.enabled = ((ActionMode.Bird.IsActive || EMono._zone.IsRegion) ? EMono.game.config.tiltRegion : EMono.game.config.tilt);
        this.camSupport.tiltShift.blurArea = (ActionMode.Bird.IsActive ? 12f : (0.1f * (float)(EMono._zone.IsRegion ? EMono.game.config.tiltPowerRegion : EMono.game.config.tiltPower)));
    }
 
    // Token: 0x06000A8E RID: 2702 RVA: 0x00041164 File Offset: 0x0003F364
    public void ScrollMouse(float x, float y)
    {
        this.position.x = this.position.x + x / this.Zoom;
        this.position.y = this.position.y + y / this.Zoom;
        if (x > 0.1f || x < -0.1f || y > 0.1f || y < 0.1f)
        {
            this.RefreshPosition();
        }
    }
 
    // Token: 0x06000A8F RID: 2703 RVA: 0x000411C8 File Offset: 0x0003F3C8
    public void ScrollAxis(Vector3 axis, bool direct = false)
    {
        if (direct)
        {
            this.position += axis;
            return;
        }
        this.position += axis * Core.delta * this.camSpeed2 * EMono.core.config.camera.senseKeyboard / this.Zoom;
    }
 
    // Token: 0x06000A90 RID: 2704 RVA: 0x00041236 File Offset: 0x0003F436
    public void Focus(Int3 ints)
    {
        this.position = new Vector3((float)ints.x, (float)ints.y, (float)ints.z);
    }
 
    // Token: 0x06000A91 RID: 2705 RVA: 0x00041258 File Offset: 0x0003F458
    public void Focus(int x, int y)
    {
        if (EMono.AdvMode)
        {
            SE.Beep();
            return;
        }
        this.scrollX = x;
        this.position.x = (float)x;
        this.scrollY = y;
        this.position.y = (float)y;
    }
 
    // Token: 0x06000A92 RID: 2706 RVA: 0x0004129E File Offset: 0x0003F49E
    public void Focus(Card c)
    {
        if (c == null)
        {
            return;
        }
        this.Focus(c.GetRootCard().pos);
    }
 
    // Token: 0x06000A93 RID: 2707 RVA: 0x000412B8 File Offset: 0x0003F4B8
    public void FocusCenter()
    {
        Point pos = new Point(EMono._map.Size / 2, EMono._map.Size / 2);
        this.Focus(pos);
    }
 
    // Token: 0x06000A94 RID: 2708 RVA: 0x000412EA File Offset: 0x0003F4EA
    public unsafe void Focus(Point pos)
    {
        this.position = *pos.PositionCenter();
    }
 
    // Token: 0x06000A95 RID: 2709 RVA: 0x00041300 File Offset: 0x0003F500
    public void FocusPC()
    {
        this.focusPos = null;
        this.Focus((EMono.pc.currentZone == EMono.game.activeZone) ? EMono.pc.pos : EMono._map.bounds.GetCenterPos());
        this.instantFocus = true;
        this.RefreshPosition();
    }
 
    // Token: 0x06000A96 RID: 2710 RVA: 0x0004135D File Offset: 0x0003F55D
    public void FocusImmediate(Point pos)
    {
        this.focusPos = null;
        this.Focus(pos);
        this.instantFocus = true;
        this.RefreshPosition();
        this.RefreshPosition();
    }
 
    // Token: 0x06000A97 RID: 2711 RVA: 0x00041388 File Offset: 0x0003F588
    public void SnapScreen(ref Vector3 v, float zoom)
    {
        float num = this.snapSize.x / zoom;
        float num2 = this.snapSize.y / zoom;
        switch (EMono.core.config.fix.snapType)
        {
        case CoreConfig.ScreenSnapType.Default:
            v.x = num * (float)Mathf.RoundToInt(v.x / num);
            v.y = num2 * (float)Mathf.RoundToInt(v.y / num2);
            return;
        case CoreConfig.ScreenSnapType.Floor:
            v.x = num * (float)Mathf.FloorToInt(v.x / num);
            v.y = num2 * (float)Mathf.FloorToInt(v.y / num2);
            return;
        case CoreConfig.ScreenSnapType.Ceil:
            v.x = num * (float)Mathf.CeilToInt(v.x / num);
            v.y = num2 * (float)Mathf.CeilToInt(v.y / num2);
            return;
        case CoreConfig.ScreenSnapType.Hack3:
            num = this.snapSize.x;
            num2 = this.snapSize.y;
            v.x = num * (float)Mathf.RoundToInt(v.x / num);
            v.y = num2 * (float)Mathf.RoundToInt(v.y / num2);
            return;
        case CoreConfig.ScreenSnapType.Hack4:
            num = this.snapSize.x;
            num2 = this.snapSize.y;
            v.x = num * (float)Mathf.FloorToInt(v.x / num);
            v.y = num2 * (float)Mathf.FloorToInt(v.y / num2);
            return;
        case CoreConfig.ScreenSnapType.Hack5:
            num = this.snapSize.x;
            num2 = this.snapSize.y;
            v.x = num * (float)Mathf.CeilToInt(v.x / num);
            v.y = num2 * (float)Mathf.CeilToInt(v.y / num2);
            return;
        case CoreConfig.ScreenSnapType.Hack6:
            v.x = 0.01f * (float)Mathf.FloorToInt(v.x * 100f) + 0.001f;
            v.y = 0.01f * (float)Mathf.FloorToInt(v.y * 100f) + 0.001f;
            return;
        case CoreConfig.ScreenSnapType.Hack7:
            v.x = 0.01f * (float)Mathf.FloorToInt(v.x * 100f) - 0.001f;
            v.y = 0.01f * (float)Mathf.FloorToInt(v.y * 100f) - 0.001f;
            return;
        case CoreConfig.ScreenSnapType.Hack8:
            v.x = 0.01f * (float)Mathf.RoundToInt(v.x * 100f) + 0.005f;
            v.y = 0.01f * (float)Mathf.RoundToInt(v.y * 100f) + 0.005f;
            return;
        case CoreConfig.ScreenSnapType.Hack9:
            v.x = 0.01f * (float)Mathf.RoundToInt(v.x * 100f) + 0.025f;
            v.y = 0.01f * (float)Mathf.RoundToInt(v.y * 100f) + 0.025f;
            return;
        default:
            return;
        }
    }
 
    // Token: 0x06000A98 RID: 2712 RVA: 0x00041670 File Offset: 0x0003F870
    public void SetZoom(float z)
    {
        this.Zoom = z;
        this.targetZoom = z;
        EMono.core.config.ApplyZoom(this.targetZoom);
        this.zoomTimer = 0f;
    }
 
    // Token: 0x06000A99 RID: 2713 RVA: 0x000416B0 File Offset: 0x0003F8B0
    public void SetTargetZoomIndex(int index)
    {
        this.targetZoomIndex = index;
        float num = this.targetZoom;
        this.targetZoom = EMono.core.config.camera.zooms[this.targetZoomIndex];
        if (num != this.targetZoom)
        {
            this.zoomTimer = 0f;
        }
    }
 
    // Token: 0x06000A9A RID: 2714 RVA: 0x00041700 File Offset: 0x0003F900
    public void ModTargetZoomIndex(int a)
    {
        if (EMono.scene.elomapActor.IsActive)
        {
            return;
        }
        int num = this.targetZoomIndex;
        this.targetZoomIndex -= a;
        int num2 = EMono.core.config.camera.extendZoomMin ? 0 : 1;
        int num3 = EMono.core.config.camera.extendZoomMax ? 4 : 3;
        if (this.targetZoomIndex < num2)
        {
            this.targetZoomIndex = num2;
        }
        else if (this.targetZoomIndex >= num3)
        {
            this.targetZoomIndex = num3;
        }
        if (this.targetZoomIndex > num && EInput.buttonScroll != null && !EInput.buttonScroll.pressing)
        {
            this.zoomPos = EInput.mposWorld;
        }
        this.SetTargetZoomIndex(this.targetZoomIndex);
    }
 
    // Token: 0x04000937 RID: 2359
    private readonly int _BackDrawPower = Shader.PropertyToID("_BackDrawPower");
 
    // Token: 0x04000938 RID: 2360
    private readonly int _Snow = Shader.PropertyToID("_Snow");
 
    // Token: 0x04000939 RID: 2361
    private readonly int _SkyLevel = Shader.PropertyToID("_SkyLevel");
 
    // Token: 0x0400093A RID: 2362
    private readonly int _NightRate = Shader.PropertyToID("_NightRate");
 
    // Token: 0x0400093B RID: 2363
    private readonly int _ViewHeight = Shader.PropertyToID("_ViewHeight");
 
    // Token: 0x0400093C RID: 2364
    private readonly int _FogStrength = Shader.PropertyToID("_FogStrength");
 
    // Token: 0x0400093D RID: 2365
    private readonly int _FogColor = Shader.PropertyToID("_FogColor");
 
    // Token: 0x0400093E RID: 2366
    private readonly int _FowColor = Shader.PropertyToID("_FowColor");
 
    // Token: 0x0400093F RID: 2367
    private readonly int _SunColor = Shader.PropertyToID("_SunColor");
 
    // Token: 0x04000940 RID: 2368
    private readonly int _SeaColor = Shader.PropertyToID("_SeaColor");
 
    // Token: 0x04000941 RID: 2369
    private readonly int _SkyColor = Shader.PropertyToID("_SkyColor");
 
    // Token: 0x04000942 RID: 2370
    private readonly int _SkyBGColor = Shader.PropertyToID("_SkyBGColor");
 
    // Token: 0x04000943 RID: 2371
    private readonly int _Offset = Shader.PropertyToID("_Offset");
 
    // Token: 0x04000944 RID: 2372
    private readonly int _Zoom = Shader.PropertyToID("_Zoom");
 
    // Token: 0x04000945 RID: 2373
    private readonly int _LightPower = Shader.PropertyToID("_LightPower");
 
    // Token: 0x04000946 RID: 2374
    private readonly int _AnimeSpeedGlobal = Shader.PropertyToID("_AnimeSpeedGlobal");
 
    // Token: 0x04000947 RID: 2375
    private readonly int _ScreenFlash = Shader.PropertyToID("_ScreenFlash");
 
    // Token: 0x04000948 RID: 2376
    public float SharpenAmount;
 
    // Token: 0x04000949 RID: 2377
    public float camSpeed2;
 
    // Token: 0x0400094A RID: 2378
    public float heightLight;
 
    // Token: 0x0400094B RID: 2379
    public float pushbackSpeed;
 
    // Token: 0x0400094C RID: 2380
    public Vector2 snapSize;
 
    // Token: 0x0400094D RID: 2381
    public Vector2 tileSize;
 
    // Token: 0x0400094E RID: 2382
    public Vector2 tileAlign;
 
    // Token: 0x0400094F RID: 2383
    public Vector2 tileWorldSize;
 
    // Token: 0x04000950 RID: 2384
    public Vector2 tileViewSize;
 
    // Token: 0x04000951 RID: 2385
    public Vector3 tileWeight;
 
    // Token: 0x04000952 RID: 2386
    public Vector3 focusFix;
 
    // Token: 0x04000953 RID: 2387
    public Vector3 tileOffsetHeight;
 
    // Token: 0x04000954 RID: 2388
    public Vector3 tileWeightHeight;
 
    // Token: 0x04000955 RID: 2389
    public Vector3 planeAngle;
 
    // Token: 0x04000956 RID: 2390
    public Vector3 planeSpeed;
 
    // Token: 0x04000957 RID: 2391
    public Vector2 paddings;
 
    // Token: 0x04000958 RID: 2392
    public Vector2 paddingOffset;
 
    // Token: 0x04000959 RID: 2393
    public Vector3 lastPos;
 
    // Token: 0x0400095A RID: 2394
    public Rect mapLimit;
 
    // Token: 0x0400095B RID: 2395
    [Space]
    public float Zoom;
 
    // Token: 0x0400095C RID: 2396
    [Space]
    public float nextMove;
 
    // Token: 0x0400095D RID: 2397
    [Space]
    public float focusSpeed;
 
    // Token: 0x0400095E RID: 2398
    [Space]
    public float focusSpeedSlow;
 
    // Token: 0x0400095F RID: 2399
    [Space]
    public float focusSpeedSlow2;
 
    // Token: 0x04000960 RID: 2400
    public int width;
 
    // Token: 0x04000961 RID: 2401
    public int height;
 
    // Token: 0x04000962 RID: 2402
    public int scrollX;
 
    // Token: 0x04000963 RID: 2403
    public int scrollY;
 
    // Token: 0x04000964 RID: 2404
    public int moonLevel;
 
    // Token: 0x04000965 RID: 2405
    public BaseTileMap tileMap;
 
    // Token: 0x04000966 RID: 2406
    public BaseTileSelector tileSelector;
 
    // Token: 0x04000967 RID: 2407
    public ScreenGuide guide;
 
    // Token: 0x04000968 RID: 2408
    public Grid grid;
 
    // Token: 0x04000969 RID: 2409
    public MeshRenderer overlayShadow;
 
    // Token: 0x0400096A RID: 2410
    public PCOrbit pcOrbit;
 
    // Token: 0x0400096B RID: 2411
    [NonSerialized]
    public float forcePrecision;
 
    // Token: 0x0400096C RID: 2412
    [NonSerialized]
    public bool isCameraMoving;
 
    // Token: 0x0400096D RID: 2413
    [NonSerialized]
    public BaseGameScreen.FocusOption focusOption;
 
    // Token: 0x0400096E RID: 2414
    [NonSerialized]
    public Vector3? focusPos;
 
    // Token: 0x0400096F RID: 2415
    [NonSerialized]
    public Vector3 position;
 
    // Token: 0x04000970 RID: 2416
    protected Vector3 camPos;
 
    // Token: 0x04000971 RID: 2417
    protected Vector3 pushBack;
 
    // Token: 0x04000972 RID: 2418
    public float screenFixX;
 
    // Token: 0x04000973 RID: 2419
    public float screenFixX2;
 
    // Token: 0x04000974 RID: 2420
    public float screenFixX3;
 
    // Token: 0x04000975 RID: 2421
    public float screenFixX4;
 
    // Token: 0x04000976 RID: 2422
    public float screenFixY;
 
    // Token: 0x04000977 RID: 2423
    public float screenFixY2;
 
    // Token: 0x04000978 RID: 2424
    public float screenFixY3;
 
    // Token: 0x04000979 RID: 2425
    public float screenFixY4;
 
    // Token: 0x0400097A RID: 2426
    private Vector3 _camPos;
 
    // Token: 0x0400097B RID: 2427
    private Point _randomPoint = new Point();
 
    // Token: 0x0400097C RID: 2428
    [NonSerialized]
    public bool instantFocus;
 
    // Token: 0x0400097D RID: 2429
    public int targetZoomIndex;
 
    // Token: 0x0400097E RID: 2430
    public float targetZoom = 0.5f;
 
    // Token: 0x0400097F RID: 2431
    public float zoomTimer;
 
    // Token: 0x04000980 RID: 2432
    public Vector3 zoomPos;
 
    // Token: 0x0200087A RID: 2170
    public class FocusOption
    {
        // Token: 0x0400243A RID: 9274
        public Point pos;
 
        // Token: 0x0400243B RID: 9275
        public float speed = 2f;
 
        // Token: 0x0400243C RID: 9276
        public bool linear = true;
 
        // Token: 0x0400243D RID: 9277
        public bool player;
    }
}