Elin Decompiled Documentation EA 23.102 Nightly
Loading...
Searching...
No Matches
BaseGameScreen.cs
Go to the documentation of this file.
1using System;
2using UnityEngine;
3
4public class BaseGameScreen : EMono
5{
6 public class FocusOption
7 {
8 public Point pos;
9
10 public float speed = 2f;
11
12 public bool linear = true;
13
14 public bool player;
15 }
16
17 private readonly int _BackDrawPower = Shader.PropertyToID("_BackDrawPower");
18
19 private readonly int _Snow = Shader.PropertyToID("_Snow");
20
21 private readonly int _SkyLevel = Shader.PropertyToID("_SkyLevel");
22
23 private readonly int _NightRate = Shader.PropertyToID("_NightRate");
24
25 private readonly int _ViewHeight = Shader.PropertyToID("_ViewHeight");
26
27 private readonly int _FogStrength = Shader.PropertyToID("_FogStrength");
28
29 private readonly int _FogColor = Shader.PropertyToID("_FogColor");
30
31 private readonly int _FowColor = Shader.PropertyToID("_FowColor");
32
33 private readonly int _SunColor = Shader.PropertyToID("_SunColor");
34
35 private readonly int _SeaColor = Shader.PropertyToID("_SeaColor");
36
37 private readonly int _SkyColor = Shader.PropertyToID("_SkyColor");
38
39 private readonly int _SkyBGColor = Shader.PropertyToID("_SkyBGColor");
40
41 private readonly int _Offset = Shader.PropertyToID("_Offset");
42
43 private readonly int _Zoom = Shader.PropertyToID("_Zoom");
44
45 private readonly int _LightPower = Shader.PropertyToID("_LightPower");
46
47 private readonly int _AnimeSpeedGlobal = Shader.PropertyToID("_AnimeSpeedGlobal");
48
49 private readonly int _ScreenFlash = Shader.PropertyToID("_ScreenFlash");
50
51 public float SharpenAmount;
52
53 public float camSpeed2;
54
55 public float heightLight;
56
57 public float pushbackSpeed;
58
59 public Vector2 snapSize;
60
61 public Vector2 tileSize;
62
63 public Vector2 tileAlign;
64
65 public Vector2 tileWorldSize;
66
67 public Vector2 tileViewSize;
68
69 public Vector3 tileWeight;
70
71 public Vector3 focusFix;
72
73 public Vector3 tileOffsetHeight;
74
75 public Vector3 tileWeightHeight;
76
77 public Vector3 planeAngle;
78
79 public Vector3 planeSpeed;
80
81 public Vector2 paddings;
82
83 public Vector2 paddingOffset;
84
85 public Vector3 lastPos;
86
87 public Rect mapLimit;
88
89 [Space]
90 public float Zoom;
91
92 [Space]
93 public float nextMove;
94
95 [Space]
96 public float focusSpeed;
97
98 [Space]
99 public float focusSpeedSlow;
100
101 [Space]
102 public float focusSpeedSlow2;
103
104 public int width;
105
106 public int height;
107
108 public int scrollX;
109
110 public int scrollY;
111
112 public int moonLevel;
113
115
117
119
120 public Grid grid;
121
122 public MeshRenderer overlayShadow;
123
125
126 [NonSerialized]
127 public float forcePrecision;
128
129 [NonSerialized]
130 public bool isCameraMoving;
131
132 [NonSerialized]
134
135 [NonSerialized]
136 public Vector3? focusPos;
137
138 [NonSerialized]
139 public Vector3 position;
140
141 protected Vector3 camPos;
142
143 protected Vector3 pushBack;
144
145 public float screenFixX;
146
147 public float screenFixX2;
148
149 public float screenFixX3;
150
151 public float screenFixX4;
152
153 public float screenFixY;
154
155 public float screenFixY2;
156
157 public float screenFixY3;
158
159 public float screenFixY4;
160
161 private Vector3 _camPos;
162
163 private Point _randomPoint = new Point();
164
165 [NonSerialized]
166 public bool instantFocus;
167
168 public int targetZoomIndex;
169
170 public float targetZoom = 0.5f;
171
172 public float zoomTimer;
173
174 public Vector3 zoomPos;
175
176 public bool fixFocus => EMono.scene.actionMode?.FixFocus ?? false;
177
178 public virtual float TargetZoom => EMono.scene.actionMode.TargetZoom;
179
181
182 protected Transform transFocus => EMono.scene.transFocus;
183
184 public virtual float SkyRate => Mathf.Clamp((1.2f - Zoom) * 2f - (EMono._zone.IsSnowCovered ? 0.38f : 0f), 0f, 2f);
185
186 public virtual float ViewHeight => SkyRate * 10f + 5f;
187
188 public virtual bool IsGameScreen => true;
189
190 public virtual bool IsLocalMap => false;
191
192 public void Activate()
193 {
194 if (!(EMono.core.screen == this))
195 {
196 if (EMono.core.screen != null)
197 {
199 }
200 SetUnitSize();
201 EMono.core.screen = this;
202 Point._screen = this;
203 base.gameObject.SetActive(value: true);
204 EMono.scene.flock.SetActive(IsLocalMap);
206 EMono.scene.firefly.SetActive(IsLocalMap);
207 EMono.scene.star.SetActive(IsLocalMap);
208 EMono.scene.sfxRain.SetActive(IsGameScreen);
209 EMono.scene.sfxSea.SetActive(IsGameScreen);
210 EMono.scene.sfxWind.SetActive(IsGameScreen);
211 EMono.scene.sfxFire.SetActive(IsGameScreen);
212 OnActivate();
213 ParticleSystem.MainModule main = EMono.scene.rain.main;
214 ParticleSystem.MainModule main2 = EMono.scene.snow.main;
215 ParticleSystem.MainModule main3 = EMono.scene.ether.main;
216 bool flag2 = (main3.prewarm = true);
217 bool prewarm = (main2.prewarm = flag2);
218 main.prewarm = prewarm;
219 ParticleSystem[] blossoms = EMono.scene.blossoms;
220 for (int i = 0; i < blossoms.Length; i++)
221 {
222 ParticleSystem.MainModule main4 = blossoms[i].main;
223 main4.prewarm = true;
224 }
225 if ((bool)overlayShadow)
226 {
228 overlayShadow.sharedMaterial = EMono.scene.profile.matOverlay;
229 }
230 EMono.scene.camSupport.grading.material = EMono.scene.profile.matGrading;
231 if (IsGameScreen)
232 {
235 RefreshAll();
236 tileMap.OnActivate(this);
238 }
239 else if (EMono.core.config != null)
240 {
242 }
243 }
244 }
245
246 public virtual void OnActivate()
247 {
248 }
249
250 public void Deactivate()
251 {
252 OnDeactivate();
253 base.gameObject.SetActive(value: false);
254 EMono.core.screen = null;
255 }
256
257 public virtual void OnDeactivate()
258 {
259 }
260
261 public virtual void SetUnitSize()
262 {
263 }
264
265 public virtual void OnEndPlayerTurn()
266 {
267 }
268
269 public void Draw()
270 {
271 if (!IsGameScreen)
272 {
273 return;
274 }
275 if (Zoom != targetZoom)
276 {
277 bool flag = EMono.scene.actionMode == ActionMode.Bird;
279 float num = camera.zoomSpeed * (flag ? 0.05f : (camera.linearZoom ? 2f : 1f)) * Core.delta;
280 zoomTimer += num * 0.3f;
281 float t = ((flag || !camera.linearZoom) ? num : zoomTimer);
282 float num2 = Mathf.Lerp(EMono.screen.Zoom, targetZoom, t);
283 if (Mathf.Abs(num2 - targetZoom) < (flag ? 0.0005f : 0.003f))
284 {
285 num2 = targetZoom;
286 }
287 if (camera.zoomToMouse && zoomPos != Vector3.zero)
288 {
289 position = Vector3.Lerp(position, zoomPos, t);
290 }
292 }
293 RenderObject.gameSpeed = EMono.scene.actionMode.gameSpeed;
294 RenderObject.gameDelta = Core.gameDeltaNoPause;
296 {
297 if (Zoom != targetZoom)
298 {
300 }
301 Vector3 vector = (EMono.pc.isSynced ? EMono.player.position : EMono.pc.pos.Position()) + focusFix;
302 position = vector;
303 scrollX = Mathf.FloorToInt(position.x / tileWorldSize.x) - width / 2 + (int)paddingOffset.x;
304 scrollY = Mathf.FloorToInt(position.y / tileWorldSize.y) - height / 4 + (int)paddingOffset.y;
305 }
306 tileMap.Draw();
307 if (instantFocus)
308 {
309 instantFocus = false;
310 }
312 if (EMono.game.activeZone != null)
313 {
314 for (int num3 = EMono._map.pointAnimes.Count - 1; num3 >= 0; num3--)
315 {
316 if (EMono._map.pointAnimes[num3].Update())
317 {
318 EMono._map.pointAnimes.RemoveAt(num3);
319 }
320 }
321 }
323 if (Scene.skipAnime)
324 {
326 Scene.skipAnime = false;
327 }
329 FlockController flock = EMono.scene.flock;
330 int visible;
331 if (targetZoom <= 1.25f)
332 {
333 Room room = EMono.pc.pos.cell.room;
334 visible = ((room == null || !room.HasRoof) ? 1 : 0);
335 }
336 else
337 {
338 visible = 0;
339 }
340 flock.UpdateVisible((byte)visible != 0);
341 if (EMono.pc.isSynced && (bool)EMono.pc.renderer.orbit)
342 {
344 }
345 }
346
347 public void UpdateShaders(float time = 0f)
348 {
350 SceneColorProfile color = profile.color;
351 SceneLightProfile light = profile.light;
352 Color value = color.fog.Evaluate(time);
353 float value2 = light.nightRatioCurve.Evaluate(time);
354 Shader.SetGlobalFloat(_Snow, EMono._zone.IsSnowCovered ? 1f : 0f);
355 Shader.SetGlobalFloat(_BackDrawPower, (!ActionMode.Cinema.IsActive) ? EMono.game.config.backDrawAlpha : 0);
356 Shader.SetGlobalFloat(_SkyLevel, SkyRate);
357 Shader.SetGlobalFloat(_NightRate, value2);
358 Shader.SetGlobalFloat(_ViewHeight, ViewHeight);
359 Shader.SetGlobalFloat(_FogStrength, value.a * 0.1f);
360 Shader.SetGlobalColor(_FogColor, value);
362 if ((bool)EMono._map.fowProfile)
363 {
364 fowProfile = EMono._map.fowProfile;
365 }
366 if ((bool)fowProfile)
367 {
368 switch (fowProfile.type)
369 {
370 case FOWType.Color:
371 Shader.SetGlobalColor(_FowColor, fowProfile.color);
372 break;
373 case FOWType.ColorAdd:
374 Shader.SetGlobalColor(_FowColor, fowProfile.color * color.fow.Evaluate(time));
375 break;
376 default:
377 Shader.SetGlobalColor(_FowColor, color.fow.Evaluate(time));
378 break;
379 }
380 }
381 else
382 {
383 Shader.SetGlobalColor(_FowColor, color.fow.Evaluate(time));
384 }
385 Shader.SetGlobalColor(_SunColor, EMono._zone.IsSnowCovered ? color.sunSnow.Evaluate(time) : color.sun.Evaluate(time));
386 Shader.SetGlobalColor(_SeaColor, color.sea.Evaluate(time));
387 Shader.SetGlobalColor(_SkyColor, color.sky.Evaluate(time));
388 Shader.SetGlobalColor(_SkyBGColor, color.skyBG.Evaluate(time));
389 Shader.SetGlobalVector(_Offset, EMono.core.config.camera.extendZoomMin ? (position * 0.3f) : (position * 0.5f));
390 Shader.SetGlobalFloat(_Zoom, Zoom);
391 Shader.SetGlobalFloat(_LightPower, light.lightPower.Evaluate(time) * light.lightPowerMod);
392 Shader.SetGlobalFloat(_AnimeSpeedGlobal, EMono.game.config.animeSpeed);
393 Shader.SetGlobalColor(_ScreenFlash, ScreenFlash.currentColor);
394 ParticleSystem.MainModule main = EMono.scene.godray.main;
395 main.startColor = (EMono._zone.IsSnowCovered ? color.godraySnow.Evaluate(time) : color.godray.Evaluate(time));
396 camSupport.grading.vignettePower = light.vignetteCurve.Evaluate(time);
397 camSupport.grading.UpdateVignette();
398 camSupport.bloom.threshold = light.bloomCurve.Evaluate(time);
399 camSupport.beautify.bloomIntensity = light.bloomCurve2.Evaluate(time);
400 }
401
402 public virtual void OnChangeHour()
403 {
404 }
405
406 public virtual void RefreshPosition()
407 {
409 {
410 return;
411 }
412 if (focusOption != null)
413 {
414 Vector3 vector = (focusOption.player ? (EMono.pc.pos.Position() + focusFix) : focusOption.pos.PositionCenter());
415 vector.z = position.z;
417 {
418 position = Vector3.MoveTowards(position, vector, focusOption.speed * Core.delta);
419 }
420 else
421 {
422 position = Vector3.Lerp(position, vector, focusOption.speed * Core.delta);
423 }
424 }
425 else if (focusPos.HasValue)
426 {
427 Vector3 obj = focusPos ?? position;
428 float x = obj.x;
429 Vector3 obj2 = focusPos ?? position;
430 focusPos = new Vector3(x, obj2.y, position.z);
432 if (Vector3.Distance(position, focusPos ?? position) < 0.1f)
433 {
434 focusPos = null;
435 }
436 }
437 else if ((bool)transFocus)
438 {
439 pushBack = Vector3.zero;
440 position.x = transFocus.position.x;
441 position.y = transFocus.position.y;
442 }
443 else if (fixFocus)
444 {
445 float z = position.z;
447 for (int i = 0; i < EMono.core.config.camera.zooms.Length; i++)
448 {
450 {
451 targetZoomIndex = i;
452 }
453 }
454 Vector3 b = (EMono.pc.isSynced ? EMono.player.position : EMono.pc.pos.Position()) + focusFix;
455 if (instantFocus)
456 {
457 position = b;
458 }
460 {
461 position = Vector3.Lerp(position, b, focusSpeed * Core.delta * Mathf.Lerp(0.2f, 1f, 1f - Mathf.Clamp(ActionMode.Adv.rightMouseTimer, 0f, 1f)));
462 }
463 else
464 {
465 position = b;
466 }
467 position.z = z;
468 pcOrbit.transform.position = EMono.pc.renderer.position;
469 }
470 else
471 {
473 {
475 }
476 pushBack = Vector3.zero;
477 int num = scrollX - scrollY;
478 int num2 = scrollY + scrollX;
479 if ((float)num <= mapLimit.x)
480 {
481 pushBack.x = mapLimit.x - (float)num;
482 }
483 if ((float)num2 <= mapLimit.y)
484 {
485 pushBack.y = mapLimit.y - (float)num2;
486 }
487 if ((float)num >= (float)EMono._map.Size + mapLimit.width - (float)(width / 2))
488 {
489 pushBack.x = (float)EMono._map.Size + mapLimit.width - (float)(width / 2) - (float)num;
490 }
491 if ((float)num2 >= (float)EMono._map.Size + mapLimit.height - (float)(height / 2))
492 {
493 pushBack.y = (float)EMono._map.Size + mapLimit.height - (float)(height / 2) - (float)num2;
494 }
495 position += Quaternion.Euler(planeAngle) * pushBack * Core.delta * pushbackSpeed;
496 }
497 scrollX = Mathf.FloorToInt(position.x / tileWorldSize.x) - width / 2 + (int)paddingOffset.x;
498 scrollY = Mathf.FloorToInt(position.y / tileWorldSize.y) - height / 4 + (int)paddingOffset.y;
499 if (lastPos.x != (float)scrollX || lastPos.y != (float)scrollY)
500 {
501 lastPos.x = scrollX;
502 lastPos.y = scrollY;
503 }
504 camPos.x = position.x;
505 camPos.y = position.y;
506 SnapScreen(ref camPos, Zoom);
507 camPos.z = -500f;
508 _camPos.x = camPos.x + screenFixX2 + screenFixX4;
509 _camPos.y = camPos.y + screenFixY2 + screenFixY4;
510 _camPos.z = camPos.z;
511 EMono.scene.cam.transform.localPosition = _camPos;
512 camPos.z = 0f;
513 EMono.scene.transAudio.position = camPos + EMono.scene.posAudioListener;
514 if ((bool)WidgetMinimap.Instance)
515 {
517 }
518 }
519
520 public void RefreshAll()
521 {
523 bool indoor = EMono._map.config.indoor;
524 ScreenGrading grading = camSupport.grading;
525 EMono.scene.flock.SetActive(!indoor);
526 if (indoor)
527 {
528 grading.material.DisableKeyword("CLOUD_ON");
529 }
530 else
531 {
532 grading.material.EnableKeyword("CLOUD_ON");
533 }
535 {
536 EMono.scene.matFloorEx.EnableKeyword("EX_ON");
537 }
538 else
539 {
540 EMono.scene.matFloorEx.DisableKeyword("EX_ON");
541 }
542 grading.profile.vignette.enable = EMono.scene.profile.light.vignette;
543 grading.profile.vignette.vignetteColor = EMono.scene.profile.light.vignetteColor;
544 RefreshSky();
545 RefreshTilt();
546 }
547
548 public void RefreshScreenSize()
549 {
551 width = (int)((float)Screen.width / tileSize.x / Zoom) + (int)paddings.x + 2;
552 height = (int)((float)Screen.height / (tileSize.y / 2f) / Zoom) + (int)paddings.y + 4;
555 Vector3 localScale = new Vector3(EMono.scene.cam.orthographicSize * ((float)Screen.width / (float)Screen.height) * 2.5f, EMono.scene.cam.orthographicSize * 2.5f, 1f);
557 {
558 EMono.scene.skyBG.transform.localScale = localScale;
559 float num = ((ActionMode.IsAdv || Zoom >= 1f || EMono._map.IsIndoor) ? 0f : (0.4f / Zoom));
561 {
562 num += 0.8f;
563 }
565 {
566 EMono.scene.sfxWind.SetVolume(Mathf.Min(num, 1f));
567 }
568 }
569 Vector3 vector = EMono.scene.cam.transform.position;
570 EMono.scene.cam.transform.position = Vector3.zero;
571 Vector3 vector2 = EMono.scene.cam.WorldToScreenPoint(Vector3.zero);
572 screenFixX2 = vector2.x % screenFixX * screenFixX3;
573 screenFixY2 = vector2.y % screenFixY * screenFixY3;
574 EMono.scene.cam.transform.position = vector;
575 }
576
578 {
579 int num = EMono.screen.scrollX - EMono.screen.scrollY + width / 2 - (height / 2 + 1) / 2;
580 int num2 = EMono.screen.scrollY + EMono.screen.scrollX + width / 2 + height / 2 / 2;
581 num = num - 20 + EMono.rnd(40);
582 num2 = num2 - 20 + EMono.rnd(40);
583 return _randomPoint.Set(num, num2);
584 }
585
586 public void RefreshSky()
587 {
589 bool indoor = EMono._map.config.indoor;
590 EMono.scene.firefly.baseParticleCount = graphic.fireflyCount;
591 EMono.scene.fireflyNight.baseParticleCount = graphic.fireflyCount * 10;
592 EMono.scene.star.baseParticleCount = graphic.starCount;
593 EMono.scene.star.gameObject.GetComponent<ParticleSystemRenderer>().enabled = EMono.world.date.IsNight;
594 EMono.scene.star.SetActive(IsLocalMap && !indoor);
595 EMono.scene.firefly.SetActive(IsLocalMap && graphic.firefly && !indoor);
596 EMono.scene.fireflyNight.SetActive(IsLocalMap && graphic.firefly && !indoor);
597 if ((bool)overlayShadow && (bool)EMono.scene.profile.matOverlay && this is GameScreen)
598 {
599 overlayShadow.sharedMaterial.SetFloat("_ShadowStrength", EMono._map.config.shadowStrength * (EMono._zone.IsSnowCovered ? 0.5f : 1f) * EMono.setting.render.shadowStrength);
600 }
603 }
604
605 public virtual void RefreshWeather()
606 {
607 bool flag = EMono._map.config.indoor || (EMono.pc.IsInActiveZone && (EMono.pc.pos.cell.room?.HasRoof ?? false));
608 bool flag2 = EMono.pc.pos.cell.room?.data.atrium ?? false;
609 Weather weather = EMono.world.weather;
610 Weather.Condition currentCondition = weather.CurrentCondition;
611 EMono.scene.filterRain.enabled = !flag && weather.IsRaining && EMono.core.config.graphic.enhanceRain;
612 EMono.scene.filterRain.Fade = ((currentCondition == Weather.Condition.RainHeavy) ? 0.4f : 0.3f);
613 EMono.scene.rain.enableEmission = !flag && weather.IsRaining;
614 ParticleSystem.EmissionModule emission = EMono.scene.rain.emission;
615 emission.rateOverTime = ((currentCondition == Weather.Condition.RainHeavy) ? 750 : 200);
616 EMono.scene.snow.enableEmission = !flag && currentCondition == Weather.Condition.Snow;
617 EMono.scene.ether.enableEmission = !flag && weather.IsEther;
618 bool enableEmission = !flag && weather.IsBlossom;
619 ParticleSystem[] blossoms = EMono.scene.blossoms;
620 for (int i = 0; i < blossoms.Length; i++)
621 {
622 blossoms[i].enableEmission = enableEmission;
623 }
624 enableEmission = !flag && currentCondition == Weather.Condition.SnowHeavy && EMono.core.config.graphic.blizzard;
625 blossoms = EMono.scene.blizzards;
626 for (int i = 0; i < blossoms.Length; i++)
627 {
628 blossoms[i].enableEmission = enableEmission;
629 }
630 EMono.scene.transBlizzard.localScale = new Vector3(1f, 1f, 1f);
631 bool flag3 = (EMono._map.config.forceGodRay || (EMono.core.config.graphic.godray && !flag && (currentCondition == Weather.Condition.Fine || currentCondition == Weather.Condition.Snow))) && !BuildMenu.Instance;
632 EMono.scene.godray.SetActive(flag3, delegate(bool enabled)
633 {
634 if (!enabled)
635 {
636 EMono.scene.godray.Clear();
637 }
638 });
639 EMono.scene.godrayDust.SetActive(flag3 && EMono.world.date.IsNight);
640 EMono.scene.snow.SetActive(enable: true);
641 EMono.scene.rain.SetActive(enable: true);
642 EMono.scene.ether.SetActive(enable: true);
643 EMono.scene.blossom.SetActive(enable: true);
644 Zone zone = EMono._zone;
645 if (EMono._zone is Zone_Tent)
646 {
647 zone = (EMono._zone.parent as Zone) ?? EMono._zone;
648 }
649 float num = ((zone.lv <= -2) ? 0f : ((zone.lv <= -1) ? 0.3f : ((flag && !flag2) ? 0.6f : 1f)));
650 EMono.scene.sfxRain.SetVolume(weather.IsRaining ? num : 0f);
651 EMono.scene.sfxSea.SetVolume(EMono._zone.VolumeSea * num);
652 EMono.scene.camSupport.grading.profile.fog = EMono.setting.render.fogs[EMono._map.config.fog];
653 EMono.scene.camSupport.grading.userFog = ((!EMono._map.config.indoor && flag) ? 0f : 1f);
654 float num2 = ((EMono._map.IsIndoor || !EMono.world.weather.IsRaining) ? 0f : ((currentCondition == Weather.Condition.RainHeavy) ? (-0.08f) : (-0.04f)));
656 {
657 num2 += EMono.scene.profile.global.snowBrightness;
658 }
659 camSupport.grading.sceneBrightness = num2;
660 ParticleSystem.MainModule main = EMono.scene.rain.main;
661 ParticleSystem.MainModule main2 = EMono.scene.snow.main;
662 ParticleSystem.MainModule main3 = EMono.scene.ether.main;
663 bool flag5 = (main3.prewarm = false);
664 bool prewarm = (main2.prewarm = flag5);
665 main.prewarm = prewarm;
666 blossoms = EMono.scene.blossoms;
667 for (int i = 0; i < blossoms.Length; i++)
668 {
669 ParticleSystem.MainModule main4 = blossoms[i].main;
670 main4.prewarm = false;
671 }
672 camSupport.grading.SetGrading();
673 }
674
675 public void RefreshGrading()
676 {
677 float timeRatio = (EMono.core.IsGameStarted ? EMono.scene.timeRatio : 0f);
678 if ((bool)camSupport.grading.profile.overlay)
679 {
680 camSupport.grading.profile.overlay.Refresh(timeRatio, EMono._zone.IsSnowCovered);
681 }
682 ScreenGrading.blind = EMono.pc.isBlind;
683 camSupport.grading.profile.sharpen.enable = EMono.core.config.graphic.sharpen > 0;
684 camSupport.grading.profile.sharpen.Strength = Mathf.Clamp(0.1f * (float)EMono.core.config.graphic.sharpen, 0f, (this is GameScreen) ? 10f : 1f);
685 camSupport.beautify.sharpen = Mathf.Clamp(0.01f * (float)EMono.core.config.graphic.sharpen2, 0f, (this is GameScreen) ? 10f : 0.5f);
686 camSupport.grading.SetGrading();
688 Color tintColor = EMono._map.config.colorScreen.Get();
689 if (tintColor.a == 0f)
690 {
691 tintColor = sceneTemplate.colorScreen;
692 }
693 camSupport.beautify.tintColor = tintColor;
694 tintColor = EMono._map.config.colorSea.Get();
695 MATERIAL.sourceWaterSea.matColor = ((tintColor.a == 0f) ? MATERIAL.sourceWaterSea.GetColor() : tintColor);
697 float num = 0f;
698 if (!EMono._map.IsIndoor)
699 {
700 num += 0.01f * EMono.core.config.test.brightnessNight * EMono.scene.profile.light.nightRatioCurve.Evaluate(EMono.scene.timeRatio);
701 }
702 camSupport.grading.nightBrightness = num;
703 }
704
705 public void RefreshTilt()
706 {
707 camSupport.tiltShift.enabled = ((ActionMode.Bird.IsActive || EMono._zone.IsRegion) ? EMono.game.config.tiltRegion : EMono.game.config.tilt);
708 camSupport.tiltShift.blurArea = (ActionMode.Bird.IsActive ? 12f : (0.1f * (float)(EMono._zone.IsRegion ? EMono.game.config.tiltPowerRegion : EMono.game.config.tiltPower)));
709 }
710
711 public void ScrollMouse(float x, float y)
712 {
713 position.x += x / Zoom;
714 position.y += y / Zoom;
715 if (x > 0.1f || x < -0.1f || y > 0.1f || y < 0.1f)
716 {
718 }
719 }
720
721 public void ScrollAxis(Vector3 axis, bool direct = false)
722 {
723 if (direct)
724 {
725 position += axis;
726 }
727 else
728 {
729 position += axis * Core.delta * camSpeed2 * EMono.core.config.camera.senseKeyboard / Zoom;
730 }
731 }
732
733 public void Focus(Int3 ints)
734 {
735 position = new Vector3(ints.x, ints.y, ints.z);
736 }
737
738 public void Focus(int x, int y)
739 {
740 if (EMono.AdvMode)
741 {
742 SE.Beep();
743 return;
744 }
745 position.x = (scrollX = x);
746 position.y = (scrollY = y);
747 }
748
749 public void Focus(Card c)
750 {
751 if (c != null)
752 {
753 Focus(c.GetRootCard().pos);
754 }
755 }
756
757 public void FocusCenter()
758 {
759 Point pos = new Point(EMono._map.Size / 2, EMono._map.Size / 2);
760 Focus(pos);
761 }
762
763 public void Focus(Point pos)
764 {
765 position = pos.PositionCenter();
766 }
767
768 public void FocusPC()
769 {
770 focusPos = null;
772 instantFocus = true;
774 }
775
776 public void FocusImmediate(Point pos)
777 {
778 focusPos = null;
779 Focus(pos);
780 instantFocus = true;
783 }
784
785 public void SnapScreen(ref Vector3 v, float zoom)
786 {
787 float num = snapSize.x / zoom;
788 float num2 = snapSize.y / zoom;
789 switch (EMono.core.config.fix.snapType)
790 {
791 case CoreConfig.ScreenSnapType.Default:
792 v.x = num * (float)Mathf.RoundToInt(v.x / num);
793 v.y = num2 * (float)Mathf.RoundToInt(v.y / num2);
794 break;
795 case CoreConfig.ScreenSnapType.Floor:
796 v.x = num * (float)Mathf.FloorToInt(v.x / num);
797 v.y = num2 * (float)Mathf.FloorToInt(v.y / num2);
798 break;
799 case CoreConfig.ScreenSnapType.Ceil:
800 v.x = num * (float)Mathf.CeilToInt(v.x / num);
801 v.y = num2 * (float)Mathf.CeilToInt(v.y / num2);
802 break;
803 case CoreConfig.ScreenSnapType.Hack3:
804 num = snapSize.x;
805 num2 = snapSize.y;
806 v.x = num * (float)Mathf.RoundToInt(v.x / num);
807 v.y = num2 * (float)Mathf.RoundToInt(v.y / num2);
808 break;
809 case CoreConfig.ScreenSnapType.Hack4:
810 num = snapSize.x;
811 num2 = snapSize.y;
812 v.x = num * (float)Mathf.FloorToInt(v.x / num);
813 v.y = num2 * (float)Mathf.FloorToInt(v.y / num2);
814 break;
815 case CoreConfig.ScreenSnapType.Hack5:
816 num = snapSize.x;
817 num2 = snapSize.y;
818 v.x = num * (float)Mathf.CeilToInt(v.x / num);
819 v.y = num2 * (float)Mathf.CeilToInt(v.y / num2);
820 break;
821 case CoreConfig.ScreenSnapType.Hack6:
822 v.x = 0.01f * (float)Mathf.FloorToInt(v.x * 100f) + 0.001f;
823 v.y = 0.01f * (float)Mathf.FloorToInt(v.y * 100f) + 0.001f;
824 break;
825 case CoreConfig.ScreenSnapType.Hack7:
826 v.x = 0.01f * (float)Mathf.FloorToInt(v.x * 100f) - 0.001f;
827 v.y = 0.01f * (float)Mathf.FloorToInt(v.y * 100f) - 0.001f;
828 break;
829 case CoreConfig.ScreenSnapType.Hack8:
830 v.x = 0.01f * (float)Mathf.RoundToInt(v.x * 100f) + 0.005f;
831 v.y = 0.01f * (float)Mathf.RoundToInt(v.y * 100f) + 0.005f;
832 break;
833 case CoreConfig.ScreenSnapType.Hack9:
834 v.x = 0.01f * (float)Mathf.RoundToInt(v.x * 100f) + 0.025f;
835 v.y = 0.01f * (float)Mathf.RoundToInt(v.y * 100f) + 0.025f;
836 break;
837 }
838 }
839
840 public void SetZoom(float z)
841 {
842 targetZoom = (Zoom = z);
844 zoomTimer = 0f;
845 }
846
847 public void SetTargetZoomIndex(int index)
848 {
849 targetZoomIndex = index;
850 float num = targetZoom;
852 if (num != targetZoom)
853 {
854 zoomTimer = 0f;
855 }
856 }
857
858 public void ModTargetZoomIndex(int a)
859 {
861 {
862 int num = targetZoomIndex;
863 targetZoomIndex -= a;
864 int num2 = ((!EMono.core.config.camera.extendZoomMin) ? 1 : 0);
865 int num3 = (EMono.core.config.camera.extendZoomMax ? 4 : 3);
866 if (targetZoomIndex < num2)
867 {
868 targetZoomIndex = num2;
869 }
870 else if (targetZoomIndex >= num3)
871 {
872 targetZoomIndex = num3;
873 }
875 {
877 }
879 }
880 }
881}
FOWType
Definition: FOWType.cs:2
if(item3.idFile==idFirstFile &&item3.id==idFirstTopic)
Definition: UIBook.cs:627
override float TargetZoom
Definition: AM_Adv.cs:241
float rightMouseTimer
Definition: AM_Adv.cs:164
virtual float TargetZoom
Definition: ActionMode.cs:227
virtual bool FixFocus
Definition: ActionMode.cs:177
bool IsActive
Definition: ActionMode.cs:121
static AM_Cinema Cinema
Definition: ActionMode.cs:73
virtual float gameSpeed
Definition: ActionMode.cs:119
static AM_Bird Bird
Definition: ActionMode.cs:31
static AM_Adv Adv
Definition: ActionMode.cs:15
bool atrium
Definition: AreaData.cs:66
AreaData data
Definition: BaseArea.cs:29
ScreenGuide guide
void Focus(int x, int y)
virtual void OnActivate()
readonly int _ScreenFlash
Vector3 tileOffsetHeight
void ModTargetZoomIndex(int a)
readonly int _Snow
readonly int _Offset
void SetZoom(float z)
void FocusImmediate(Point pos)
void SetTargetZoomIndex(int index)
readonly int _BackDrawPower
Vector2 paddingOffset
void ScrollAxis(Vector3 axis, bool direct=false)
readonly int _ViewHeight
Vector3 planeSpeed
readonly int _LightPower
MeshRenderer overlayShadow
readonly int _SunColor
virtual void OnDeactivate()
Vector3 tileWeightHeight
readonly int _SkyBGColor
Transform transFocus
virtual float TargetZoom
void Focus(Point pos)
Vector2 tileWorldSize
virtual void OnChangeHour()
readonly int _FogStrength
Point GetRandomPoint()
virtual bool IsLocalMap
CameraSupport camSupport
void ScrollMouse(float x, float y)
readonly int _Zoom
readonly int _FowColor
readonly int _SeaColor
Vector3 tileWeight
virtual void OnEndPlayerTurn()
BaseTileSelector tileSelector
void SnapScreen(ref Vector3 v, float zoom)
Vector3 planeAngle
readonly int _FogColor
Vector2 tileViewSize
readonly int _SkyColor
readonly int _SkyLevel
readonly int _NightRate
void UpdateShaders(float time=0f)
virtual void RefreshWeather()
void RefreshScreenSize()
virtual float SkyRate
void Focus(Card c)
BaseTileMap tileMap
virtual bool IsGameScreen
void Focus(Int3 ints)
virtual void RefreshPosition()
FocusOption focusOption
virtual void SetUnitSize()
virtual float ViewHeight
readonly int _AnimeSpeedGlobal
virtual void Draw()
Definition: BaseTileMap.cs:533
void OnActivate(BaseGameScreen _screen)
Definition: BaseTileMap.cs:510
FowProfile fowProfile
static BuildMenu Instance
Definition: BuildMenu.cs:77
bool pressing
Definition: ButtonState.cs:35
ScreenGrading grading
Divider divier
void ResizeCameraToPixelPerfect()
Vector3 position
Definition: CardRenderer.cs:21
TCOrbit orbit
Definition: CardRenderer.cs:7
Definition: Card.cs:11
Point pos
Definition: Card.cs:55
Card GetRootCard()
Definition: Card.cs:3173
CardRenderer renderer
Definition: Card.cs:57
Room room
Definition: Cell.cs:102
override bool isSynced
Definition: Chara.cs:676
Zone currentZone
Definition: Chara.cs:240
bool isBlind
Definition: Chara.cs:125
CameraSupport.Divider divider
Definition: CoreConfig.cs:563
ScreenSnapType snapType
Definition: CoreConfig.cs:565
void RefreshUIBrightness()
Definition: CoreConfig.cs:959
GraphicSetting graphic
Definition: CoreConfig.cs:594
CameraConfig camera
Definition: CoreConfig.cs:604
void ApplyZoom(float a)
Definition: CoreConfig.cs:922
Definition: Core.cs:14
static float gameDeltaNoPause
Definition: Core.cs:23
BaseGameScreen screen
Definition: Core.cs:67
bool IsGameStarted
Definition: Core.cs:84
static float delta
Definition: Core.cs:17
CoreConfig config
Definition: Core.cs:70
bool IsNight
Definition: Date.cs:112
Definition: EInput.cs:8
static ButtonState buttonScroll
Definition: EInput.cs:359
static Vector3 mposWorld
Definition: EInput.cs:339
Definition: EMono.cs:4
static GameSetting setting
Definition: EMono.cs:31
static Core core
Definition: EMono.cs:5
static Chara pc
Definition: EMono.cs:13
static World world
Definition: EMono.cs:37
static Player player
Definition: EMono.cs:11
static Zone _zone
Definition: EMono.cs:19
static BaseGameScreen screen
Definition: EMono.cs:29
static Game game
Definition: EMono.cs:7
static int rnd(int a)
Definition: EMono.cs:47
static Scene scene
Definition: EMono.cs:27
static bool AdvMode
Definition: EMono.cs:9
static Map _map
Definition: EMono.cs:17
void UpdateEffects()
static EffectManager Instance
bool IsActive
Definition: EloMapActor.cs:21
FOWType type
Definition: FowProfile.cs:5
Color color
Definition: FowProfile.cs:7
RenderSetting render
Definition: GameSetting.cs:301
bool tilt
Definition: Game.cs:18
int animeSpeed
Definition: Game.cs:84
int tiltPower
Definition: Game.cs:72
int backDrawAlpha
Definition: Game.cs:81
int tiltPowerRegion
Definition: Game.cs:75
bool tiltRegion
Definition: Game.cs:21
Zone activeZone
Definition: Game.cs:245
Config config
Definition: Game.cs:215
Definition: Int3.cs:2
int x
Definition: Int3.cs:6
int y
Definition: Int3.cs:18
int z
Definition: Int3.cs:30
static SourceMaterial.Row sourceWaterSea
Definition: MATERIAL.cs:41
int Size
Definition: MapBounds.cs:20
Point GetCenterPos()
Definition: MapBounds.cs:52
SerializableColor colorSea
Definition: MapConfig.cs:98
bool indoor
Definition: MapConfig.cs:29
SerializableColor colorScreen
Definition: MapConfig.cs:95
string idSceneTemplate
Definition: MapConfig.cs:23
float shadowStrength
Definition: MapConfig.cs:71
FogType fog
Definition: MapConfig.cs:77
bool IsIndoor
Definition: Map.cs:131
FowProfile fowProfile
Definition: Map.cs:101
MapConfig config
Definition: Map.cs:37
List< TransAnime > pointAnimes
Definition: Map.cs:83
MapBounds bounds
Definition: Map.cs:52
bool simulatingZone
Definition: Player.cs:980
Definition: Point.cs:9
ref Vector3 Position(int height)
Definition: Point.cs:524
Point Set(int _x, int _z)
Definition: Point.cs:479
ref Vector3 PositionCenter()
Definition: Point.cs:563
Cell cell
Definition: Point.cs:51
Definition: Room.cs:4
bool HasRoof
Definition: Room.cs:29
AnimationCurve lightPower
AnimationCurve bloomCurve
AnimationCurve bloomCurve2
AnimationCurve nightRatioCurve
AnimationCurve vignetteCurve
Material matOverlay
Definition: SceneProfile.cs:14
SceneGlobalProfile global
Definition: SceneProfile.cs:6
SceneColorProfile color
Definition: SceneProfile.cs:12
Material matGrading
Definition: SceneProfile.cs:16
SceneLightProfile light
Definition: SceneProfile.cs:10
Color colorScreen
Definition: SceneTemplate.cs:7
static SceneTemplate Load(string id)
Definition: SceneTemplate.cs:9
Definition: Scene.cs:8
ParticleSystem ether
Definition: Scene.cs:53
Material matFloorEx
Definition: Scene.cs:103
static bool skipAnime
Definition: Scene.cs:25
SoundSource sfxWind
Definition: Scene.cs:81
Transform transFocus
Definition: Scene.cs:27
ParticleSystem snow
Definition: Scene.cs:51
VFX fireflyNight
Definition: Scene.cs:45
VFX firefly
Definition: Scene.cs:43
float timeRatio
Definition: Scene.cs:124
ParticleSystem godrayDust
Definition: Scene.cs:57
CameraSupport camSupport
Definition: Scene.cs:41
SoundSource sfxFire
Definition: Scene.cs:85
EloMapActor elomapActor
Definition: Scene.cs:97
ParticleSystem blossom
Definition: Scene.cs:59
VFX star
Definition: Scene.cs:47
void ApplyZoneConfig()
Definition: Scene.cs:811
Vector3 posAudioListener
Definition: Scene.cs:33
ParticleSystem godray
Definition: Scene.cs:55
ActionMode actionMode
Definition: Scene.cs:77
Camera cam
Definition: Scene.cs:37
SceneProfile profile
Definition: Scene.cs:73
SoundSource sfxSea
Definition: Scene.cs:83
void OnChangeHour()
Definition: Scene.cs:764
ParticleSystem[] blizzards
Definition: Scene.cs:65
FlockController flock
Definition: Scene.cs:67
ParticleSystem rain
Definition: Scene.cs:49
SoundSource sfxRain
Definition: Scene.cs:79
ParticleSystem[] blossoms
Definition: Scene.cs:63
static Color currentColor
Definition: ScreenFlash.cs:8
int lv
Definition: Spatial.cs:142
virtual bool IsRegion
Definition: Spatial.cs:501
virtual bool IsSnowCovered
Definition: Spatial.cs:531
virtual float VolumeSea
Definition: Spatial.cs:478
virtual void Refresh()
Definition: TCOrbit.cs:3
bool IsEther
Definition: Weather.cs:156
bool IsBlossom
Definition: Weather.cs:141
Condition
Definition: Weather.cs:16
Condition CurrentCondition
Definition: Weather.cs:79
bool IsRaining
Definition: Weather.cs:117
static void RefreshHighlights()
static WidgetMinimap Instance
GameDate date
Definition: World.cs:6
Weather weather
Definition: World.cs:12
Definition: Zone.cs:12
BiomeProfile biome
Definition: Zone.cs:126
virtual string IDSceneTemplate
Definition: Zone.cs:191