Elin Decompiled Documentation EA 23.102 Nightly
Loading...
Searching...
No Matches
BaseTileMap.cs
Go to the documentation of this file.
1using System;
2using NoiseSystem;
3using UnityEngine;
4
5public class BaseTileMap : EMono
6{
7 public enum WallClipMode
8 {
9 ByRoom,
10 ByLot
11 }
12
13 public enum InnerMode
14 {
15 None,
17 Height,
19 }
20
21 public enum CardIconMode
22 {
23 None,
24 Inspect,
26 State,
28 }
29
30 public enum ScreenHighlight
31 {
32 None,
33 SunMap
34 }
35
36 public static bool forceShowHang;
37
38 public int count;
39
40 [Header("Mouse Hit")]
41 public Collider2D mouseCollider;
42
43 public Vector3 colliderFix;
44
45 public int maxColliderCheck;
46
47 [Header("Height")]
48 public float heightBlockSize;
49
50 public float slopeFixZ;
51
52 public float heightModDeco;
53
54 public float heightLimitDeco;
55
56 public Vector3 heightMod;
57
58 public Vector3 ugFix;
59
60 public Vector3 ugFixBridge;
61
62 public Vector3 ugFixBridgeBottom;
63
64 public Vector3 ugFixBridgeTop;
65
66 public Vector3 heightModRoofBlock;
67
68 [Header("Room")]
69 public float rightWallShade;
70
71 public Vector3 roofRampFix;
72
73 public Vector3 roofFix;
74
75 public Vector3 roofFix2;
76
77 public Vector3 roofFix3;
78
79 public float roofLightMod;
80
81 public float lotLight;
82
83 public float lotLight2;
84
85 public float roofLightSnow;
86
87 [Header("Other")]
89
91
92 public Vector3 edgeBlockFix;
93
94 public Vector3 bridgeFix;
95
96 public Vector3 cornerWallFix;
97
98 public Vector3 cornerWallFix2;
99
100 public Vector3 cornerWallFix3;
101
102 public Vector3 altitudeFix;
103
104 public Vector3 waterEdgeFix;
105
106 public Vector3 waterEdgeBridgeFix;
107
108 public Vector3 waterEdgeFixShore;
109
110 public Vector3 waterEdgeFixShoreSand;
111
112 public Vector3[] ambientShadowFix;
113
114 public Vector3[] transitionFix;
115
116 public Vector3[] wallHangFix;
117
118 public Vector3[] waterEdgeBlockFix;
119
120 public int fogTile;
121
122 public float floatSpeed;
123
124 public float shadowModStrength;
125
126 public int maxFloat;
127
128 public int[] seaAnimeIndexes;
129
130 [Header("References")]
131 public NoiseLayer layerGroundLights;
132
134
136
138
140
142
144
146
148
150
152
154
156
158
160
162
164
166
168
170
172
174
176
178
180
182
184
186
188
190
192
194
196
198
200
202
204
206
208
210
212
214
216
218
220
222
224
226
228
230
231 public Point TestPoint = new Point();
232
234
235 [NonSerialized]
236 public int Size;
237
238 [NonSerialized]
239 public int SizeXZ;
240
241 [NonSerialized]
242 public int mx;
243
244 [NonSerialized]
245 public int mz;
246
247 [NonSerialized]
248 public int x;
249
250 [NonSerialized]
251 public int z;
252
253 [NonSerialized]
254 public int cx;
255
256 [NonSerialized]
257 public int cz;
258
259 [NonSerialized]
260 public int activeCount;
261
262 [NonSerialized]
263 public int floatV = 1;
264
265 [NonSerialized]
266 public byte[] groundLights;
267
268 [NonSerialized]
269 public bool lowBlock;
270
271 [NonSerialized]
272 public bool lowObj;
273
274 [NonSerialized]
275 public bool highlightArea;
276
277 [NonSerialized]
279
280 [NonSerialized]
281 public bool hideRoomFog;
282
283 [NonSerialized]
284 public bool showRoof;
285
286 [NonSerialized]
287 public bool showFullWall;
288
289 [NonSerialized]
290 public bool hideHang;
291
292 [NonSerialized]
293 public bool usingHouseBoard;
294
295 [NonSerialized]
296 public bool noRoofMode;
297
298 [NonSerialized]
299 public bool fogged;
300
301 [NonSerialized]
302 public float[] lightLookUp;
303
304 [NonSerialized]
305 public float _lightMod;
306
307 [NonSerialized]
308 public float _baseBrightness;
309
310 [NonSerialized]
311 public float lowblockTimer;
312
313 [NonSerialized]
314 public float heightLightMod;
315
316 [NonSerialized]
317 public float _rightWallShade;
318
319 [NonSerialized]
320 public float roofLightLimitMod;
321
322 [NonSerialized]
323 public float floatY;
324
325 [NonSerialized]
327
328 [NonSerialized]
329 public Vector3 _heightMod;
330
331 [NonSerialized]
333
334 protected RaycastHit2D[] rays = new RaycastHit2D[1];
335
337
338 protected bool isMining;
339
340 protected bool buildMode;
341
342 protected bool hasBridge;
343
344 protected bool _lowblock;
345
346 protected bool isIndoor;
347
349
350 protected Map map;
351
352 protected MeshPass pass;
353
355
357
359
360 protected int liquidLv;
361
362 protected int index;
363
364 protected int totalFire;
365
366 protected int snowColorToken;
367
368 protected int waterAnimeIndex;
369
370 protected int lowWallObjAltitude;
371
373
375
377
378 protected float blockLight;
379
380 protected float floorLight;
381
382 protected float floorLight2;
383
384 protected float light;
385
386 protected float pcMaxLight;
387
388 protected float orgX;
389
390 protected float orgY;
391
392 protected float orgZ;
393
394 protected float roomHeight;
395
396 protected float maxHeight;
397
398 protected float snowLight;
399
400 protected float waterAnimeTimer;
401
402 protected float floatTimer;
403
404 protected float destBrightness;
405
406 protected float lightLimit;
407
408 protected float modSublight1;
409
410 protected float modSublight2;
411
412 protected float shadowStrength;
413
414 protected float _shadowStrength;
415
416 protected float fogBrightness;
417
418 protected float defaultBlockHeight;
419
420 protected float snowLimit;
421
422 protected float snowColor;
423
424 protected float snowColor2;
425
426 protected float nightRatio;
427
428 protected RenderParam param = new RenderParam();
429
430 protected MeshBatch batch;
431
432 protected Vector3 _actorPos;
433
434 protected Vector3 freePos;
435
436 protected int tile;
437
438 protected int floorMatColor;
439
440 protected int height;
441
442 protected int currentHeight;
443
444 protected int pcX;
445
446 protected int pcZ;
447
448 protected int floorDir;
449
450 protected bool roof;
451
452 protected bool isSeen;
453
454 protected bool showAllCards;
455
456 protected bool fogBounds;
457
458 protected bool snowed;
459
460 protected bool isSnowCovered;
461
462 protected bool highlightCells;
463
464 protected bool cinemaMode;
465
466 protected bool alwaysLowblock;
467
468 protected bool showBorder;
469
470 protected Vector3 thingPos;
471
472 protected Vector3 orgPos;
473
474 protected Cell cell;
475
477
479
481
483
484 protected Room currentRoom;
485
486 protected Room lastRoom;
487
488 protected Room room;
489
490 protected Lot currentLot;
491
493
495
497
498 private bool noSlopMode;
499
501
502 public const int DefColor = 104025;
503
504 public const int BlocklightToken = 262144;
505
506 public const int BlocklightMTP = 50;
507
509
510 public void OnActivate(BaseGameScreen _screen)
511 {
512 screen = _screen;
513 if (lightLookUp == null)
514 {
515 lightLookUp = new float[256];
516 for (int i = 0; i < 256; i++)
517 {
518 lightLookUp[i] = EMono.scene.profile.global.lightLookupCurve.Evaluate((float)i / 255f);
519 }
520 }
523 zSetting = renderSetting.zSetting;
524 RenderObject.syncList = EMono.scene.syncList;
525 RenderObject.altitudeFix = altitudeFix.y;
526 if (Rand.bytes == null)
527 {
528 Rand.InitBytes(1);
529 }
531 }
532
533 public virtual void Draw()
534 {
535 Zone zone = EMono._zone;
536 map = zone.map;
537 Size = map.Size;
538 SizeXZ = map.SizeXZ;
540 count = 0;
541 totalFire = 0;
542 pcX = EMono.pc.pos.x;
543 pcZ = EMono.pc.pos.z;
546 lightSetting = profile.light;
549 {
550 buildMode = false;
551 }
553 isMining = EMono.scene.actionMode == ActionMode.Mine;
557 subtleHighlightArea = EMono.scene.actionMode.AreaHihlight != 0 && (EMono.scene.actionMode.AreaHihlight == AreaHighlightMode.Build || EMono.scene.actionMode.AreaHihlight != AreaHighlightMode.Edit);
558 highlightArea = EMono.scene.actionMode.AreaHihlight == AreaHighlightMode.Edit || subtleHighlightArea;
560 _rightWallShade = (int)(50f * rightWallShade) * 262144;
563 showBorder = (EMono.core.config.game.showBorder == 1 && EMono._zone is Zone_Field && !EMono._zone.IsPlayerFaction) || (EMono.core.config.game.showBorder == 2 && !EMono._zone.map.IsIndoor && !EMono._zone.IsSkyLevel && !EMono._zone.IsRegion);
564 snowLimit = profile.global.snowLimit.Evaluate(EMono.scene.timeRatio);
565 snowLight = profile.global.snowLight;
566 snowColor = profile.global.snowColor;
567 snowColor2 = profile.global.snowColor2;
568 snowColorToken = (int)((float)profile.global.snowRGB.x * nightRatio) * 4096 + (int)((float)profile.global.snowRGB.y * nightRatio) * 64 + (int)((float)profile.global.snowRGB.z * nightRatio);
571 {
573 }
574 roofLightLimitMod = profile.global.roofLightLimitMod.Evaluate(EMono.scene.timeRatio);
575 fogBounds = (EMono._map.config.forceHideOutbounds && (!EMono.debug.godBuild || !buildMode)) || (EMono.core.config.game.dontRenderOutsideMap && !buildMode);
576 heightLightMod = ((EMono._map.config.heightLightMod == 0f) ? 0.005f : EMono._map.config.heightLightMod);
577 modSublight1 = profile.global.modSublight1;
578 modSublight2 = profile.global.modSublight2 * nightRatio;
579 pcMaxLight = EMono.player.lightPower * 2f * (float)(EMono.player.lightRadius - 2);
582 _lightMod = lightSetting.lightMod * lightSetting.lightModCurve.Evaluate(EMono.scene.timeRatio);
583 destBrightness = lightSetting.baseBrightness * lightSetting.baseBrightnessCurve.Evaluate(EMono.scene.timeRatio);
584 float num = destBrightness;
585 destBrightness = destBrightness * lightSetting.dynamicBrightnessCurve2.Evaluate(EMono.scene.timeRatio) + lightSetting.dynamicBrightnessCurve.Evaluate(EMono.scene.timeRatio) * (float)(int)EMono.pc.pos.cell.light + ((EMono.pc.pos.cell.light == 0) ? 0f : lightSetting.dynamicBrightnessLightBonus);
586 if (destBrightness > num)
587 {
588 destBrightness = num;
589 }
590 if (!Mathf.Approximately(_baseBrightness, destBrightness))
591 {
593 }
594 if (activeCount == 0)
595 {
597 }
598 activeCount++;
600 {
601 _baseBrightness = 0.7f;
602 }
603 Fov.nonGradientMod = profile.global.fovModNonGradient;
606 float num2 = Core.delta * (float)EMono.game.config.animeSpeed * 0.01f;
607 floatTimer += num2;
609 {
611 floatY += floatV;
612 if (floatY >= (float)maxFloat)
613 {
614 floatV *= -1;
615 }
616 if (floatY < 0f)
617 {
618 floatV *= -1;
619 }
620 }
621 waterAnimeTimer += num2;
622 if (waterAnimeTimer > 0.5f)
623 {
624 waterAnimeTimer = 0f;
626 }
627 if (cinemaMode)
628 {
629 CinemaConfig cinemaConfig = EMono.player.cinemaConfig;
630 profile = ActionMode.Cinema.profile;
631 lightSetting = profile.light;
633 _lightMod += lightSetting.lightMod * lightSetting.lightModCurve.Evaluate(EMono.scene.timeRatio) * (0.01f * (float)cinemaConfig.light);
634 destBrightness += 0.01f * (float)cinemaConfig.brightness;
635 EMono.scene.camSupport.grading.cinemaBrightness = 0.01f * (float)cinemaConfig.brightness;
636 EMono.scene.camSupport.grading.SetGrading();
637 heightLightMod = 0f;
638 }
639 map.rooms.Refresh();
640 noSlopMode = EInput.isAltDown && EInput.isShiftDown;
644 {
647 }
648 else
649 {
650 currentHeight = 0;
651 currentRoom = null;
652 }
653 lowObj = false;
655 noRoofMode = false;
656 bool flag = !isIndoor || EMono._zone is Zone_Tent;
658 {
659 lowBlock = (hideRoomFog = (hideHang = false));
660 showRoof = (showFullWall = flag);
662 {
663 fogBounds = false;
664 }
665 }
666 else if (buildMode)
667 {
669 if (HitPoint.IsValid)
670 {
672 }
673 hideRoomFog = true;
678 if (cinemaMode)
679 {
681 }
682 }
683 else if (ActionMode.IsAdv)
684 {
685 noRoofMode = EMono.game.config.noRoof || screen.focusOption != null;
687 {
688 if (!EMono.pc.IsMoving)
689 {
690 lowblockTimer = 0.1f;
691 }
692 }
693 else if (!EInput.rightMouse.pressing)
694 {
695 lowblockTimer = 0f;
696 }
697 x = EMono.pc.pos.x;
698 z = EMono.pc.pos.z;
699 Room room = null;
700 if (room != null)
701 {
703 }
704 if (currentRoom != null)
705 {
706 currentRoom.data.visited = true;
707 }
708 if (room != null)
709 {
710 room.data.visited = true;
711 }
712 lowBlock = lowblockTimer > 0f;
713 hideRoomFog = currentRoom != null && (currentRoom.HasRoof || isIndoor);
714 if (hideRoomFog)
715 {
716 lowBlock = true;
717 }
718 if (noRoofMode && (currentRoom == null || currentRoom.lot.idRoofStyle == 0))
719 {
720 hideRoomFog = true;
721 showRoof = (showFullWall = false);
722 }
723 else
724 {
725 showRoof = (showFullWall = flag && !lowBlock && !hideRoomFog);
726 }
728 EMono.game.config.showRoof = !hideRoomFog;
729 if (forceShowHang)
730 {
731 hideHang = false;
732 forceShowHang = false;
733 }
734 }
735 else
736 {
737 lowBlock = (hideRoomFog = (hideHang = false));
738 showRoof = (showFullWall = true);
739 }
740 currentLot = currentRoom?.lot ?? null;
741 Vector3 mposWorld = EInput.mposWorld;
742 mposWorld.z = 0f;
743 Vector3Int vector3Int = screen.grid.WorldToCell(mposWorld);
744 mx = -vector3Int.y;
745 mz = vector3Int.x - 1;
746 HitPoint.Set(mx, mz);
747 bool isAltDown = EInput.isAltDown;
748 for (int num3 = maxColliderCheck; num3 >= 0; num3--)
749 {
750 TestPoint.x = mx + num3;
751 TestPoint.z = mz - num3;
752 if (TestPoint.x >= 0 && TestPoint.x < Size && TestPoint.z >= 0 && TestPoint.z < Size)
753 {
754 mouseCollider.transform.position = (isAltDown ? TestPoint.Position(TestPoint.cell.height) : TestPoint.Position()) + colliderFix;
755 Physics2D.SyncTransforms();
756 if (Physics2D.RaycastNonAlloc(mposWorld, Vector2.zero, rays) > 0)
757 {
759 break;
760 }
761 }
762 TestPoint.x = mx + num3 - 1;
763 TestPoint.z = mz - num3;
764 if (TestPoint.x >= 0 && TestPoint.x < Size && TestPoint.z >= 0 && TestPoint.z < Size)
765 {
766 mouseCollider.transform.position = (isAltDown ? TestPoint.Position(TestPoint.cell.height) : TestPoint.Position()) + colliderFix;
767 Physics2D.SyncTransforms();
768 if (Physics2D.RaycastNonAlloc(mposWorld, Vector2.zero, rays) > 0)
769 {
771 break;
772 }
773 }
774 TestPoint.x = mx + num3;
775 TestPoint.z = mz - num3 + 1;
776 if (TestPoint.x >= 0 && TestPoint.x < Size && TestPoint.z >= 0 && TestPoint.z < Size)
777 {
778 mouseCollider.transform.position = (isAltDown ? TestPoint.Position(TestPoint.cell.height) : TestPoint.Position()) + colliderFix;
779 Physics2D.SyncTransforms();
780 if (Physics2D.RaycastNonAlloc(mposWorld, Vector2.zero, rays) > 0)
781 {
783 break;
784 }
785 }
786 }
787 HitPoint.Clamp();
788 bool flag2 = EMono._zone.UseFog && !EMono.scene.bg.wall;
789 for (z = 0; z < screen.height; z++)
790 {
791 for (x = 0; x < screen.width; x++)
792 {
793 cx = screen.scrollX - screen.scrollY + x - (z + 1) / 2;
794 cz = screen.scrollY + screen.scrollX + x + z / 2;
795 if (((cz < 0 && cx >= -cz && cx > 0 && cx < Size - cz) || (cx >= Size && cx < Size * 2 - cz - 1 && cz >= -cx && cz < Size - 1)) && EMono.scene.bg.wall)
796 {
797 param.x = (float)(cx + cz) * screen.tileAlign.x + edgeBlockFix.x;
798 param.y = (float)(cz - cx) * screen.tileAlign.y + edgeBlockFix.y;
799 param.z = 1000f + param.x * screen.tileWeight.x + param.y * screen.tileWeight.z + (float)z * edgeBlockFix.z;
800 blockLight = 10485760f;
801 pass = passInner;
803 batch.matrices[pass.idx].m03 = param.x;
804 batch.matrices[pass.idx].m13 = param.y;
805 batch.matrices[pass.idx].m23 = param.z;
806 batch.tiles[pass.idx] = 4 + ((cx >= Size) ? 1 : 0);
808 batch.matColors[pass.idx] = 104025f;
809 pass.idx++;
810 if (pass.idx == pass.batchSize)
811 {
812 pass.NextBatch();
813 }
814 }
815 else if (cx < 0 || cz < 0 || cx >= Size || cz >= Size)
816 {
817 if (flag2)
818 {
819 param.x = (float)(cx + cz) * screen.tileAlign.x;
820 param.y = (float)(cz - cx) * screen.tileAlign.y + (float)height * _heightMod.y;
821 param.z = 1000f + param.x * screen.tileWeight.x + param.y * screen.tileWeight.z + (float)height * _heightMod.z;
822 param.tile = 0f;
824 }
825 }
826 else
827 {
828 DrawTile();
829 }
830 }
831 }
832 if (showRoof)
833 {
834 foreach (Lot item in map.rooms.listLot)
835 {
836 if (item.sync)
837 {
838 DrawRoof(item);
839 item.sync = false;
840 item.light = 0f;
841 }
842 }
843 }
844 else
845 {
846 foreach (Lot item2 in map.rooms.listLot)
847 {
848 item2.sync = false;
849 item2.light = 0f;
850 }
851 }
852 EMono.scene.sfxFire.SetVolume(Mathf.Clamp(0.1f * (float)totalFire + ((totalFire != 0) ? 0.2f : 0f), 0f, 1f));
853 this.room = EMono.pc.pos.cell.room;
854 int valueOrDefault = (this.room?.lot?.idBGM).GetValueOrDefault();
855 if (valueOrDefault == 0)
856 {
857 goto IL_1671;
858 }
859 if (!(EMono.Sound.currentPlaylist != EMono.Sound.plLot))
860 {
861 BGMData data = EMono.Sound.plLot.list[0].data;
862 if ((object)data != null && data.id == valueOrDefault)
863 {
864 goto IL_1671;
865 }
866 }
867 goto IL_1690;
868 IL_169a:
869 if (this.room != lastRoom)
870 {
872 lastRoom = this.room;
873 }
874 SoundManager.bgmVolumeMod = ((!LayerDrama.maxBGMVolume && !EMono._map.IsIndoor && this.room != null && !this.room.data.atrium && this.room.HasRoof) ? (-0.6f) : 0f);
876 return;
877 IL_1690:
879 goto IL_169a;
880 IL_1671:
881 if (valueOrDefault == 0 && EMono.Sound.currentPlaylist == EMono.Sound.plLot)
882 {
883 goto IL_1690;
884 }
885 goto IL_169a;
886 }
887
888 public void RefreshHeight()
889 {
890 if (EMono.game != null)
891 {
892 float num = (((buildMode && !EMono.game.config.slope) || noSlopMode) ? 0f : ((float)EMono.game.config.slopeMod * 0.01f));
894 _heightMod.x = num;
895 _heightMod.y *= num;
896 _heightMod.z *= num;
897 }
898 }
899
900 public virtual void DrawTile()
901 {
902 count++;
903 index = cx + cz * Size;
904 this.cell = (param.cell = map.cells[cx, cz]);
905 detail = this.cell.detail;
906 isSeen = this.cell.isSeen;
907 this.room = this.cell.room;
908 roof = this.cell.HasRoof;
909 matBlock = this.cell.matBlock;
910 sourceBlock = this.cell.sourceBlock;
911 bool flag = this.cell.isFloating;
912 snowed = isSnowCovered && !roof && !this.cell.isClearSnow && !this.cell.isDeck && !flag;
914 floorDir = this.cell.floorDir;
915 if (snowed && !this.cell.sourceFloor.ignoreSnow)
916 {
917 if (this.cell.IsFloorWater)
918 {
920 matFloor = this.cell.matFloor;
921 }
922 else
923 {
924 if (this.cell.sourceObj.snowTile > 0)
925 {
927 floorDir = this.cell.sourceObj.snowTile - 1;
928 }
929 else if (index % 3 == 0 && Rand.bytes[index % Rand.MaxBytes] < 8 && !this.cell.HasObj && this.cell.FirstThing == null)
930 {
933 }
934 else
935 {
937 }
939 }
940 }
941 else
942 {
943 sourceFloor = this.cell.sourceFloor;
944 matFloor = this.cell.matFloor;
945 }
946 bool isWater = sourceFloor.tileType.IsWater;
947 light = (this.cell.pcSync ? this.cell.light : (this.cell.light / 3 * 2));
949 height = this.cell.height;
950 hasBridge = this.cell._bridge != 0;
952 if (hasBridge)
953 {
954 if (this.cell.bridgeHeight < currentHeight)
955 {
956 blockLight -= heightLightMod * (float)(currentHeight - this.cell.bridgeHeight);
957 }
958 if (snowed && !this.cell.sourceBridge.ignoreSnow)
959 {
960 if (this.cell.IsBridgeWater)
961 {
963 matBridge = this.cell.matBridge;
964 }
965 else
966 {
969 }
970 }
971 else
972 {
973 sourceBridge = this.cell.sourceBridge;
974 matBridge = this.cell.matBridge;
975 }
976 }
977 else if (height < currentHeight)
978 {
980 }
981 liquidLv = (param.liquidLv = ((!flag) ? (((this.cell.liquidLv + this.cell._bridge != 0) ? this.cell.sourceBridge.tileType.LiquidLV : sourceFloor.tileType.LiquidLV) * 10) : 0));
982 if (this.cell.shore != 0 && liquidLv > 20)
983 {
984 liquidLv = (param.liquidLv = 20);
985 }
986 if (liquidLv > 99)
987 {
988 liquidLv = (param.liquidLv = 99);
989 }
990 CellEffect effect = this.cell.effect;
991 if (effect != null && effect.IsFire)
992 {
993 blockLight += 0.2f;
994 totalFire++;
995 }
997 {
999 }
1000 blockLight += shadowModStrength * (float)(int)this.cell.shadowMod * _heightMod.x * _shadowStrength;
1001 if (this.room != null)
1002 {
1003 this.room.lot.sync = true;
1004 if (this.room.lot.light < blockLight)
1005 {
1006 this.room.lot.light = blockLight;
1007 }
1008 }
1009 if (currentLot != null && currentLot.idRoofStyle != 0)
1010 {
1011 bool flag2 = this.cell.IsRoomEdge && (this.cell.Front.room?.lot == currentLot || this.cell.Right.room?.lot == currentLot || this.cell.FrontRight.room?.lot == currentLot);
1012 if (!buildMode)
1013 {
1014 if ((this.room != null && this.room.lot == currentLot) || flag2)
1015 {
1017 }
1018 else
1019 {
1020 blockLight += (isSnowCovered ? (-0.02f) : lotLight2);
1021 }
1022 }
1023 }
1024 if (this.cell.outOfBounds && !cinemaMode)
1025 {
1026 blockLight -= 0.1f;
1027 if (fogBounds)
1028 {
1029 isSeen = false;
1030 }
1031 }
1033 param.color = (blockLight = (int)(blockLight * 50f) * 262144 + ((this.cell.lightR >= 64) ? 63 : this.cell.lightR) * 4096 + ((this.cell.lightG >= 64) ? 63 : this.cell.lightG) * 64 + ((this.cell.lightB >= 64) ? 63 : this.cell.lightB));
1034 if (snowed)
1035 {
1038 {
1040 }
1041 floorLight = (int)(floorLight * 50f) * 262144 + (int)((float)((this.cell.lightR >= 50) ? 50 : this.cell.lightR) * snowColor) * 4096 + (int)((float)((this.cell.lightG >= 50) ? 50 : this.cell.lightG) * snowColor) * 64 + (int)((float)((this.cell.lightB >= 50) ? 50 : this.cell.lightB) * snowColor) + snowColorToken;
1042 }
1043 else if (isSnowCovered && !roof)
1044 {
1045 floorLight = (int)(floorLight * 50f) * 262144 + (int)((float)((this.cell.lightR >= 50) ? 50 : this.cell.lightR) * snowColor2) * 4096 + (int)((float)((this.cell.lightG >= 50) ? 50 : this.cell.lightG) * snowColor2) * 64 + (int)((float)((this.cell.lightB >= 50) ? 50 : this.cell.lightB) * snowColor2) + snowColorToken;
1046 }
1047 else
1048 {
1050 }
1051 bool num = this.room != null && sourceBlock.tileType.CastShadowSelf && !this.cell.hasDoor;
1052 bool flag3 = this.room != null && showRoof && this.room.lot.idRoofStyle != 0 && !this.room.data.atrium && !sourceBlock.tileType.Invisible;
1053 if (flag3 && this.cell.hasDoor && this.cell.IsLotEdge)
1054 {
1055 flag3 = false;
1056 }
1057 if (num || !isSeen || flag3)
1058 {
1059 floorLight += -3145728f;
1060 }
1061 if (this.cell.isWatered && !snowed)
1062 {
1063 floorLight += -2359296f;
1064 }
1065 param.snow = false;
1066 param.x = (float)(cx + cz) * screen.tileAlign.x;
1067 param.y = (float)(cz - cx) * screen.tileAlign.y + (float)height * _heightMod.y;
1068 param.z = 1000f + param.x * screen.tileWeight.x + param.y * screen.tileWeight.z + (float)height * _heightMod.z;
1069 if (flag)
1070 {
1071 param.y += 0.01f * floatY;
1072 }
1073 if (detail != null)
1074 {
1075 TransAnime anime = detail.anime;
1076 if (anime != null && anime.animeBlock)
1077 {
1078 TransAnime anime2 = detail.anime;
1079 param.x += anime2.v.x;
1080 param.y += anime2.v.y;
1081 param.z += anime2.v.z;
1082 }
1083 if (detail.designation != null)
1084 {
1086 }
1087 }
1088 if (screenHighlight != 0 && screenHighlight == ScreenHighlight.SunMap && Map.sunMap.Contains(index))
1089 {
1091 }
1092 if (this.cell._roofBlock != 0 && (isSeen || !EMono._zone.UseFog) && showRoof && !lowBlock)
1093 {
1094 SourceBlock.Row row = Cell.blockList[this.cell._roofBlock];
1095 SourceMaterial.Row row2 = Cell.matList[this.cell._roofBlockMat];
1096 this.tileType = row.tileType;
1097 param.mat = row2;
1098 param.dir = this.cell._roofBlockDir % 4;
1099 param.snow = isSnowCovered;
1100 orgX = param.x;
1101 orgY = param.y;
1102 orgZ = param.z;
1103 SetRoofHeight(param, this.cell, cx, cz, 0, this.cell._roofBlockDir / 4, this.tileType.IsWallOrFence ? param.dir : (-1));
1104 switch (this.tileType.blockRenderMode)
1105 {
1106 case BlockRenderMode.FullBlock:
1107 param.color -= (int)(_shadowStrength * 50f) * 262144;
1108 param.tile = row._tiles[param.dir % row._tiles.Length];
1109 param.matColor = ((row.colorMod == 0) ? 104025 : GetColorInt(ref row2.matColor, row.colorMod));
1110 row.renderData.Draw(param);
1111 break;
1112 case BlockRenderMode.WallOrFence:
1113 {
1114 _lowblock = true;
1115 int dir = param.dir;
1116 if (dir == 0 || dir == 2)
1117 {
1118 param.dir = 0;
1119 _sourceBlock = row;
1120 this.tileType = _sourceBlock.tileType;
1121 if (_sourceBlock.useAltColor)
1122 {
1123 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.altColor, _sourceBlock.colorMod));
1124 }
1125 else
1126 {
1127 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.matColor, _sourceBlock.colorMod));
1128 }
1129 param.tile = (tile = _sourceBlock._tiles[0] + ((_lowblock && !this.tileType.IsFence) ? 32 : 0));
1130 _sourceBlock.renderData.Draw(param);
1131 param.z -= 0.01f;
1132 }
1133 if (dir == 1 || dir == 2)
1134 {
1135 param.dir = 1;
1136 _sourceBlock = row;
1137 this.tileType = _sourceBlock.tileType;
1138 if (_sourceBlock.useAltColor)
1139 {
1140 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.altColor, _sourceBlock.colorMod));
1141 }
1142 else
1143 {
1144 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.matColor, _sourceBlock.colorMod));
1145 }
1146 param.tile = (tile = -_sourceBlock._tiles[0] + ((_lowblock && !this.tileType.IsFence) ? (-32) : 0));
1147 _sourceBlock.renderData.Draw(param);
1148 }
1149 break;
1150 }
1151 case BlockRenderMode.HalfBlock:
1152 _sourceBlock = ((row.id == 5) ? EMono.sources.blocks.rows[row2.defBlock] : row);
1153 param.tile = _sourceBlock._tiles[0];
1154 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref row2.matColor, _sourceBlock.colorMod));
1155 param.tile2 = _sourceBlock.sourceAutoFloor._tiles[0];
1156 param.halfBlockColor = ((_sourceBlock.sourceAutoFloor.colorMod == 0) ? 104025 : GetColorInt(ref row2.matColor, _sourceBlock.sourceAutoFloor.colorMod));
1157 row.renderData.Draw(param);
1158 break;
1159 case BlockRenderMode.Pillar:
1160 {
1161 RenderData renderData = row.renderData;
1162 param.tile = row._tiles[param.dir % row._tiles.Length];
1163 param.matColor = ((row.colorMod == 0) ? 104025 : GetColorInt(ref row2.matColor, row.colorMod));
1164 renderData.Draw(param);
1165 param.tile = renderData.idShadow;
1166 SourcePref shadowPref = renderData.shadowPref;
1167 int shadow2 = shadowPref.shadow;
1168 passShadow.AddShadow(param.x + renderData.offsetShadow.x, param.y + renderData.offsetShadow.y, param.z + renderData.offsetShadow.z, ShadowData.Instance.items[shadow2], shadowPref, 0, param.snow);
1169 break;
1170 }
1171 default:
1172 param.tile = row._tiles[param.dir % row._tiles.Length];
1173 param.matColor = ((row.colorMod == 0) ? 104025 : GetColorInt(ref row2.matColor, row.colorMod));
1174 row.renderData.Draw(param);
1175 break;
1176 }
1177 param.x = orgX;
1178 param.y = orgY;
1179 param.z = orgZ;
1180 param.color = blockLight;
1181 }
1182 fogged = false;
1183 bool flag4 = this.cell.isSurrounded && innerMode != 0 && sourceBlock.tileType.IsFullBlock;
1184 if (!(!isSeen || flag4))
1185 {
1186 goto IL_1668;
1187 }
1188 bool isRoomEdge = this.cell.IsRoomEdge;
1189 orgY = param.y;
1190 orgZ = param.z;
1191 param.color = (int)(50f * (_baseBrightness + fogBrightness)) * 262144;
1192 param.matColor = 104025f;
1193 if (hasBridge)
1194 {
1195 param.y = (float)(cz - cx) * screen.tileAlign.y + (float)(int)this.cell.bridgeHeight * _heightMod.y + ugFixBridgeBottom.x;
1196 param.z = 1000f + param.x * screen.tileWeight.x + param.y * screen.tileWeight.z + (float)(int)this.cell.bridgeHeight * _heightMod.z;
1197 }
1198 bool flag5 = (!isSeen && EMono._zone.UseFog) || flag4;
1199 if (flag5)
1200 {
1201 param.tile = 7f;
1203 param.tile = 0f;
1205 }
1206 else if (this.cell.HasFloodBlock && isRoomEdge)
1207 {
1208 param.tile = 9f;
1210 }
1211 else
1212 {
1213 param.tile = 8f;
1215 }
1216 if ((this.cell.isSlopeEdge || hasBridge) && (flag5 || !isRoomEdge))
1217 {
1218 float num2 = (float)(int)this.cell.TopHeight * _heightMod.y;
1219 param.tile = 0f;
1220 for (int i = 0; (float)i < num2 / heightBlockSize; i++)
1221 {
1222 param.y += ugFix.y;
1223 param.z += ugFix.z + slopeFixZ * (float)i;
1224 if (flag5)
1225 {
1227 }
1228 else
1229 {
1231 }
1232 }
1233 }
1234 param.y = orgY;
1235 param.z = orgZ;
1236 param.color = blockLight;
1237 if (flag5)
1238 {
1239 if (detail == null || !EMono.pc.hasTelepathy)
1240 {
1241 return;
1242 }
1243 }
1244 else
1245 {
1246 if (isRoomEdge)
1247 {
1248 goto IL_1668;
1249 }
1250 if (detail == null || !EMono.pc.hasTelepathy)
1251 {
1252 if (noRoofMode || detail == null)
1253 {
1254 return;
1255 }
1256 fogged = true;
1257 }
1258 }
1259 goto IL_7b6a;
1260 IL_6faf:
1261 if (isSnowCovered && (sourceBlock.id != 0 || this.cell.hasDoor) && !snowed && !this.cell.isClearSnow && ((!this.cell.Front.HasRoof && !this.cell.Front.HasBlock) || (!this.cell.Right.HasRoof && !this.cell.Right.HasBlock)))
1262 {
1263 snowed = true;
1264 }
1265 if (this.cell.effect != null)
1266 {
1267 if (this.cell.effect.IsLiquid)
1268 {
1269 SourceCellEffect.Row sourceEffect = this.cell.sourceEffect;
1270 SourceMaterial.Row defaultMaterial = sourceEffect.DefaultMaterial;
1271 tile = 4 + Rand.bytes[index % Rand.MaxBytes] % 4;
1272 param.tile = tile + this.cell.sourceEffect._tiles[0];
1273 param.mat = defaultMaterial;
1274 param.matColor = ((this.cell.effect.color == 0) ? GetColorInt(ref defaultMaterial.matColor, sourceEffect.colorMod) : this.cell.effect.color);
1275 sourceEffect.renderData.Draw(param);
1276 }
1277 else
1278 {
1279 param.tile = this.cell.effect.source._tiles[0];
1280 SourceCellEffect.Row sourceEffect2 = this.cell.sourceEffect;
1281 if (sourceEffect2.anime.Length != 0)
1282 {
1283 if (sourceEffect2.anime.Length > 2)
1284 {
1285 float num3 = Time.realtimeSinceStartup * 1000f / (float)sourceEffect2.anime[1] % (float)sourceEffect2.anime[2];
1286 if (!(num3 >= (float)sourceEffect2.anime[0]))
1287 {
1288 param.tile += num3;
1289 }
1290 }
1291 else
1292 {
1293 float num4 = Time.realtimeSinceStartup * 1000f / (float)sourceEffect2.anime[1] % (float)sourceEffect2.anime[0];
1294 param.tile += num4;
1295 }
1296 }
1297 if (this.cell.effect.IsFire)
1298 {
1300 }
1301 else
1302 {
1303 this.cell.effect.source.renderData.Draw(param);
1304 }
1305 }
1306 }
1307 param.color = floorLight;
1308 if (this.cell.critter != null)
1309 {
1310 Critter critter = this.cell.critter;
1311 int snowTile = critter.tile;
1312 if (snowed && critter.SnowTile != 0)
1313 {
1314 critter.x = 0.06f;
1315 critter.y = -0.06f;
1316 snowTile = critter.SnowTile;
1317 }
1318 else
1319 {
1320 critter.Update();
1321 }
1322 pass = passObjSS;
1324 batch.matrices[pass.idx].m03 = param.x + (float)(int)(critter.x * 100f) * 0.01f;
1325 batch.matrices[pass.idx].m13 = param.y + (float)(int)(critter.y * 100f) * 0.01f;
1326 batch.matrices[pass.idx].m23 = param.z;
1327 batch.tiles[pass.idx] = snowTile * ((!critter.reverse) ? 1 : (-1));
1329 pass.idx++;
1330 if (pass.idx == pass.batchSize)
1331 {
1332 pass.NextBatch();
1333 }
1334 }
1335 if (detail != null)
1336 {
1337 TransAnime anime3 = detail.anime;
1338 if (anime3 != null && !anime3.animeBlock)
1339 {
1340 TransAnime anime4 = detail.anime;
1341 param.x += anime4.v.x;
1342 param.y += anime4.v.y;
1343 param.z += anime4.v.z;
1344 }
1345 }
1346 if (this.cell.obj != 0 && !this.cell.sourceObj.renderData.SkipOnMap)
1347 {
1348 SourceObj.Row sourceObj = this.cell.sourceObj;
1349 if (!snowed || sourceObj.snowTile <= 0)
1350 {
1351 param.snow = snowed;
1352 param.mat = this.cell.matObj;
1353 orgY = param.y;
1354 if (param.liquidLv > 0)
1355 {
1356 if (sourceObj.pref.Float)
1357 {
1358 param.y += 0.01f * floatY;
1359 if (liquidLv > 10)
1360 {
1361 liquidLv = TileType.FloorWaterShallow.LiquidLV * 10;
1362 }
1363 liquidLv -= (int)(floatY * 0.5f);
1364 param.liquidLv = liquidLv;
1365 }
1366 if (sourceObj.tileType.IsWaterTop)
1367 {
1368 param.liquidLv = 0;
1369 }
1370 else
1371 {
1372 param.liquidLv += sourceObj.pref.liquidMod;
1373 if (param.liquidLv < 1)
1374 {
1375 param.liquid = 1f;
1376 }
1377 else if (param.liquidLv > 99 + sourceObj.pref.liquidModMax)
1378 {
1379 param.liquidLv = 99 + sourceObj.pref.liquidModMax;
1380 }
1381 }
1382 }
1383 if (sourceObj.useAltColor)
1384 {
1385 param.matColor = ((sourceObj.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.altColor, sourceObj.colorMod));
1386 }
1387 else
1388 {
1389 param.matColor = ((sourceObj.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.matColor, sourceObj.colorMod));
1390 }
1391 if (sourceObj.HasGrowth)
1392 {
1393 this.cell.growth.OnRenderTileMap(param);
1394 if (this.cell.obj == 118 && Core.fixedFrame % 10f == 0f && sourceObj.growth.IsMature)
1395 {
1396 EMono.scene.psFey.transform.position = new Vector3(param.x, param.y, param.z - 2f);
1397 EMono.scene.psFey.Emit(1);
1398 }
1399 }
1400 else
1401 {
1402 if (this.cell.autotileObj != 0)
1403 {
1404 param.tile = sourceObj._tiles[0] + this.cell.autotileObj;
1405 }
1406 else if (sourceObj.tileType.IsUseBlockDir)
1407 {
1408 param.tile = sourceObj._tiles[this.cell.blockDir % sourceObj._tiles.Length];
1409 }
1410 else
1411 {
1412 param.tile = sourceObj._tiles[this.cell.objDir % sourceObj._tiles.Length];
1413 }
1414 if (_lowblock && sourceObj.tileType.IsSkipLowBlock)
1415 {
1416 param.tile += ((param.tile > 0f) ? 1 : (-1)) * 3000000;
1417 }
1418 orgY = param.y;
1419 orgZ = param.z;
1420 param.y += sourceObj.pref.y;
1421 param.z += sourceObj.pref.z;
1422 sourceObj.renderData.Draw(param);
1423 param.y = orgY;
1424 param.z = orgZ;
1425 int shadow3 = sourceObj.pref.shadow;
1426 if (shadow3 > 1 && !this.cell.ignoreObjShadow)
1427 {
1428 passShadow.AddShadow(param.x + sourceObj.renderData.offsetShadow.x, param.y + sourceObj.renderData.offsetShadow.y, param.z + sourceObj.renderData.offsetShadow.z, ShadowData.Instance.items[shadow3], sourceObj.pref, 0, param.snow);
1429 }
1430 param.y = orgY;
1431 }
1432 }
1433 }
1434 if (this.cell.decal != 0 && sourceFloor.tileType.AllowBlood)
1435 {
1436 passDecal.Add(param, (int)this.cell.decal, floorLight);
1437 }
1438 if (highlightCells)
1439 {
1440 switch (ActionMode.FlagCell.mode)
1441 {
1442 case AM_FlagCell.Mode.flagWallPillar:
1443 if (this.cell.isToggleWallPillar)
1444 {
1445 passArea.Add(param, 34f, 0f);
1446 }
1447 break;
1448 case AM_FlagCell.Mode.flagSnow:
1449 if (this.cell.isClearSnow)
1450 {
1451 passArea.Add(param, 34f, 0f);
1452 }
1453 break;
1454 case AM_FlagCell.Mode.flagFloat:
1455 if (this.cell.isForceFloat)
1456 {
1457 passArea.Add(param, 34f, 0f);
1458 }
1459 break;
1460 case AM_FlagCell.Mode.flagClear:
1461 if (this.cell.isClearArea)
1462 {
1463 passArea.Add(param, 34f, 0f);
1464 }
1465 break;
1466 }
1467 }
1468 if (detail == null)
1469 {
1470 return;
1471 }
1472 if (highlightArea && detail.area != null)
1473 {
1474 passArea.Add(param, (int)detail.area.GetTile(index) - ((!subtleHighlightArea) ? 1 : 0), 0f);
1475 }
1476 if (detail.footmark != null && sourceFloor.id != 0)
1477 {
1478 param.tile = detail.footmark.tile;
1479 param.mat = matFloor;
1480 param.matColor = 104025f;
1482 }
1483 goto IL_7b6a;
1484 IL_1668:
1485 if (this.cell.isSlopeEdge)
1486 {
1487 float num5 = (float)height * _heightMod.y;
1488 orgY = param.y;
1489 orgZ = param.z;
1490 param.dir = this.cell.blockDir;
1491 if (snowed)
1492 {
1493 param.color = floorLight;
1494 }
1495 SourceBlock.Row defBlock;
1496 if (sourceBlock.tileType.IsFullBlock)
1497 {
1498 defBlock = sourceBlock;
1499 param.mat = matBlock;
1500 param.tile = sourceBlock._tiles[this.cell.blockDir % sourceBlock._tiles.Length];
1501 param.matColor = ((sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref matBlock.matColor, sourceBlock.colorMod));
1502 }
1503 else
1504 {
1505 defBlock = sourceFloor._defBlock;
1506 param.mat = matFloor;
1507 param.tile = defBlock._tiles[this.cell.blockDir % defBlock._tiles.Length];
1508 if (defBlock.id != 1)
1509 {
1510 param.matColor = ((sourceFloor.colorMod == 0) ? 104025 : GetColorInt(ref matFloor.matColor, sourceFloor.colorMod));
1511 }
1512 else
1513 {
1514 param.matColor = 104025f;
1515 }
1516 }
1517 for (int j = 0; (float)j < num5 / heightBlockSize; j++)
1518 {
1519 param.y += ugFix.y;
1520 param.z += ugFix.z + slopeFixZ * (float)j;
1521 defBlock.renderData.Draw(param);
1522 if (this.cell.pcSync && EMono.player.lightPower > 0f)
1523 {
1524 float num6 = param.tile;
1525 param.tile = 0f;
1527 param.tile = num6;
1528 }
1529 }
1530 param.y = orgY;
1531 param.z = orgZ;
1532 }
1533 param.color = floorLight;
1534 if (!isWater && (this.cell.Front.sourceFloor.tileType.IsWater || this.cell.Right.sourceFloor.tileType.IsWater) && this.cell.sourceBlock.tileType.RenderWaterBlock && !flag)
1535 {
1536 orgY = param.y;
1537 orgZ = param.z;
1538 int num7 = 0;
1539 if (sourceBlock.tileType.IsFullBlock)
1540 {
1542 num7 = sourceBlock._tiles[this.cell.blockDir % sourceBlock._tiles.Length];
1543 }
1544 else
1545 {
1546 SourceBlock.Row row3 = sourceFloor._defBlock;
1547 num7 = row3._tiles[this.cell.blockDir % row3._tiles.Length];
1548 }
1549 if (((this.cell.Front.shore / 12) & 1) == 0 && this.cell.Front.sourceFloor.tileType.IsWater && this.cell.Front.height <= height && this.cell.Front.sourceBlock.tileType.RenderWaterBlock)
1550 {
1551 param.y = (float)(cz - cx) * screen.tileAlign.y - (this.cell.Front.sourceFloor.tileType.IsDeepWater ? 0.6f : 0.4f) + (float)(int)this.cell.Front.height * _heightMod.y;
1552 param.z = 1000f + param.x * screen.tileWeight.x + param.y * screen.tileWeight.z;
1553 param.tile = num7 + ((!this.cell.Front.sourceFloor.tileType.IsDeepWater) ? 3000000 : 0);
1555 }
1556 if (((this.cell.Right.shore / 12) & 8) == 0 && this.cell.Right.sourceFloor.tileType.IsWater && this.cell.Right.height <= height && this.cell.Right.sourceBlock.tileType.RenderWaterBlock)
1557 {
1558 param.y = (float)(cz - cx) * screen.tileAlign.y - (this.cell.Right.sourceFloor.tileType.IsDeepWater ? 0.6f : 0.4f) + (float)(int)this.cell.Right.height * _heightMod.y;
1559 param.z = 1000f + param.x * screen.tileWeight.x + param.y * screen.tileWeight.z;
1560 param.tile = num7 + ((!this.cell.Right.sourceFloor.tileType.IsDeepWater) ? 3000000 : 0);
1562 }
1563 param.y = orgY;
1564 param.z = orgZ;
1565 }
1566 if (showBorder && !this.cell.outOfBounds)
1567 {
1568 param.matColor = 104025f;
1569 if (cx == EMono._map.bounds.x)
1570 {
1571 renderBorder.Draw(param, 12 + (EMono.world.date.IsNight ? 4 : 0));
1572 }
1573 else if (cx == EMono._map.bounds.maxX)
1574 {
1575 renderBorder.Draw(param, 13 + (EMono.world.date.IsNight ? 4 : 0));
1576 }
1577 if (cz == EMono._map.bounds.z)
1578 {
1579 renderBorder.Draw(param, 14 + (EMono.world.date.IsNight ? 4 : 0));
1580 }
1581 else if (cz == EMono._map.bounds.maxZ)
1582 {
1583 renderBorder.Draw(param, 15 + (EMono.world.date.IsNight ? 4 : 0));
1584 }
1585 }
1586 if (this.cell.isSkyFloor || (detail != null && detail.anime != null && detail.anime.drawBlock))
1587 {
1588 orgY = param.y;
1589 orgZ = param.z;
1590 SourceBlock.Row defBlock2 = sourceFloor._defBlock;
1591 param.mat = matFloor;
1592 param.tile = defBlock2._tiles[this.cell.blockDir % defBlock2._tiles.Length];
1593 if (defBlock2.id != 1)
1594 {
1595 param.matColor = ((sourceFloor.colorMod == 0) ? 104025 : GetColorInt(ref matFloor.matColor, sourceFloor.colorMod));
1596 }
1597 else
1598 {
1599 param.matColor = 104025f;
1600 }
1601 for (int k = 0; k < ((!this.cell.isSkyFloor) ? 1 : EMono._map.config.skyBlockHeight); k++)
1602 {
1603 param.y += ugFix.y;
1604 param.z += ugFix.z + slopeFixZ * (float)k;
1605 defBlock2.renderData.Draw(param);
1606 }
1607 param.y = orgY;
1608 param.z = orgZ;
1609 }
1610 if (!sourceFloor.tileType.IsSkipFloor)
1611 {
1612 if ((hasBridge && sourceBridge.tileType.CastShadowSelf) || this.cell.castFloorShadow)
1613 {
1614 floorLight2 = _lightMod * light * 0.2f + _baseBrightness + _shadowStrength * floorShadowStrength * (isWater ? 0.7f : (hasBridge ? 1f : (0.6f * (1f - nightRatio))));
1615 if (snowed)
1616 {
1617 floorLight2 = (int)((double)floorLight2 * 0.85 * 50.0) * 262144 + snowColorToken;
1618 }
1619 else
1620 {
1621 floorLight2 = (int)(floorLight2 * 50f) * 262144 + ((this.cell.lightR >= 64) ? 63 : this.cell.lightR) * 4096 + ((this.cell.lightG >= 64) ? 63 : this.cell.lightG) * 64 + ((this.cell.lightB >= 64) ? 63 : this.cell.lightB);
1622 }
1623 param.color = floorLight2;
1624 if (this.cell.lotShade)
1625 {
1627 }
1628 }
1629 floorMatColor = ((sourceFloor.colorMod == 0) ? 104025 : GetColorInt(ref matFloor.matColor, sourceFloor.colorMod));
1630 if (isWater && flag)
1631 {
1632 param.y -= 0.01f * floatY;
1633 }
1634 if (!sourceBlock.tileType.IsSkipFloor || sourceBlock.transparent || hasBridge || this.cell.hasDoor || this.cell.skipRender)
1635 {
1636 param.mat = matFloor;
1637 param.tile = sourceFloor._tiles[floorDir % sourceFloor._tiles.Length];
1638 param.matColor = floorMatColor;
1639 param.snow = snowed;
1640 if (this.cell.isDeck)
1641 {
1642 param.z += 1f;
1643 if ((bool)sourceFloor.renderData.subData)
1644 {
1645 sourceFloor.renderData.subData.Draw(param);
1646 }
1647 sourceFloor.renderData.Draw(param);
1648 param.z -= 1f;
1649 }
1650 else
1651 {
1652 if ((bool)sourceFloor.renderData.subData)
1653 {
1654 sourceFloor.renderData.subData.Draw(param);
1655 }
1656 sourceFloor.renderData.Draw(param);
1657 }
1658 int num8 = 0;
1659 if (isSnowCovered && sourceFloor == FLOOR.sourceSnow && !this.cell.hasDoor)
1660 {
1661 if (!this.cell.Right.IsSnowTile && this.cell.Right.topHeight == this.cell.topHeight)
1662 {
1663 num8++;
1664 }
1665 if (!this.cell.Front.IsSnowTile && this.cell.Front.topHeight == this.cell.topHeight)
1666 {
1667 num8 += 2;
1668 }
1669 if (num8 != 0)
1670 {
1671 param.tile = 448 + num8 + 12;
1672 param.z -= 0.1f;
1673 sourceFloor.renderData.Draw(param);
1674 param.z += 0.1f;
1675 }
1676 }
1677 if (this.cell.shadow != 0 && !hasBridge && !this.cell.skipRender)
1678 {
1679 if (snowed)
1680 {
1682 {
1683 param.tile = 448 + this.cell.shadow + 8 + (this.cell.HasFence ? 4 : 0);
1684 param.z -= 0.01f;
1685 sourceFloor.renderData.Draw(param);
1686 }
1687 }
1688 else
1689 {
1690 pass = passEdge;
1692 batch.matrices[pass.idx].m03 = param.x + ambientShadowFix[this.cell.shadow].x;
1693 batch.matrices[pass.idx].m13 = param.y + ambientShadowFix[this.cell.shadow].y;
1694 batch.matrices[pass.idx].m23 = param.z + ambientShadowFix[this.cell.shadow].z;
1695 batch.tiles[pass.idx] = 448 + this.cell.shadow;
1697 batch.matColors[pass.idx] = 104025f;
1698 pass.idx++;
1699 if (pass.idx == pass.batchSize)
1700 {
1701 pass.NextBatch();
1702 }
1703 }
1704 if (!sourceFloor.ignoreTransition && !snowed)
1705 {
1706 Cell back = this.cell.Back;
1707 if (back.sourceBlock.transition[0] != -1 && back.isSeen && !back.hasDoor)
1708 {
1709 pass = passFloor;
1711 batch.matrices[pass.idx].m03 = param.x + transitionFix[0].x;
1712 batch.matrices[pass.idx].m13 = param.y + transitionFix[0].y;
1713 batch.matrices[pass.idx].m23 = param.z + transitionFix[0].z;
1714 batch.tiles[pass.idx] = 480 + back.sourceBlock.transition[0] + Rand.bytes[index % Rand.MaxBytes] % back.sourceBlock.transition[1];
1716 batch.matColors[pass.idx] = GetColorInt(ref back.matBlock.matColor, back.sourceBlock.colorMod);
1717 pass.idx++;
1718 if (pass.idx == pass.batchSize)
1719 {
1720 pass.NextBatch();
1721 }
1722 }
1723 back = this.cell.Left;
1724 if (back.sourceBlock.transition[0] != -1 && back.isSeen && !back.hasDoor)
1725 {
1726 pass = passFloor;
1728 batch.matrices[pass.idx].m03 = param.x + transitionFix[1].x;
1729 batch.matrices[pass.idx].m13 = param.y + transitionFix[1].y;
1730 batch.matrices[pass.idx].m23 = param.z + transitionFix[1].z;
1731 batch.tiles[pass.idx] = 512 + back.sourceBlock.transition[0] + Rand.bytes[index % Rand.MaxBytes] % back.sourceBlock.transition[1];
1733 batch.matColors[pass.idx] = GetColorInt(ref back.matBlock.matColor, back.sourceBlock.colorMod);
1734 pass.idx++;
1735 if (pass.idx == pass.batchSize)
1736 {
1737 pass.NextBatch();
1738 }
1739 }
1740 }
1741 }
1742 if (this.cell.autotile != 0 && sourceFloor.autotile != 0 && (!hasBridge || this.cell.bridgeHeight - this.cell.height > 3) && !this.cell.skipRender && num8 == 0)
1743 {
1744 pass = (isWater ? passAutoTileWater : passAutoTile);
1746 batch.matrices[pass.idx].m03 = param.x;
1747 batch.matrices[pass.idx].m13 = param.y;
1748 batch.matrices[pass.idx].m23 = param.z + ((hasBridge || this.cell._block != 0) ? 0.8f : 0f);
1749 batch.tiles[pass.idx] = (26 + sourceFloor.autotile / 2) * 32 + sourceFloor.autotile % 2 * 16 + this.cell.autotile;
1750 batch.colors[pass.idx] = param.color + (float)((int)(sourceFloor.autotileBrightness * 100f) * 262144);
1752 pass.idx++;
1753 if (pass.idx == pass.batchSize)
1754 {
1755 pass.NextBatch();
1756 }
1757 }
1758 }
1759 if (isWater)
1760 {
1761 int num9 = 12;
1762 int num10 = this.cell.shore / num9;
1763 int num11 = this.cell.shore % num9;
1764 bool isShoreSand = this.cell.isShoreSand;
1765 if (this.cell.shore != 0)
1766 {
1767 Cell cell = ((((uint)num10 & (true ? 1u : 0u)) != 0) ? this.cell.Back : ((((uint)num10 & 2u) != 0) ? this.cell.Right : ((((uint)num10 & 4u) != 0) ? this.cell.Front : this.cell.Left)));
1768 if (isShoreSand && !cell.sourceFloor.isBeach)
1769 {
1770 cell = ((((uint)num10 & 8u) != 0) ? this.cell.Left : ((((uint)num10 & 4u) != 0) ? this.cell.Front : ((((uint)num10 & 2u) != 0) ? this.cell.Right : this.cell.Back)));
1771 }
1772 if (!cell.IsSnowTile)
1773 {
1774 param.matColor = GetColorInt(ref cell.matFloor.matColor, cell.sourceFloor.colorMod);
1775 if (isShoreSand)
1776 {
1777 pass = passShore;
1779 batch.matrices[pass.idx].m03 = param.x;
1780 batch.matrices[pass.idx].m13 = param.y;
1781 batch.matrices[pass.idx].m23 = param.z;
1782 batch.tiles[pass.idx] = 768 + this.cell.shore / num9;
1785 pass.idx++;
1786 if (pass.idx == pass.batchSize)
1787 {
1788 pass.NextBatch();
1789 }
1790 num11 = 2;
1791 }
1792 else
1793 {
1794 num11 = cell.sourceFloor.edge;
1795 }
1796 param.tile = (24 + num11 / 2) * 32 + num11 % 2 * 16 + num10;
1798 }
1799 }
1800 if (this.cell.Back.isShoreSand && ((uint)(this.cell.Back.shore / num9) & 8u) != 0 && this.cell.Left.isShoreSand && ((uint)(this.cell.Left.shore / num9) & (true ? 1u : 0u)) != 0)
1801 {
1802 param.tile = 785f;
1803 param.matColor = GetColorInt(ref this.cell.BackLeft.matFloor.matColor, this.cell.BackLeft.sourceFloor.colorMod);
1805 Draw(60);
1806 }
1807 if (this.cell.Back.isShoreSand && ((uint)(this.cell.Back.shore / num9) & 2u) != 0 && this.cell.Right.isShoreSand && ((uint)(this.cell.Right.shore / num9) & (true ? 1u : 0u)) != 0)
1808 {
1809 param.tile = 786f;
1810 param.matColor = GetColorInt(ref this.cell.BackRight.matFloor.matColor, this.cell.BackRight.sourceFloor.colorMod);
1812 Draw(56);
1813 }
1814 if (this.cell.Front.isShoreSand && ((uint)(this.cell.Front.shore / num9) & 2u) != 0 && this.cell.Right.isShoreSand && ((uint)(this.cell.Right.shore / num9) & 4u) != 0)
1815 {
1816 param.tile = 787f;
1817 param.matColor = GetColorInt(ref this.cell.FrontRight.matFloor.matColor, this.cell.FrontRight.sourceFloor.colorMod);
1819 Draw(48);
1820 }
1821 if (this.cell.Front.isShoreSand && ((uint)(this.cell.Front.shore / num9) & 8u) != 0 && this.cell.Left.isShoreSand && ((uint)(this.cell.Left.shore / num9) & 4u) != 0)
1822 {
1823 param.tile = 788f;
1824 param.matColor = GetColorInt(ref this.cell.FrontLeft.matFloor.matColor, this.cell.FrontLeft.sourceFloor.colorMod);
1826 Draw(52);
1827 }
1828 if (this.cell._bridge != 0 && this.cell.isBridgeEdge && this.cell.bridgePillar != byte.MaxValue)
1829 {
1830 pass = passEdge;
1832 batch.matrices[pass.idx].m03 = param.x + waterEdgeBridgeFix.x;
1833 batch.matrices[pass.idx].m13 = param.y + waterEdgeBridgeFix.y;
1834 batch.matrices[pass.idx].m23 = param.z + waterEdgeBridgeFix.z;
1835 batch.tiles[pass.idx] = 616 + waterAnimeIndex % 4;
1837 batch.matColors[pass.idx] = 104025f;
1838 pass.idx++;
1839 if (pass.idx == pass.batchSize)
1840 {
1841 pass.NextBatch();
1842 }
1843 }
1844 bool flag6 = false;
1845 if (isShoreSand)
1846 {
1847 if (((uint)num10 & (true ? 1u : 0u)) != 0)
1848 {
1849 if (((uint)num10 & 8u) != 0)
1850 {
1851 if ((num10 & 2) == 0 && (num10 & 4) == 0)
1852 {
1853 Draw(16);
1854 }
1855 flag6 = true;
1856 }
1857 if (((uint)num10 & 2u) != 0)
1858 {
1859 if ((num10 & 8) == 0 && (num10 & 4) == 0)
1860 {
1861 Draw(20);
1862 }
1863 flag6 = true;
1864 }
1865 }
1866 if (((uint)num10 & 4u) != 0)
1867 {
1868 if (((uint)num10 & 8u) != 0)
1869 {
1870 if ((num10 & 2) == 0 && (num10 & 1) == 0)
1871 {
1872 Draw(24);
1873 }
1874 flag6 = true;
1875 }
1876 if (((uint)num10 & 2u) != 0)
1877 {
1878 if ((num10 & 8) == 0 && (num10 & 1) == 0)
1879 {
1880 Draw(28);
1881 }
1882 flag6 = true;
1883 }
1884 }
1885 if (!flag6)
1886 {
1887 if (!this.cell.Front.sourceFloor.tileType.IsWater && !this.cell.Front.isDeck)
1888 {
1889 Draw(8);
1890 }
1891 if (!this.cell.Right.sourceFloor.tileType.IsWater && !this.cell.Right.isDeck)
1892 {
1893 Draw(12);
1894 }
1895 }
1896 }
1897 if (!flag6)
1898 {
1899 if (!this.cell.Back.sourceFloor.tileType.IsWater && !this.cell.Back.isDeck)
1900 {
1901 pass = passEdge;
1903 batch.tiles[pass.idx] = 608 + waterAnimeIndex % 4;
1904 batch.matColors[pass.idx] = 104025f;
1905 if (((uint)(this.cell.shore / num9) & (true ? 1u : 0u)) != 0)
1906 {
1907 if (isShoreSand)
1908 {
1909 param.matColor = GetColorInt(ref this.cell.Back.matFloor.matColor, this.cell.Back.sourceFloor.colorMod);
1910 batch.matrices[pass.idx].m03 = param.x + waterEdgeFixShoreSand.x;
1911 batch.matrices[pass.idx].m13 = param.y + waterEdgeFixShoreSand.y;
1912 batch.matrices[pass.idx].m23 = param.z + waterEdgeFixShoreSand.z;
1915 }
1916 else
1917 {
1918 batch.matrices[pass.idx].m03 = param.x;
1919 batch.matrices[pass.idx].m13 = param.y;
1920 batch.matrices[pass.idx].m23 = param.z + waterEdgeFixShore.z;
1921 }
1922 }
1923 else
1924 {
1925 batch.matrices[pass.idx].m03 = param.x;
1926 batch.matrices[pass.idx].m13 = param.y;
1927 batch.matrices[pass.idx].m23 = param.z + waterEdgeFix.z;
1928 batch.tiles[pass.idx] += 12f;
1929 }
1931 pass.idx++;
1932 if (pass.idx == pass.batchSize)
1933 {
1934 pass.NextBatch();
1935 }
1936 }
1937 if (!this.cell.Left.sourceFloor.tileType.IsWater && !this.cell.Left.isDeck)
1938 {
1939 pass = passEdge;
1941 batch.tiles[pass.idx] = 612 + waterAnimeIndex % 4;
1942 batch.matColors[pass.idx] = 104025f;
1943 if (((uint)(this.cell.shore / num9) & 8u) != 0)
1944 {
1945 if (isShoreSand)
1946 {
1947 param.matColor = GetColorInt(ref this.cell.Left.matFloor.matColor, this.cell.Left.sourceFloor.colorMod);
1948 batch.matrices[pass.idx].m03 = param.x + waterEdgeFixShoreSand.x;
1949 batch.matrices[pass.idx].m13 = param.y + waterEdgeFixShoreSand.y;
1950 batch.matrices[pass.idx].m23 = param.z + waterEdgeFixShoreSand.z;
1953 }
1954 else
1955 {
1956 batch.matrices[pass.idx].m03 = param.x;
1957 batch.matrices[pass.idx].m13 = param.y;
1958 batch.matrices[pass.idx].m23 = param.z + waterEdgeFixShore.z;
1959 }
1960 }
1961 else
1962 {
1963 batch.matrices[pass.idx].m03 = param.x;
1964 batch.matrices[pass.idx].m13 = param.y;
1965 batch.matrices[pass.idx].m23 = param.z + waterEdgeFix.z;
1966 batch.tiles[pass.idx] += 12f;
1967 }
1969 pass.idx++;
1970 if (pass.idx == pass.batchSize)
1971 {
1972 pass.NextBatch();
1973 }
1974 }
1975 }
1976 if (flag)
1977 {
1978 param.y += 0.01f * floatY;
1979 }
1980 }
1981 if (flag)
1982 {
1983 param.z -= 1f;
1984 }
1985 }
1986 if (this.cell.skipRender)
1987 {
1988 if (this.cell.pcSync)
1989 {
1990 param.tile = 0f;
1992 }
1993 return;
1994 }
1995 if (hasBridge)
1996 {
1997 param.y = (float)(cz - cx) * screen.tileAlign.y + (float)(int)this.cell.bridgeHeight * _heightMod.y;
1998 param.z = 1000f + param.x * screen.tileWeight.x + param.y * screen.tileWeight.z + (float)(int)this.cell.bridgeHeight * _heightMod.z;
1999 if (flag)
2000 {
2001 param.y += 0.01f * floatY;
2002 }
2003 param.color = floorLight;
2004 param.mat = matBridge;
2005 floorMatColor = ((sourceBridge.colorMod == 0) ? 104025 : GetColorInt(ref matBridge.matColor, sourceBridge.colorMod));
2006 param.dir = this.cell.floorDir;
2007 param.tile = sourceBridge._tiles[this.cell.floorDir % sourceBridge._tiles.Length];
2008 param.matColor = floorMatColor;
2009 sourceBridge.renderData.Draw(param);
2010 if (this.cell.autotileBridge != 0 && sourceBridge.autotile != 0)
2011 {
2014 batch.matrices[pass.idx].m03 = param.x;
2015 batch.matrices[pass.idx].m13 = param.y;
2016 batch.matrices[pass.idx].m23 = param.z + ((this.cell._block != 0) ? 0.8f : 0f);
2017 batch.tiles[pass.idx] = (26 + sourceBridge.autotile / 2) * 32 + sourceBridge.autotile % 2 * 16 + this.cell.autotileBridge;
2018 batch.colors[pass.idx] = param.color + (float)((int)(sourceBridge.autotileBrightness * 100f) * 262144);
2020 pass.idx++;
2021 if (pass.idx == pass.batchSize)
2022 {
2023 pass.NextBatch();
2024 }
2025 }
2026 if (this.cell.shadow != 0)
2027 {
2029 {
2030 param.tile = 448 + this.cell.shadow + 8 + (this.cell.HasFence ? 4 : 0);
2031 param.z -= 0.01f;
2032 sourceBridge.renderData.Draw(param);
2033 }
2034 else
2035 {
2036 pass = passEdge;
2038 batch.matrices[pass.idx].m03 = param.x + ambientShadowFix[this.cell.shadow].x;
2039 batch.matrices[pass.idx].m13 = param.y + ambientShadowFix[this.cell.shadow].y;
2040 batch.matrices[pass.idx].m23 = param.z + ambientShadowFix[this.cell.shadow].z;
2041 batch.tiles[pass.idx] = 448 + this.cell.shadow;
2043 batch.matColors[pass.idx] = 104025f;
2044 pass.idx++;
2045 if (pass.idx == pass.batchSize)
2046 {
2047 pass.NextBatch();
2048 }
2049 }
2050 }
2051 if (this.cell.isBridgeEdge && this.cell.bridgeHeight - this.cell.height >= 3 && this.cell.bridgePillar != byte.MaxValue && !noSlopMode)
2052 {
2053 orgY = param.y;
2054 orgZ = param.z;
2055 param.y += bridgeFix.y;
2056 param.z += bridgeFix.z;
2057 param.dir = 0;
2058 SourceBlock.Row row4 = sourceBridge._bridgeBlock;
2059 float num12 = (float)(this.cell.bridgeHeight - this.cell.height) * _heightMod.y;
2060 if (this.cell.sourceFloor.tileType == TileType.Sky)
2061 {
2062 num12 += (float)EMono._map.config.skyBlockHeight;
2063 }
2064 int num13 = (int)(num12 / heightBlockSize) + 2;
2065 if (this.cell.bridgePillar != 0)
2066 {
2067 row4 = EMono.sources.blocks.rows[this.cell.bridgePillar];
2068 param.tile = row4._tiles[0] + ((num13 == 2) ? 32 : 0);
2069 param.mat = ((sourceBridge.DefaultMaterial == row4.DefaultMaterial) ? sourceBridge.DefaultMaterial : row4.DefaultMaterial);
2070 param.matColor = ((row4.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.matColor, row4.colorMod));
2071 }
2072 else
2073 {
2074 param.mat = matBlock;
2075 param.tile = row4._tiles[0] + 32;
2076 param.matColor = ((row4.colorMod == 0) ? 104025 : GetColorInt(ref matBridge.matColor, row4.colorMod));
2077 }
2078 param.y += ugFixBridgeTop.y;
2079 param.z += ugFixBridgeTop.z;
2080 for (int l = 0; l < num13; l++)
2081 {
2082 if (l == num13 - 1)
2083 {
2084 param.y = (float)(cz - cx) * screen.tileAlign.y + (float)height * _heightMod.y + ugFixBridgeBottom.y;
2085 param.z = 1000f + param.x * screen.tileWeight.x + param.y * screen.tileWeight.z + (float)height * _heightMod.z + ugFixBridgeBottom.z;
2086 }
2087 else
2088 {
2089 param.y += ugFixBridge.y;
2090 param.z += ugFixBridge.z;
2091 }
2092 row4.renderData.Draw(param);
2093 }
2094 param.y = orgY;
2095 param.z = orgZ;
2096 }
2097 }
2098 if (!buildMode && this.cell.highlight != 0)
2099 {
2100 if (this.cell._block != 0 && !this.cell.hasDoor)
2101 {
2102 screen.guide.DrawWall(this.cell.GetPoint(), EMono.Colors.blockColors.MapHighlight, useMarkerPass: true);
2103 }
2104 else
2105 {
2106 passGuideFloor.Add(this.cell.GetPoint(), (int)this.cell.highlight);
2107 }
2108 }
2109 param.color = blockLight;
2110 if (isSnowCovered && (sourceBlock.id != 0 || this.cell.hasDoor) && (snowed || this.cell.isClearSnow) && (this.cell.Front.HasRoof || this.cell.Right.HasRoof))
2111 {
2112 snowed = false;
2113 }
2114 int num14 = 0;
2115 if (sourceBlock.id != 0)
2116 {
2117 this.tileType = sourceBlock.tileType;
2118 roomHeight = 0f;
2119 int blockDir = this.cell.blockDir;
2120 bool flag7 = false;
2121 switch (wallClipMode)
2122 {
2123 case WallClipMode.ByRoom:
2124 if (!this.tileType.RepeatBlock)
2125 {
2126 break;
2127 }
2128 if (currentRoom == null || showFullWall)
2129 {
2130 this.room = this.room ?? this.cell.Front.room ?? this.cell.Right.room ?? this.cell.FrontRight.room;
2132 }
2133 else if (this.room != this.cell.Front.room && (this.cell.Front.room == currentRoom || (this.room?.lot != currentLot && this.cell.Front.room?.lot == currentLot)))
2134 {
2135 this.room = this.cell.Front.room;
2136 _lowblock = !this.cell.Front.lotWall && !this.cell.Front.fullWall;
2137 }
2138 else if (this.room != this.cell.Right.room && (this.cell.Right.room == currentRoom || (this.room?.lot != currentLot && this.cell.Right.room?.lot == currentLot)))
2139 {
2140 this.room = this.cell.Right.room;
2141 _lowblock = !this.cell.Right.lotWall && !this.cell.Right.fullWall;
2142 }
2143 else if (this.tileType.IsFullBlock && this.room != this.cell.FrontRight.room && (this.cell.FrontRight.room == currentRoom || (this.room?.lot != currentLot && this.cell.FrontRight.room?.lot == currentLot)))
2144 {
2145 this.room = this.cell.FrontRight.room;
2146 _lowblock = !this.cell.FrontRight.lotWall && !this.cell.FrontRight.fullWall;
2147 }
2148 else
2149 {
2150 this.room = this.room ?? this.cell.Front.room ?? this.cell.Right.room ?? this.cell.FrontRight.room;
2151 _lowblock = true;
2152 if (!this.tileType.IsFullBlock)
2153 {
2154 if (this.cell.lotWall)
2155 {
2156 _lowblock = false;
2157 }
2158 else if (this.room == currentRoom)
2159 {
2160 _lowblock = !this.cell.fullWall;
2161 }
2162 }
2163 }
2164 flag7 = (this.room != null && this.room.data.atrium) || (this.cell.room != null && this.cell.room.data.atrium);
2165 if (flag7)
2166 {
2167 _lowblock = false;
2168 }
2169 if (this.room == null && alwaysLowblock)
2170 {
2171 _lowblock = true;
2172 roomHeight = 0f;
2173 }
2174 if (this.room != null)
2175 {
2176 maxHeight = (float)(cz - cx) * screen.tileAlign.y + (float)this.room.lot.mh * _heightMod.y;
2177 if (showRoof)
2178 {
2179 roomHeight = this.room.lot.realHeight;
2180 break;
2181 }
2182 if ((noRoofMode && currentRoom == null) || (_lowblock && !this.tileType.ForceRpeatBlock))
2183 {
2184 roomHeight = 0f;
2185 break;
2186 }
2187 int num15 = ((this.room.data.maxHeight == 0) ? 2 : this.room.data.maxHeight);
2188 roomHeight = EMono.setting.render.roomHeightMod * (float)((this.room.lot.height < num15) ? this.room.lot.height : num15) + 0.01f * (float)this.room.lot.heightFix;
2189 }
2190 break;
2191 case WallClipMode.ByLot:
2192 if (defaultBlockHeight > 0f || isIndoor)
2193 {
2194 _lowblock = cx != 0 && cz != Size - 1 && ((!this.cell.Back.HasBlock && !this.cell.Back.isWallEdge) || (!this.cell.Left.HasBlock && !this.cell.Left.isWallEdge) || !this.cell.Back.Left.HasBlock);
2195 if (!_lowblock)
2196 {
2198 maxHeight = (float)(cz - cx) * screen.tileAlign.y + (float)(int)this.cell.TopHeight * _heightMod.y;
2199 }
2200 break;
2201 }
2202 if (showFullWall)
2203 {
2204 _lowblock = this.room != null;
2205 if (_lowblock)
2206 {
2207 if (this.cell.Back.IsRoomEdge && this.cell.Right.IsRoomEdge && this.cell.Back.room == null && this.cell.Right.room == null && this.cell.Right.Front.room?.lot == this.room?.lot)
2208 {
2209 _lowblock = false;
2210 }
2211 }
2212 else if (this.cell.Back.room != null && this.cell.Back.room.lot == (this.cell.Front.room ?? this.cell.Right.room)?.lot)
2213 {
2214 _lowblock = true;
2215 }
2216 }
2217 else
2218 {
2220 }
2221 if (this.tileType.RepeatBlock)
2222 {
2223 this.room = this.room ?? this.cell.Front.room ?? this.cell.Right.room ?? this.cell.FrontRight.room;
2224 if (this.room != null && (!noRoofMode || currentRoom != null) && (!showFullWall || currentRoom == null || this.room.lot == currentRoom.lot))
2225 {
2226 roomHeight = ((_lowblock && !this.tileType.ForceRpeatBlock) ? 0f : this.room.lot.realHeight);
2227 maxHeight = (float)(cz - cx) * screen.tileAlign.y + (float)this.room.lot.mh * _heightMod.y;
2228 }
2229 }
2230 break;
2231 }
2232 if (!_lowblock && (double)roomHeight > 1.2 && this.tileType.RepeatBlock)
2233 {
2234 num14 = 1;
2235 }
2236 else if (lowBlock)
2237 {
2238 num14 = 2;
2239 }
2240 param.mat = matBlock;
2241 param.dir = this.cell.blockDir;
2242 param.snow = snowed;
2243 switch (this.tileType.blockRenderMode)
2244 {
2245 case BlockRenderMode.FullBlock:
2246 {
2247 bool invisible = sourceBlock.tileType.Invisible;
2248 if (invisible && !buildMode && !ActionMode.Cinema.IsActive)
2249 {
2250 break;
2251 }
2252 if (this.cell.isSurrounded)
2253 {
2254 switch (innerMode)
2255 {
2256 case InnerMode.InnerBlock:
2257 case InnerMode.BuildMode:
2259 param.color = (int)(50f * blockLight) * 262144;
2260 param.matColor = 104025f;
2261 param.tile = (buildMode ? 1 : 2) + ((_lowblock || defaultBlockHeight > 0f) ? 3000000 : 0);
2263 return;
2264 case InnerMode.None:
2265 case InnerMode.Height:
2266 param.color = blockLight;
2267 break;
2268 }
2269 }
2270 if (snowed)
2271 {
2272 param.color = floorLight;
2273 }
2274 param.color -= (int)(_shadowStrength * 0.8f * 50f) * 262144;
2275 if (currentRoom != null && !showFullWall)
2276 {
2277 _lowblock = true;
2278 roomHeight = 0f;
2279 if (this.cell.room != currentRoom && (this.cell.Front.room == currentRoom || this.cell.Right.room == currentRoom || this.cell.FrontRight.room == currentRoom) && (this.cell.Back.room != currentRoom || this.cell.Right.room != currentRoom) && (this.cell.Front.room != currentRoom || this.cell.Left.room != currentRoom))
2280 {
2281 _lowblock = false;
2282 }
2283 if (!_lowblock)
2284 {
2285 int num16 = ((currentRoom.data.maxHeight == 0) ? 2 : currentRoom.data.maxHeight);
2286 roomHeight = EMono.setting.render.roomHeightMod * (float)((currentRoom.lot.height < num16) ? currentRoom.lot.height : num16) + 0.01f * (float)currentRoom.lot.heightFix;
2287 }
2288 }
2289 if (flag7)
2290 {
2291 _lowblock = (!this.cell.Front.HasFullBlock || !this.cell.Right.HasFullBlock) && (!this.cell.Front.HasFullBlock || !this.cell.Left.HasFullBlock) && (!this.cell.Back.HasFullBlock || !this.cell.Right.HasFullBlock) && (!this.cell.Back.HasFullBlock || !this.cell.Left.HasFullBlock);
2292 if (_lowblock)
2293 {
2294 roomHeight = 0f;
2295 }
2296 }
2297 if (invisible)
2298 {
2299 roomHeight = 0f;
2300 _lowblock = false;
2301 }
2302 if (this.cell.Things.Count > 0)
2303 {
2304 _lowblock = false;
2305 }
2306 param.tile = sourceBlock._tiles[this.cell.blockDir % sourceBlock._tiles.Length] + (_lowblock ? 3000000 : 0);
2307 param.matColor = ((sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref matBlock.matColor, sourceBlock.colorMod));
2308 if (roomHeight == 0f)
2309 {
2310 if (!this.cell.hasDoor)
2311 {
2312 sourceBlock.renderData.Draw(param);
2313 }
2314 }
2315 else
2316 {
2317 sourceBlock.renderData.DrawRepeatTo(param, maxHeight, roomHeight, ref renderSetting.peakFixBlock, this.cell.hasDoor, this.cell.effect?.FireAmount ?? 0, isBlock: true);
2318 }
2319 Room room = this.cell.Front.room ?? this.cell.room;
2320 if (room == null && this.cell.Right.room != null)
2321 {
2322 room = this.cell.Right.room;
2323 }
2324 if (!invisible && room != null)
2325 {
2326 if (room.lot.idDeco != 0 && !this.cell.hasDoor)
2327 {
2328 param.tile = EMono.sources.blocks.rows[0].ConvertTile(1000 + room.lot.idDeco);
2329 param.matColor = room.lot.colDeco;
2330 float y = param.y;
2331 param.y += (float)room.lot.decoFix * 0.01f;
2333 param.y = y;
2334 }
2335 if (room.lot.idDeco2 != 0 && roomHeight != 0f && (float)room.lot.decoFix2 * 0.01f + heightLimitDeco < roomHeight + maxHeight - param.y)
2336 {
2337 param.tile = EMono.sources.blocks.rows[0].ConvertTile(1000 + room.lot.idDeco2);
2338 param.matColor = room.lot.colDeco2;
2339 float y2 = param.y;
2340 float num17 = param.z;
2341 param.y += (float)room.lot.decoFix2 * 0.01f;
2342 param.z += (float)room.lot.decoFix2 * 0.01f * heightModDeco;
2344 param.y = y2;
2345 param.z = num17;
2346 }
2347 }
2348 room = this.cell.Right.room ?? this.cell.room;
2349 if (room == null && this.cell.Front.room != null)
2350 {
2351 room = this.cell.Front.room;
2352 }
2353 if (!invisible && room != null)
2354 {
2355 if (room.lot.idDeco != 0 && !this.cell.hasDoor)
2356 {
2357 param.tile = EMono.sources.blocks.rows[0].ConvertTile(1000 + room.lot.idDeco) * -1;
2358 param.matColor = room.lot.colDeco;
2359 float y3 = param.y;
2360 param.y += (float)room.lot.decoFix * 0.01f;
2362 param.y = y3;
2363 }
2364 if (room.lot.idDeco2 != 0 && roomHeight != 0f && (float)room.lot.decoFix2 * 0.01f + heightLimitDeco < roomHeight + maxHeight - param.y)
2365 {
2366 param.tile = EMono.sources.blocks.rows[0].ConvertTile(1000 + room.lot.idDeco2) * -1;
2367 param.matColor = room.lot.colDeco2;
2368 float y4 = param.y;
2369 float num18 = param.z;
2370 param.y += (float)room.lot.decoFix2 * 0.01f;
2371 param.z += (float)room.lot.decoFix2 * 0.01f * heightModDeco;
2373 param.y = y4;
2374 param.z = num18;
2375 }
2376 }
2377 break;
2378 }
2379 case BlockRenderMode.WallOrFence:
2380 {
2382 {
2383 showFullWall = true;
2384 _lowblock = false;
2385 }
2386 orgY = param.y;
2387 orgZ = param.z;
2388 param.color = (this.tileType.IsFence ? (floorLight - (float)((int)(_shadowStrength * 0.8f * 50f) * 262144)) : blockLight);
2389 bool flag8 = blockDir == 1 || _lowblock || flag7;
2390 bool flag9 = blockDir == 0 || _lowblock || flag7;
2391 if (!showFullWall && currentRoom != null)
2392 {
2393 if (!flag8)
2394 {
2395 if (currentRoom == this.cell.room || (this.cell.lotWall && this.cell.room?.lot == currentLot && this.cell.Front.room != currentRoom))
2396 {
2397 if (!this.cell.IsRoomEdge || (this.cell.Front.room != this.cell.room && this.cell.FrontRight.room != this.cell.room))
2398 {
2399 flag8 = true;
2400 }
2401 }
2402 else if ((!this.cell.Front.lotWall || this.cell.Front.room?.lot != currentLot) && this.cell.Front.room != currentRoom)
2403 {
2404 flag8 = true;
2405 }
2406 }
2407 if (!flag9)
2408 {
2409 if (currentRoom == this.cell.room || (this.cell.lotWall && this.cell.room?.lot == currentLot && this.cell.Right.room != currentRoom))
2410 {
2411 if (!this.cell.IsRoomEdge || (this.cell.Right.room != this.cell.room && this.cell.FrontRight.room != this.cell.room))
2412 {
2413 flag9 = true;
2414 }
2415 }
2416 else if ((!this.cell.Right.lotWall || this.cell.Right.room?.lot != currentLot) && this.cell.Right.room != currentRoom)
2417 {
2418 flag9 = true;
2419 }
2420 }
2421 }
2422 if (blockDir == 0 || blockDir == 2)
2423 {
2424 param.dir = 0;
2425 Room room2 = this.cell.Front.room ?? this.cell.room;
2426 if (room2 != null && this.tileType.IsWall)
2427 {
2428 if (room2.lot.idDeco != 0 && !this.cell.hasDoor)
2429 {
2430 param.tile = EMono.sources.blocks.rows[0].ConvertTile(1000 + room2.lot.idDeco);
2431 param.matColor = room2.lot.colDeco;
2432 param.y += (float)room2.lot.decoFix * 0.01f;
2434 param.y = orgY;
2435 }
2436 if (room2.lot.idDeco2 != 0 && roomHeight != 0f && !flag8 && (float)room2.lot.decoFix2 * 0.01f + heightLimitDeco < roomHeight + maxHeight - param.y)
2437 {
2438 param.tile = EMono.sources.blocks.rows[0].ConvertTile(1000 + room2.lot.idDeco2);
2439 param.matColor = room2.lot.colDeco2;
2440 param.y += (float)room2.lot.decoFix2 * 0.01f;
2441 param.z += (float)room2.lot.decoFix2 * 0.01f * heightModDeco;
2443 param.y = orgY;
2444 param.z = orgZ;
2445 }
2446 }
2447 Cell left = this.cell.Left;
2448 if (blockDir == 2 && left.sourceBlock.tileType.IsWallOrFence && !this.cell.crossWall)
2449 {
2450 _sourceBlock = left.sourceBlock;
2451 param.mat = left.matBlock;
2452 }
2453 else
2454 {
2456 param.mat = matBlock;
2457 }
2458 this.tileType = _sourceBlock.tileType;
2459 param.tile = (tile = _sourceBlock._tiles[0] + ((flag8 && !this.tileType.IsFence) ? 32 : 0));
2460 if (_sourceBlock.useAltColor)
2461 {
2462 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.altColor, _sourceBlock.colorMod));
2463 }
2464 else
2465 {
2466 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.matColor, _sourceBlock.colorMod));
2467 }
2468 if (roomHeight == 0f || flag8 || !this.tileType.RepeatBlock)
2469 {
2470 if (!this.cell.hasDoor)
2471 {
2472 _sourceBlock.renderData.Draw(param);
2473 }
2474 }
2475 else
2476 {
2477 _sourceBlock.renderData.DrawRepeatTo(param, maxHeight, roomHeight, ref renderSetting.peakFix, this.cell.hasDoor, this.cell.effect?.FireAmount ?? 0);
2478 }
2479 param.z += cornerWallFix2.z;
2480 if ((blockDir == 2 || (this.cell.Front.HasWallOrFence && this.cell.Front.blockDir != 0)) != this.cell.isToggleWallPillar)
2481 {
2482 if (this.cell.Back.IsSnowTile && this.cell.Right.IsSnowTile)
2483 {
2484 param.snow = true;
2485 }
2486 param.tile = _sourceBlock._tiles[0] + ((flag8 && flag9 && !this.tileType.IsFence && !flag7) ? 32 : 0) + (this.tileType.IsFence ? 32 : 64);
2487 if (roomHeight == 0f || !this.tileType.RepeatBlock || (flag8 && flag9 && !flag7))
2488 {
2489 _sourceBlock.renderData.Draw(param);
2490 }
2491 else
2492 {
2493 _sourceBlock.renderData.DrawRepeatTo(param, maxHeight, roomHeight, ref renderSetting.peakFix);
2494 }
2495 }
2496 if (!flag8 && !showRoof && this.cell.Left.HasWallOrFence && this.cell.Left.blockDir != 0 && !this.cell.isToggleWallPillar)
2497 {
2498 orgX = param.x;
2499 param.tile = _sourceBlock._tiles[0] + ((flag8 && !this.tileType.IsFence && !flag7) ? 32 : 0) + (this.tileType.IsFence ? 32 : 64);
2500 param.x += cornerWallFix3.x;
2501 param.y += cornerWallFix3.y;
2502 param.z += cornerWallFix3.z;
2503 if (!flag7 && (roomHeight == 0f || flag8))
2504 {
2505 _sourceBlock.renderData.Draw(param);
2506 }
2507 else
2508 {
2509 _sourceBlock.renderData.DrawRepeatTo(param, maxHeight, roomHeight + cornerWallFix.y, ref renderSetting.peakFix);
2510 }
2511 param.x = orgX;
2512 }
2513 else if (this.cell.FrontLeft.HasWallOrFence && this.cell.FrontLeft.blockDir != 0 && (!flag8 || !this.cell.Left.HasWall) && !this.cell.isToggleWallPillar)
2514 {
2515 orgX = param.x;
2516 param.tile = _sourceBlock._tiles[0] + ((flag8 && !this.tileType.IsFence && !flag7) ? 32 : 0) + (this.tileType.IsFence ? 32 : 64);
2517 param.x += cornerWallFix.x;
2518 param.y += cornerWallFix.y;
2519 param.z += cornerWallFix.z;
2520 if (!flag7 && (roomHeight == 0f || flag8))
2521 {
2522 _sourceBlock.renderData.Draw(param);
2523 }
2524 else
2525 {
2526 _sourceBlock.renderData.DrawRepeatTo(param, maxHeight, roomHeight + cornerWallFix.y, ref renderSetting.peakFix);
2527 }
2528 param.x = orgX;
2529 }
2530 }
2531 if (blockDir == 1 || blockDir == 2)
2532 {
2533 param.y = orgY;
2534 param.z = orgZ;
2535 param.dir = 1;
2536 Room room3 = this.cell.Right.room ?? this.cell.room;
2537 if (room3 != null && this.tileType.IsWall)
2538 {
2539 if (room3.lot.idDeco != 0 && !this.cell.hasDoor)
2540 {
2541 param.tile = -EMono.sources.blocks.rows[0].ConvertTile(1000 + room3.lot.idDeco);
2542 param.matColor = room3.lot.colDeco;
2543 param.y += (float)room3.lot.decoFix * 0.01f;
2545 param.y = orgY;
2546 }
2547 if (room3.lot.idDeco2 != 0 && roomHeight != 0f && !flag9 && (float)room3.lot.decoFix2 * 0.01f + heightLimitDeco < roomHeight + maxHeight - param.y)
2548 {
2549 param.tile = -EMono.sources.blocks.rows[0].ConvertTile(1000 + room3.lot.idDeco2);
2550 param.matColor = room3.lot.colDeco2;
2551 param.y += (float)room3.lot.decoFix2 * 0.01f;
2552 param.z += (float)room3.lot.decoFix2 * 0.01f * heightModDeco;
2554 param.y = orgY;
2555 param.z = orgZ;
2556 }
2557 }
2558 if (blockDir == 2 && this.cell.room == null && this.cell.Right.room != null)
2559 {
2560 Room room4 = this.cell.Right.room;
2561 maxHeight = (float)(cz - cx) * screen.tileAlign.y + (float)room4.lot.mh * _heightMod.y;
2562 if (showRoof)
2563 {
2564 roomHeight = room4.lot.realHeight;
2565 }
2566 else if ((noRoofMode && currentRoom == null) || (_lowblock && !this.tileType.ForceRpeatBlock))
2567 {
2568 roomHeight = 0f;
2569 }
2570 else
2571 {
2572 int num19 = ((room4.data.maxHeight == 0) ? 2 : room4.data.maxHeight);
2573 roomHeight = EMono.setting.render.roomHeightMod * (float)((room4.lot.height < num19) ? room4.lot.height : num19) + 0.01f * (float)room4.lot.heightFix;
2574 }
2575 }
2576 Cell back2 = this.cell.Back;
2577 if (blockDir == 2 && back2.sourceBlock.tileType.IsWallOrFence && !this.cell.crossWall)
2578 {
2579 _sourceBlock = back2.sourceBlock;
2580 param.mat = back2.matBlock;
2581 }
2582 else
2583 {
2585 param.mat = matBlock;
2586 }
2587 this.tileType = _sourceBlock.tileType;
2588 param.tile = (tile = -_sourceBlock._tiles[0] + ((flag9 && !this.tileType.IsFence) ? (-32) : 0));
2589 if (_sourceBlock.useAltColor)
2590 {
2591 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.altColor, _sourceBlock.colorMod));
2592 }
2593 else
2594 {
2595 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref param.mat.matColor, _sourceBlock.colorMod));
2596 }
2597 param.color += _rightWallShade;
2598 if (roomHeight == 0f || flag9 || !this.tileType.RepeatBlock)
2599 {
2600 if (!this.cell.hasDoor)
2601 {
2602 _sourceBlock.renderData.Draw(param);
2603 }
2604 }
2605 else
2606 {
2607 _sourceBlock.renderData.DrawRepeatTo(param, maxHeight, roomHeight, ref renderSetting.peakFix, this.cell.hasDoor, this.cell.effect?.FireAmount ?? 0);
2608 }
2609 if ((this.cell.Right.HasWallOrFence && this.cell.Right.blockDir != 1) != this.cell.isToggleWallPillar && (blockDir != 2 || !this.cell.isToggleWallPillar))
2610 {
2611 if (this.cell.Left.IsSnowTile && this.cell.Front.IsSnowTile)
2612 {
2613 param.snow = true;
2614 }
2615 orgX = param.x;
2616 param.tile = _sourceBlock._tiles[0] + ((flag9 && !this.tileType.IsFence && !flag7) ? 32 : 0) + (this.tileType.IsFence ? 32 : 64);
2617 if (!flag7 && (roomHeight == 0f || !this.tileType.RepeatBlock || flag9))
2618 {
2619 _sourceBlock.renderData.Draw(param);
2620 }
2621 else
2622 {
2623 _sourceBlock.renderData.DrawRepeatTo(param, maxHeight, roomHeight, ref renderSetting.peakFix);
2624 }
2625 param.x = orgX;
2626 }
2627 }
2628 param.y = orgY;
2629 param.z = orgZ;
2630 break;
2631 }
2632 case BlockRenderMode.HalfBlock:
2633 param.color = floorLight;
2634 _sourceBlock = ((sourceBlock.id == 5) ? EMono.sources.blocks.rows[matBlock.defBlock] : sourceBlock);
2635 param.tile = _sourceBlock._tiles[0];
2636 param.matColor = ((_sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref matBlock.matColor, _sourceBlock.colorMod));
2637 param.tile2 = _sourceBlock.sourceAutoFloor._tiles[0];
2638 param.halfBlockColor = ((_sourceBlock.sourceAutoFloor.colorMod == 0) ? 104025 : GetColorInt(ref matBlock.matColor, _sourceBlock.sourceAutoFloor.colorMod));
2639 sourceBlock.renderData.Draw(param);
2640 break;
2641 case BlockRenderMode.Pillar:
2642 {
2643 RenderData renderData2 = sourceBlock.renderData;
2644 param.tile = sourceBlock._tiles[this.cell.blockDir % sourceBlock._tiles.Length];
2645 param.matColor = ((sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref matBlock.matColor, sourceBlock.colorMod));
2646 int num20 = this.cell.objDir + ((this.cell.objDir >= 7) ? this.cell.objDir : 0) + 1;
2647 if (num20 == 0)
2648 {
2649 renderData2.Draw(param);
2650 }
2651 else
2652 {
2653 renderData2.DrawRepeat(param, num20, sourceBlock.tileType.RepeatSize);
2654 }
2655 param.tile = renderData2.idShadow;
2656 SourcePref shadowPref2 = renderData2.shadowPref;
2657 int shadow4 = shadowPref2.shadow;
2658 passShadow.AddShadow(param.x + renderData2.offsetShadow.x, param.y + renderData2.offsetShadow.y, param.z + renderData2.offsetShadow.z, ShadowData.Instance.items[shadow4], shadowPref2, 0, param.snow);
2659 break;
2660 }
2661 default:
2662 param.color = floorLight;
2663 param.tile = sourceBlock._tiles[this.cell.blockDir % sourceBlock._tiles.Length] + ((_lowblock && this.tileType.UseLowWallTiles) ? 3000000 : 0);
2664 param.matColor = ((sourceBlock.colorMod == 0) ? 104025 : GetColorInt(ref matBlock.matColor, sourceBlock.colorMod));
2665 if (roomHeight == 0f)
2666 {
2667 sourceBlock.renderData.Draw(param);
2668 }
2669 else
2670 {
2671 sourceBlock.renderData.DrawRepeatTo(param, maxHeight, roomHeight, ref renderSetting.peakFixBlock);
2672 }
2673 break;
2674 }
2675 }
2676 if (this.cell.pcSync && EMono.player.lightPower > 0f && !cinemaMode)
2677 {
2678 if (this.cell.room != null || !this.cell.IsRoomEdge || !showRoof)
2679 {
2680 goto IL_6f4f;
2681 }
2682 if (this.cell._block == 0 || !this.cell.sourceBlock.tileType.RepeatBlock)
2683 {
2684 Room obj = this.cell.FrontRight.room;
2685 if (obj == null || !obj.HasRoof)
2686 {
2687 goto IL_6f4f;
2688 }
2689 }
2690 }
2691 goto IL_6faf;
2692 IL_7b6a:
2693 if (detail.things.Count == 0 && detail.charas.Count == 0)
2694 {
2695 return;
2696 }
2697 int num21 = 0;
2698 thingPos.x = 0f;
2699 thingPos.y = 0f;
2700 thingPos.z = 0f;
2701 freePos.x = (freePos.y = (freePos.z = 0f));
2702 if (this.cell.HasRamp)
2703 {
2704 Vector3 rampFix = sourceBlock.tileType.GetRampFix(this.cell.blockDir);
2705 param.x += rampFix.x;
2706 param.y += rampFix.y;
2707 param.z += rampFix.z;
2708 freePos.x += rampFix.x;
2709 freePos.y += rampFix.y;
2710 freePos.z += rampFix.z;
2711 }
2712 param.y += (flag ? 0f : ((this.cell._bridge != 0) ? this.cell.sourceBridge.tileType.FloorHeight : sourceFloor.tileType.FloorHeight));
2713 orgPos.x = (orgX = param.x);
2714 orgPos.y = (orgY = param.y);
2715 orgPos.z = (orgZ = param.z);
2716 if (flag && liquidLv > 0)
2717 {
2718 if (liquidLv > 10)
2719 {
2720 liquidLv = TileType.FloorWaterShallow.LiquidLV * 10;
2721 }
2722 liquidLv -= (int)(floatY * 0.5f);
2723 param.liquidLv = liquidLv;
2725 }
2726 Thing thing = null;
2727 bool shadow = liquidLv == 0;
2728 float num22 = 0f;
2729 float num23 = 0f;
2730 bool flag10 = false;
2731 float num24 = 0f;
2732 bool flag11 = false;
2733 float num25 = 0f;
2734 if (detail.things.Count > 0 && isSeen)
2735 {
2736 _ = zSetting.max1;
2737 float num26 = 0f;
2738 for (int m = 0; m < detail.things.Count; m++)
2739 {
2740 Thing t = detail.things[m];
2741 if ((fogged && !t.isRoofItem) || ((t.isHidden || t.trait.HideInAdv || t.isMasked) && !EMono.scene.actionMode.ShowMaskedThings) || (t.isRoofItem && ((this.room == null && !sourceBlock.tileType.IsFullBlock && !EMono._zone.IsPCFaction) || (lowBlock && !showFullWall && this.room != null) || (noRoofMode && currentRoom == null))) || (flag3 && !t.isRoofItem))
2742 {
2743 continue;
2744 }
2746 bool isInstalled = t.IsInstalled;
2747 SourcePref pref = t.Pref;
2748 if (!isInstalled && t.category.tileDummy != 0)
2749 {
2751 }
2752 float num27 = ((tileType.UseMountHeight && isInstalled) ? 0f : ((pref.height < 0f) ? 0f : ((pref.height == 0f) ? 0.1f : pref.height)));
2753 if (t.ignoreStackHeight)
2754 {
2755 thingPos.y -= num22;
2756 }
2757 shadow = thingPos.y < 0.16f && num25 < 0.16f;
2758 _ = pref.bypassShadow;
2759 param.shadowFix = 0f - thingPos.y;
2760 param.liquidLv = ((thingPos.y + (float)t.altitude < 0.1f) ? liquidLv : 0);
2761 if (t.isRoofItem)
2762 {
2763 param.snow = isSnowCovered && !this.cell.isClearSnow;
2764 SetRoofHeight(param, this.cell, cx, cz);
2765 _actorPos.x = param.x;
2766 _actorPos.y = param.y;
2767 _actorPos.z = param.z + num26;
2768 if (this.room != null)
2769 {
2770 param.color = GetRoofLight(this.room.lot);
2771 }
2772 shadow = false;
2773 param.liquidLv = 0;
2774 }
2775 else
2776 {
2777 param.snow = snowed;
2778 _actorPos.x = orgX + num23;
2779 _actorPos.y = orgY;
2780 _actorPos.z = orgZ + num26 + thingPos.z;
2781 if (tileType.CanStack || !isInstalled)
2782 {
2783 if (thing?.id != t.id)
2784 {
2785 _actorPos.x += thingPos.x;
2786 }
2787 _actorPos.y += thingPos.y;
2788 if (t.trait.IgnoreLastStackHeight && (thing == null || !thing.trait.IgnoreLastStackHeight))
2789 {
2790 thingPos.y -= num22;
2791 if (thing != null)
2792 {
2793 _actorPos.z -= 0.2f;
2794 thingPos.z -= 0.2f;
2795 }
2796 _actorPos.y -= num22;
2797 }
2798 _actorPos.z += renderSetting.thingZ + (float)m * -0.01f + zSetting.mod1 * thingPos.y;
2799 }
2800 if (isInstalled)
2801 {
2802 if (t.TileType.IsRamp)
2803 {
2804 Vector3 rampFix2 = t.TileType.GetRampFix(t.dir, pref);
2805 orgX += rampFix2.x;
2806 orgY += rampFix2.y;
2807 orgZ += rampFix2.z;
2808 freePos.x += rampFix2.x;
2809 freePos.y += rampFix2.y;
2810 freePos.z += rampFix2.z;
2811 if (!this.cell.IsTopWater || t.altitude > 0)
2812 {
2813 num25 += rampFix2.y;
2814 }
2815 liquidLv -= (int)(rampFix2.y * 150f);
2816 if (liquidLv < 0)
2817 {
2818 liquidLv = 0;
2819 }
2820 }
2821 else if (!flag11 && t.trait.IsChangeFloorHeight && !t.ignoreStackHeight)
2822 {
2823 orgY += num27 + (float)t.altitude * altitudeFix.y;
2824 orgZ += (float)t.altitude * altitudeFix.z;
2825 freePos.y += num27 + (float)t.altitude * altitudeFix.y;
2826 if (!this.cell.IsTopWater || t.altitude > 0)
2827 {
2828 num25 += num27 + (float)t.altitude * altitudeFix.y;
2829 }
2830 _actorPos.x += pref.x * (float)((!t.flipX) ? 1 : (-1));
2831 _actorPos.z += pref.z;
2832 thingPos.z += pref.z;
2833 liquidLv -= (int)(num27 * 150f);
2834 if (liquidLv < 0)
2835 {
2836 liquidLv = 0;
2837 }
2838 }
2839 else
2840 {
2841 thingPos.y += num27;
2842 _actorPos.x += pref.x * (float)((!t.flipX) ? 1 : (-1));
2843 _actorPos.z += pref.z;
2844 if (pref.height >= 0f)
2845 {
2846 thingPos.z += pref.z;
2847 }
2848 }
2849 if (!tileType.UseMountHeight && m > 10)
2850 {
2851 flag11 = true;
2852 }
2853 }
2854 else
2855 {
2856 thingPos.y += num27;
2857 _actorPos.x += pref.x * (float)((!t.flipX) ? 1 : (-1));
2858 _actorPos.z += pref.z;
2859 thingPos.z += pref.z;
2860 }
2861 if (t.isFloating && isWater && !hasBridge && !flag)
2862 {
2863 flag = true;
2864 float num28 = ((this.cell._bridge != 0) ? sourceBridge.tileType.FloorHeight : sourceFloor.tileType.FloorHeight);
2865 orgY += 0.01f * floatY - num28;
2866 num24 = num27;
2867 _actorPos.y += 0.01f * floatY - num28;
2868 if (liquidLv > 10)
2869 {
2870 liquidLv = TileType.FloorWaterShallow.LiquidLV * 10;
2871 }
2872 liquidLv -= (int)(floatY * 0.5f);
2873 if (liquidLv < 0)
2874 {
2875 liquidLv = 0;
2876 }
2877 param.liquidLv = liquidLv;
2878 }
2879 num22 = num27;
2880 if (t.sourceCard.multisize && !t.trait.IsGround)
2881 {
2882 num26 += zSetting.multiZ;
2883 }
2884 orgZ += t.renderer.data.stackZ;
2885 if (param.liquidLv > 0)
2886 {
2887 param.liquidLv += pref.liquidMod;
2888 if (param.liquidLv < 1)
2889 {
2890 param.liquidLv = 1;
2891 }
2892 else if (param.liquidLv > 99 + pref.liquidModMax)
2893 {
2894 param.liquidLv = 99 + pref.liquidModMax;
2895 }
2896 }
2897 }
2898 if (isInstalled && tileType.UseMountHeight)
2899 {
2900 if (tileType != TileType.Illumination || !this.cell.HasObj)
2901 {
2902 if (noRoofMode && currentRoom == null && t.altitude >= lowWallObjAltitude)
2903 {
2904 continue;
2905 }
2906 if (hideHang && (this.cell.room?.lot != currentLot || (!this.cell.lotWall && this.cell.room != currentRoom)))
2907 {
2908 Room room5 = ((t.dir == 0) ? this.cell.Back.room : this.cell.Left.room);
2910 {
2911 if (room5 == null || !room5.data.showWallItem)
2912 {
2913 continue;
2914 }
2915 }
2916 else if (t.altitude >= lowWallObjAltitude)
2917 {
2918 continue;
2919 }
2920 }
2921 }
2923 {
2924 flag10 = true;
2925 }
2927 shadow = false;
2928 param.liquidLv = 0;
2929 if (t.freePos)
2930 {
2931 _actorPos.x += t.fx;
2932 _actorPos.y += t.fy;
2933 }
2934 }
2935 else
2936 {
2937 if (t.altitude != 0)
2938 {
2940 if (t.altitude > 2 && ((this.cell.Back.room != null && this.cell.Back.IsRoomEdge) || (this.cell.Left.room != null && this.cell.Left.IsRoomEdge)) && hideHang && (this.cell.room?.lot != currentLot || (!this.cell.lotWall && this.cell.room != currentRoom)))
2941 {
2942 continue;
2943 }
2944 }
2945 if (t.freePos)
2946 {
2947 _actorPos.x = orgX + t.fx - freePos.x;
2948 _actorPos.y = orgY + t.fy - freePos.y;
2949 }
2950 if (t.trait is TraitDoor && (t.trait as TraitDoor).IsOpen())
2951 {
2952 _actorPos.z += -0.5f;
2953 }
2954 }
2955 if (!t.sourceCard.multisize || (t.pos.x == cx && t.pos.z == cz))
2956 {
2957 if (iconMode != 0)
2958 {
2959 int num29 = 0;
2960 switch (iconMode)
2961 {
2962 case CardIconMode.Visibility:
2963 if (t.isMasked)
2964 {
2965 num29 = 17;
2966 }
2967 break;
2968 case CardIconMode.State:
2969 if (t.placeState == PlaceState.installed)
2970 {
2971 num29 = 18;
2972 }
2973 break;
2974 case CardIconMode.Deconstruct:
2975 if (t.isDeconstructing)
2976 {
2977 num29 = 14;
2978 }
2979 break;
2980 }
2982 {
2983 num29 = 13;
2984 }
2985 if (num29 != 0)
2986 {
2987 passGuideBlock.Add(_actorPos.x, _actorPos.y, _actorPos.z - 10f, num29);
2988 }
2989 }
2991 if (_lowblock && t.trait.UseLowblock && !this.cell.HasFullBlock)
2992 {
2993 param.tile += ((param.tile < 0f) ? (-64) : 64);
2994 }
2995 if (t.trait is TraitTrolley && EMono.pc.ai is AI_Trolley aI_Trolley && aI_Trolley.trolley.owner == t)
2996 {
2997 RenderParam _param = new RenderParam(param);
2998 EMono.core.actionsLateUpdate.Add(delegate
2999 {
3000 t.SetRenderParam(_param);
3001 _actorPos.x = EMono.pc.renderer.position.x;
3002 _actorPos.y = EMono.pc.renderer.position.y - pref.height;
3003 _actorPos.z = EMono.pc.renderer.position.z + 0.02f;
3004 t.renderer.Draw(_param, ref _actorPos, !t.noShadow && (shadow || tileType.AlwaysShowShadow));
3005 });
3006 }
3007 else
3008 {
3009 t.renderer.Draw(param, ref _actorPos, !t.noShadow && (shadow || tileType.AlwaysShowShadow));
3010 }
3011 }
3012 if (isInstalled)
3013 {
3014 num23 += pref.stackX * (float)((!t.flipX) ? 1 : (-1));
3015 }
3016 param.x = orgX;
3017 param.y = orgY;
3018 param.z = orgZ;
3019 param.color = floorLight;
3020 thing = t;
3021 if (pref.Float)
3022 {
3023 liquidLv = 0;
3024 }
3025 }
3026 }
3027 orgY += num24;
3028 if (detail.charas.Count <= 0)
3029 {
3030 return;
3031 }
3032 param.shadowFix = 0f - num25;
3033 param.color += 1310720f;
3034 float max = zSetting.max2;
3035 for (int n = 0; n < detail.charas.Count; n++)
3036 {
3037 Chara chara = detail.charas[n];
3038 if (chara.host != null || (chara != EMono.pc && chara != LayerDrama.alwaysVisible && (flag3 || fogged || (!showAllCards && !EMono.player.CanSee(chara)))))
3039 {
3040 continue;
3041 }
3042 _actorPos.x = orgX;
3043 _actorPos.y = orgY;
3044 _actorPos.z = orgZ;
3045 chara.SetRenderParam(param);
3046 _ = chara.IsAliveInCurrentZone;
3047 if (chara.isRestrained)
3048 {
3049 TraitShackle restrainer = chara.GetRestrainer();
3050 if (restrainer != null)
3051 {
3052 Vector3 getRestrainPos = restrainer.GetRestrainPos;
3053 if (getRestrainPos != default(Vector3))
3054 {
3055 Vector3 position = restrainer.owner.renderer.position;
3056 float defCharaHeight = EMono.setting.render.defCharaHeight;
3057 float num30 = getRestrainPos.y + defCharaHeight - ((chara.Pref.height == 0f) ? defCharaHeight : chara.source.pref.height);
3058 _actorPos.x = position.x + getRestrainPos.x * (float)((restrainer.owner.dir % 2 == 0) ? 1 : (-1));
3059 _actorPos.y = position.y + num30;
3060 _actorPos.z = position.z + getRestrainPos.z;
3061 param.liquidLv = 0;
3062 param.shadowFix = orgY - _actorPos.y;
3063 chara.renderer.SetFirst(first: true);
3064 chara.renderer.Draw(param, ref _actorPos, drawShadow: true);
3065 param.shadowFix = 0f;
3066 continue;
3067 }
3068 }
3069 }
3070 if (!chara.sourceCard.multisize || (chara.pos.x == cx && chara.pos.z == cz))
3071 {
3072 if (chara.IsDeadOrSleeping && chara.IsPCC)
3073 {
3074 float num31 = chara.renderer.data.size.y * 0.3f;
3075 if (thingPos.y > max)
3076 {
3077 thingPos.y = max;
3078 }
3079 float num32 = thingPos.y + num31;
3080 float num33 = (float)n * -0.01f;
3081 if (num32 > zSetting.thresh1)
3082 {
3083 num33 = zSetting.mod1;
3084 }
3085 _actorPos.x += thingPos.x;
3086 _actorPos.y += thingPos.y;
3087 _actorPos.z += renderSetting.laydownZ + num33;
3088 param.liquidLv = ((thingPos.y == 0f && liquidLv > 0) ? 90 : 0);
3089 thingPos.y += num31 * 0.8f;
3090 chara.renderer.Draw(param, ref _actorPos, liquidLv == 0);
3091 }
3092 else
3093 {
3094 param.liquidLv = liquidLv;
3095 if (param.liquidLv > 0)
3096 {
3097 param.liquidLv += chara.Pref.liquidMod;
3098 if (param.liquidLv < 1)
3099 {
3100 param.liquidLv = 1;
3101 }
3102 else if (param.liquidLv > 99 + chara.Pref.liquidModMax)
3103 {
3104 param.liquidLv = 99 + chara.Pref.liquidModMax;
3105 }
3106 }
3107 if (!chara.IsPC && !chara.renderer.IsMoving && detail.charas.Count > 1 && (detail.charas.Count != 2 || !detail.charas[0].IsDeadOrSleeping || !detail.charas[0].IsPCC))
3108 {
3109 _actorPos += renderSetting.charaPos[1 + ((num21 < 4) ? num21 : 3)];
3110 }
3111 _actorPos.z += 0.01f * (float)n + renderSetting.charaZ;
3112 num21++;
3113 if (flag10)
3114 {
3115 _actorPos.z += chara.renderer.data.hangedFixZ;
3116 }
3117 chara.renderer.Draw(param, ref _actorPos, liquidLv == 0);
3118 }
3119 }
3120 param.x = orgX;
3121 param.y = orgY;
3122 param.z = orgZ;
3123 }
3124 return;
3125 IL_6f4f:
3126 if (!showRoof || !roof || this.cell.room == null || this.cell.Front.room == null || this.cell.Right.room == null)
3127 {
3128 param.tile = num14;
3130 }
3131 goto IL_6faf;
3132 void Draw(int tile)
3133 {
3134 pass = passEdge;
3137 batch.matrices[pass.idx].m03 = param.x + waterEdgeFixShoreSand.x;
3138 batch.matrices[pass.idx].m13 = param.y + waterEdgeFixShoreSand.y;
3139 batch.matrices[pass.idx].m23 = param.z + waterEdgeFixShoreSand.z;
3142 pass.idx++;
3143 if (pass.idx == pass.batchSize)
3144 {
3145 pass.NextBatch();
3146 }
3147 }
3148 }
3149
3150 public Vector3 GetThingPosition(Card tg, Point p)
3151 {
3152 Vector3 zero = Vector3.zero;
3153 float num = 0f;
3154 cell = p.cell;
3156 if (!tg.TileType.UseMountHeight)
3157 {
3159 {
3160 zero.z -= 1f;
3161 }
3162 else if (!tg.sourceCard.multisize)
3163 {
3164 float num2 = ((cell._bridge != 0) ? cell.sourceBridge.tileType.FloorHeight : sourceFloor.tileType.FloorHeight);
3165 zero.y += num2;
3166 zero.z -= num2 * heightMod.z;
3167 }
3168 if (cell.HasRamp)
3169 {
3170 Vector3 rampFix = cell.sourceBlock.tileType.GetRampFix(cell.blockDir);
3171 zero.x += rampFix.x;
3172 zero.y += rampFix.y;
3173 zero.z += rampFix.z;
3174 }
3175 }
3176 if (tg.sourceCard.multisize)
3177 {
3178 zero.z -= 1f;
3179 }
3180 zero.x += tg.Pref.x * (float)((!tg.flipX) ? 1 : (-1));
3181 zero.z += tg.Pref.z;
3182 detail = cell.detail;
3183 if (tg.isChara)
3184 {
3185 return zero;
3186 }
3187 bool flag = false;
3189 {
3190 flag = true;
3191 }
3193 {
3194 if (tg.altitude != 0)
3195 {
3196 zero += altitudeFix * tg.altitude;
3197 }
3198 flag = true;
3199 }
3201 {
3202 return zero;
3203 }
3204 float num3 = 0f;
3205 if (detail != null && detail.things.Count > 0)
3206 {
3207 Card card = null;
3208 for (int i = 0; i < detail.things.Count; i++)
3209 {
3210 Thing thing = detail.things[i];
3211 SourcePref pref = thing.Pref;
3213 float num4 = (tileType.UseMountHeight ? 0f : ((pref.height == 0f) ? 0.1f : pref.height));
3214 if (!thing.IsInstalled || thing == ActionMode.Inspect.target)
3215 {
3216 continue;
3217 }
3218 if (thing.TileType.IsRamp)
3219 {
3220 Vector3 rampFix2 = thing.TileType.GetRampFix(thing.dir, pref);
3221 zero.x += rampFix2.x;
3222 zero.y += rampFix2.y;
3223 zero.z += rampFix2.z;
3224 }
3225 if (!flag && tileType.CanStack)
3226 {
3227 if (thing.ignoreStackHeight)
3228 {
3229 zero.y -= num3;
3230 }
3231 zero.y += num4;
3232 zero.x += pref.stackX * (float)((!thing.flipX) ? 1 : (-1));
3233 zero.z += pref.z + thing.renderer.data.stackZ;
3234 if (!tileType.UseMountHeight && thing.altitude != 0)
3235 {
3236 zero += altitudeFix * thing.altitude;
3237 num4 += altitudeFix.y * (float)thing.altitude;
3238 }
3239 if (thing.trait.IgnoreLastStackHeight && (card == null || !card.trait.IgnoreLastStackHeight))
3240 {
3241 zero.y -= num3;
3242 }
3243 num3 = num4;
3244 zero.z += renderSetting.thingZ + num + (float)i * -0.01f + zSetting.mod1 * zero.y;
3245 if (thing.sourceCard.multisize)
3246 {
3247 num += zSetting.multiZ;
3248 }
3249 card = thing;
3250 }
3251 }
3252 }
3253 if (flag)
3254 {
3255 return zero;
3256 }
3257 if (tg.ignoreStackHeight)
3258 {
3259 zero.y -= num3;
3260 }
3261 if (tg.altitude != 0)
3262 {
3263 zero += altitudeFix * tg.altitude;
3264 }
3265 return zero;
3266 }
3267
3269 {
3270 float num = _baseBrightness + 0.05f;
3271 num = ((!cell.IsSnowTile) ? ((float)((int)(num * 50f) * 262144 + ((cell.lightR >= 64) ? 63 : cell.lightR) * 4096 + ((cell.lightG >= 64) ? 63 : cell.lightG) * 64 + ((cell.lightB >= 64) ? 63 : cell.lightB))) : ((float)((int)(num * 50f) * 262144 + (int)((float)((cell.lightR >= 50) ? 50 : cell.lightR) * snowColor) * 4096 + (int)((float)((cell.lightG >= 50) ? 50 : cell.lightG) * snowColor) * 64 + (int)((float)((cell.lightB >= 50) ? 50 : cell.lightB) * snowColor) + snowColorToken)));
3272 return (int)num;
3273 }
3274
3275 public int GetRoofLight(Lot lot)
3276 {
3277 float num = Mathf.Sqrt(lot.light) * roofLightMod;
3278 if (num > lightLimit * roofLightLimitMod)
3279 {
3281 }
3282 if (isSnowCovered)
3283 {
3284 num += roofLightSnow * (1f - nightRatio);
3285 }
3286 int num2 = (int)(num * 50f) * 262144;
3287 if (isSnowCovered)
3288 {
3289 num2 += snowColorToken;
3290 }
3291 return num2;
3292 }
3293
3294 public void DrawRoof(Lot lot)
3295 {
3296 RoofStyle roofStyle = roofStyles[lot.idRoofStyle];
3297 if (roofStyle.type == RoofStyle.Type.None)
3298 {
3299 return;
3300 }
3301 bool reverse = lot.reverse;
3302 int num;
3303 int num2;
3304 int num3;
3305 int num4;
3306 if (reverse)
3307 {
3308 num = lot.z - roofStyle.h;
3309 num2 = lot.x - roofStyle.w;
3310 num3 = lot.mz + 1 + roofStyle.h;
3311 num4 = lot.mx + 1 + roofStyle.w;
3312 if (num2 > 1 && num > 0 && map.cells[num2 - 1, num].HasFullBlock)
3313 {
3314 num2--;
3315 }
3316 if (num3 < Size && num4 < Size && map.cells[num4 - 1, num3].HasFullBlock)
3317 {
3318 num3++;
3319 }
3320 }
3321 else
3322 {
3323 num = lot.x - roofStyle.w;
3324 num2 = lot.z - roofStyle.h;
3325 num3 = lot.mx + 1 + roofStyle.w;
3326 num4 = lot.mz + 1 + roofStyle.h;
3327 if (num2 > 0 && num > 1 && map.cells[num - 1, num2].HasFullBlock)
3328 {
3329 num--;
3330 }
3331 if (num3 < Size && num4 < Size && map.cells[num3 - 1, num4].HasFullBlock)
3332 {
3333 num4++;
3334 }
3335 }
3336 int num5;
3337 if (roofStyle.wing)
3338 {
3339 num5 = ((lot.height > 1) ? 1 : 0);
3340 if (num5 != 0)
3341 {
3342 num2--;
3343 num4++;
3344 }
3345 }
3346 else
3347 {
3348 num5 = 0;
3349 }
3350 int num6 = num4 + (reverse ? roofStyle.w : roofStyle.h) * 2 - num2;
3351 int idRoofTile = lot.idRoofTile;
3352 int num7 = lot.idBlock;
3353 int num8 = num7;
3354 if (num7 >= EMono.sources.blocks.rows.Count)
3355 {
3356 num7 = EMono.sources.blocks.rows.Count - 1;
3357 }
3358 if (num8 >= EMono.sources.floors.rows.Count)
3359 {
3360 num8 = EMono.sources.floors.rows.Count - 1;
3361 }
3362 int num9 = lot.idRamp;
3363 if (num9 >= EMono.sources.blocks.rows.Count)
3364 {
3365 num9 = EMono.sources.blocks.rows.Count - 1;
3366 }
3367 bool flag = false;
3368 int num10 = num6 / 2 - roofStyle.flatW;
3369 int num11 = num6 / 2 + roofStyle.flatW + ((num6 % 2 != 0) ? 1 : 0);
3370 SourceBlock.Row row = (roofStyle.useDefBlock ? cell.sourceFloor._defBlock : EMono.sources.blocks.rows[num7]);
3371 int num12 = 0;
3372 int num13 = ((num5 != 0) ? (-1) : 0);
3373 int num14 = 0;
3374 Vector3 vector = (lot.fullblock ? roofStyle.posFixBlock : roofStyle.posFix);
3375 switch (roofStyle.type)
3376 {
3377 case RoofStyle.Type.Default:
3378 flag = num6 % 2 == 1 && roofStyle.flatW == 0;
3379 break;
3380 case RoofStyle.Type.Flat:
3381 case RoofStyle.Type.FlatFloor:
3382 num10 = roofStyle.flatW;
3383 num11 = num6 - roofStyle.flatW;
3384 if (num10 == 0)
3385 {
3386 num14 = 1;
3387 }
3388 if (roofStyle.type != RoofStyle.Type.FlatFloor)
3389 {
3390 num--;
3391 num3++;
3392 num2--;
3393 num4++;
3394 }
3395 break;
3396 case RoofStyle.Type.Triangle:
3397 num10 = 999;
3398 num11 = 999;
3399 break;
3400 }
3401 for (cz = num2; cz < num4; cz++)
3402 {
3403 for (cx = num; cx < num3; cx++)
3404 {
3405 if (cx < 0 || cz < 0 || cx >= Size || cz >= Size)
3406 {
3407 continue;
3408 }
3409 int num15;
3410 int num16;
3411 if (reverse)
3412 {
3413 num15 = cz;
3414 num16 = cx;
3415 cell = map.cells[num15, num16];
3416 if (roofStyle.wing && cz == num4 - 1 && cell.Right.Right.room != null && cell.Right.Right.room.lot != lot)
3417 {
3418 continue;
3419 }
3420 }
3421 else
3422 {
3423 num15 = cx;
3424 num16 = cz;
3425 cell = map.cells[num15, num16];
3426 if (roofStyle.wing && cz == 0 && cell.Front.Front.room != null && cell.Front.Front.room.lot != lot)
3427 {
3428 continue;
3429 }
3430 }
3431 int num17 = num16 - num15;
3432 room = cell.room;
3433 if (room != null && room.lot != lot)
3434 {
3435 continue;
3436 }
3437 bool flag2 = false;
3438 if (roofStyle.type == RoofStyle.Type.Flat)
3439 {
3440 if (reverse)
3441 {
3442 if (!cell.HasFullBlock || cell.room != null)
3443 {
3444 num14 = ((cell.Left.room != null && cell.Left.room.lot == lot) ? ((cell.Right.room != null && cell.Right.room.lot == lot) ? 1 : ((cell.HasFullBlock && cell.Right.HasFullBlock && cell.Right.room != null) ? 1 : 2)) : (cell.Left.HasFullBlock ? 1 : 0));
3445 }
3446 else if (cell.Left.room?.lot == lot && cell.Right.room != null)
3447 {
3448 num14 = 1;
3449 flag2 = true;
3450 }
3451 else if (cell.Front.room?.lot == lot)
3452 {
3453 num14 = ((cell.FrontRight.room?.lot == lot) ? 1 : 2);
3454 flag2 = true;
3455 }
3456 else if (cell.Right.room?.lot == lot || cell.FrontRight.room?.lot == lot)
3457 {
3458 num14 = 0;
3459 flag2 = true;
3460 }
3461 }
3462 else if (!cell.HasFullBlock || cell.room != null)
3463 {
3464 num14 = ((cell.Front.room != null && cell.Front.room.lot == lot) ? ((cell.Back.room != null && cell.Back.room.lot == lot) ? 1 : (cell.Back.HasFullBlock ? 1 : 2)) : ((cell.HasFullBlock && cell.Front.HasFullBlock && cell.Front.room != null) ? 1 : 0));
3465 }
3466 else if (cell.Right.room?.lot == lot)
3467 {
3468 num14 = ((cell.FrontRight.room?.lot == lot) ? 1 : 0);
3469 flag2 = true;
3470 }
3471 else if (cell.Front.room?.lot == lot || cell.FrontRight.room?.lot == lot)
3472 {
3473 num14 = 2;
3474 flag2 = true;
3475 }
3476 num13 = 0;
3477 }
3478 bool flag3 = isSnowCovered && !cell.isClearSnow;
3479 if (room == null && !roofStyle.coverLot && !flag2 && !(cell.HasFullBlock && cell.IsRoomEdge && flag3))
3480 {
3481 continue;
3482 }
3483 index = cx + cz * Size;
3485 float num18 = (float)num17 * screen.tileAlign.y + (float)lot.mh * _heightMod.y + lot.realHeight + roofFix.y + vector.y;
3486 float num19 = 1000f + param.x * screen.tileWeight.x + (float)lot.mh * _heightMod.z + lot.realHeight * roofFix3.z + roofFix.z + vector.z;
3487 if (lot.height == 1 && lot.heightFix < 20)
3488 {
3489 num18 += roofStyle.lowRoofFix.y;
3490 num19 += roofStyle.lowRoofFix.z;
3491 }
3492 param.x = (float)(cx + cz) * screen.tileAlign.x + roofFix.x + (float)num13 * roofFix2.x + vector.x * (float)(reverse ? 1 : (-1));
3493 param.y = num18 + (float)num13 * roofFix2.y;
3494 param.z = num19 + param.y * screen.tileWeight.z + (float)num13 * roofFix2.z;
3495 param.color = GetRoofLight(lot);
3496 param.snow = idRoofTile == 0 && flag3;
3497 param.shadowFix = 0f;
3498 if (num14 == 1)
3499 {
3501 RenderRow renderRow;
3502 if (roofStyle.type == RoofStyle.Type.FlatFloor)
3503 {
3504 if (cell.HasFullBlock && cell.IsRoomEdge && !flag3)
3505 {
3506 continue;
3507 }
3508 renderRow = EMono.sources.floors.rows[num8];
3509 renderRow.SetRenderParam(param, mat, 0);
3510 param.matColor = lot.colRoof;
3511 }
3512 else
3513 {
3514 renderRow = row;
3515 renderRow.SetRenderParam(param, mat, 0);
3516 param.matColor = lot.colBlock;
3517 }
3518 renderRow.renderData.Draw(param);
3519 if (idRoofTile != 0)
3520 {
3521 renderRow = EMono.sources.blocks.rows[EMono.sources.objs.rows[idRoofTile].idRoof];
3522 int num20 = (reverse ? 1 : 0) + ((!flag) ? 2 : 0);
3523 renderRow.SetRenderParam(param, MATERIAL.sourceGold, num20);
3524 param.matColor = lot.colRoof;
3525 if (roofStyle.type == RoofStyle.Type.FlatFloor)
3526 {
3527 param.x += roofStyle.posFixBlock.x;
3528 param.y += roofStyle.posFixBlock.y;
3529 param.z += roofStyle.posFixBlock.z;
3530 }
3531 if (!flag)
3532 {
3533 param.z += 0.5f;
3534 }
3535 if (flag3)
3536 {
3537 param.matColor = 104025f;
3538 if (roofStyle.type != RoofStyle.Type.FlatFloor)
3539 {
3540 param.z += roofStyle.snowZ;
3541 }
3542 param.tile = renderRow.renderData.ConvertTile(renderRow.snowTile) + num20;
3543 renderRow.renderData.Draw(param);
3544 }
3545 else
3546 {
3547 renderRow.renderData.Draw(param);
3548 }
3549 }
3550 else if (flag3 && roofStyle.type == RoofStyle.Type.FlatFloor)
3551 {
3552 param.matColor = 104025f;
3553 param.tile = 10f;
3554 param.x += roofStyle.snowFix.x;
3555 param.y += roofStyle.snowFix.y;
3556 param.z += roofStyle.snowZ + roofStyle.snowFix.z;
3557 renderRow.renderData.Draw(param);
3558 }
3559 }
3560 else
3561 {
3562 if (idRoofTile != 0)
3563 {
3564 int num21 = ((!reverse) ? ((num14 != 0) ? 2 : 0) : ((num14 != 0) ? 1 : 3));
3565 if (lot.altRoof && !flag && (roofStyle.type == RoofStyle.Type.Default || roofStyle.type == RoofStyle.Type.DefaultNoTop))
3566 {
3567 param.shadowFix = num21 + 1;
3568 }
3569 RenderRow renderRow = EMono.sources.objs.rows[idRoofTile];
3570 renderRow.SetRenderParam(param, MATERIAL.sourceGold, num21);
3571 param.matColor = lot.colRoof;
3572 if (flag3)
3573 {
3574 param.matColor = 104025f;
3575 param.z += roofStyle.snowZ;
3576 param.tile = renderRow.renderData.ConvertTile(renderRow.snowTile) + num21 + (lot.altRoof ? 8 : 0);
3577 renderRow.renderData.Draw(param);
3578 }
3579 else
3580 {
3581 param.tile += (lot.altRoof ? 8 : 0);
3582 renderRow.renderData.Draw(param);
3583 }
3584 param.shadowFix = 0f;
3585 }
3586 if (num13 >= 0)
3587 {
3588 param.y += roofRampFix.y;
3589 param.z += roofRampFix.z;
3590 RenderRow renderRow = EMono.sources.blocks.rows[num9];
3591 renderRow.SetRenderParam(param, MATERIAL.sourceGold, (!reverse) ? ((num14 != 0) ? 2 : 0) : ((num14 != 0) ? 1 : 3));
3592 param.matColor = lot.colBlock;
3593 renderRow.renderData.Draw(param);
3594 }
3595 }
3596 CellEffect effect = cell.effect;
3597 if (effect != null && effect.FireAmount > 0)
3598 {
3600 }
3601 if (num13 < 1)
3602 {
3603 continue;
3604 }
3605 if (roofStyle.type != RoofStyle.Type.Flat)
3606 {
3607 param.snow = false;
3608 }
3609 for (int i = 0; i < num13; i++)
3610 {
3611 param.x = (float)(cx + cz) * screen.tileAlign.x + roofFix.x + (float)i * roofFix2.x + vector.x * (float)(reverse ? 1 : (-1));
3612 param.y = num18 + (float)i * roofFix2.y;
3613 param.z = num19 + param.y * screen.tileWeight.z + (float)i * roofFix2.z;
3614 RenderRow renderRow = row;
3615 renderRow.SetRenderParam(param, MATERIAL.sourceGold, 0);
3616 param.matColor = lot.colBlock;
3617 renderRow.renderData.Draw(param);
3618 index++;
3619 CellEffect effect2 = cell.effect;
3620 if (effect2 != null && effect2.FireAmount > 0 && Rand.bytes[index % Rand.MaxBytes] % 3 == 0)
3621 {
3623 }
3624 }
3625 }
3626 num12++;
3627 if (roofStyle.type != RoofStyle.Type.Flat)
3628 {
3629 if (num12 == num10)
3630 {
3631 num14 = 1;
3632 }
3633 if (num12 == num11)
3634 {
3635 num14 = 2;
3636 num13++;
3637 }
3638 num13 += num14 switch
3639 {
3640 1 => 0,
3641 0 => 1,
3642 _ => -1,
3643 };
3644 }
3645 }
3646 }
3647
3648 public static int GetColorInt(ref Color matColor, int p)
3649 {
3650 if (p == 0)
3651 {
3652 return 104025;
3653 }
3654 return p * 262144 + (int)(matColor.r * 50f) * 4096 + (int)(matColor.g * 50f) * 64 + (int)(matColor.b * 50f);
3655 }
3656
3657 public void SetRoofHeight(MeshPassParam _param, Cell _cell, int _cx, int _cz, int h = 0, int altitude = 0, int dirWall = -1, bool ignoreAltitudeY = false)
3658 {
3659 Room room = _cell.room;
3660 if (room == null && dirWall != -1)
3661 {
3662 if (dirWall == 0 && _cell.Front.room != null)
3663 {
3664 room = _cell.Front.room;
3665 _cell = _cell.Front;
3666 }
3667 else if (_cell.Right.room != null)
3668 {
3669 room = _cell.Right.room;
3670 _cell = _cell.Right;
3671 }
3672 }
3673 if (room != null)
3674 {
3675 Lot lot = room.lot;
3676 RoofStyle roofStyle = roofStyles[lot.idRoofStyle];
3677 float num = (float)(_cz - _cx) * screen.tileAlign.y + (float)lot.mh * _heightMod.y + lot.realHeight + roofFix.y;
3678 float num2 = 1000f + param.x * screen.tileWeight.x + (float)lot.mh * _heightMod.z + lot.realHeight * roofFix3.z + roofFix.z + roofStyle.posFix.z;
3679 if (lot.height == 1)
3680 {
3681 num += roofStyle.lowRoofFix.y;
3682 num2 += roofStyle.lowRoofFix.z;
3683 }
3684 _param.x = (float)(_cx + _cz) * screen.tileAlign.x + roofFix.x + (float)h * roofFix2.x;
3685 _param.y = num + (float)h * roofFix2.y;
3686 _param.z = num2 + _param.y * screen.tileWeight.z + (float)h * roofFix2.z + heightModRoofBlock.y;
3687 }
3688 if (!ignoreAltitudeY || room != null)
3689 {
3690 _param.y += (float)altitude * _heightMod.y;
3691 }
3692 _param.z += (float)altitude * heightModRoofBlock.z;
3693 }
3694}
AreaHighlightMode
BlockRenderMode
PlaceState
Definition: PlaceState.cs:2
if(item3.idFile==idFirstFile &&item3.id==idFirstTopic)
Definition: UIBook.cs:627
TraitTrolley trolley
Definition: AI_Trolley.cs:23
SceneProfile profile
Definition: AM_Cinema.cs:5
static AM_Inspect Inspect
Definition: ActionMode.cs:23
virtual bool IsRoofEditMode(Card c=null)
Definition: ActionMode.cs:311
static bool IsAdv
Definition: ActionMode.cs:117
static AM_ViewMap ViewMap
Definition: ActionMode.cs:63
virtual BaseTileMap.CardIconMode cardIconMode
Definition: ActionMode.cs:229
virtual bool ShowMaskedThings
Definition: ActionMode.cs:221
bool IsActive
Definition: ActionMode.cs:121
static AM_FlagCell FlagCell
Definition: ActionMode.cs:77
virtual bool IsBuildMode
Definition: ActionMode.cs:181
static AM_Cinema Cinema
Definition: ActionMode.cs:73
static AM_Bird Bird
Definition: ActionMode.cs:31
static AM_Mine Mine
Definition: ActionMode.cs:33
bool showWallItem
Definition: AreaData.cs:54
bool atrium
Definition: AreaData.cs:66
int maxHeight
Definition: AreaData.cs:30
virtual byte GetTile(int index)
Definition: Area.cs:75
AreaData data
Definition: BaseArea.cs:29
List< Action > actionsLateUpdate
Definition: BaseCore.cs:29
ScreenGuide guide
Vector3 tileWeight
BaseTileSelector tileSelector
virtual void RefreshWeather()
MeshPass passArea
Definition: BaseTileMap.cs:141
Vector3 roofFix2
Definition: BaseTileMap.cs:75
MeshPass passFog
Definition: BaseTileMap.cs:169
Vector3 cornerWallFix
Definition: BaseTileMap.cs:96
const int BlocklightToken
Definition: BaseTileMap.cs:504
float maxHeight
Definition: BaseTileMap.cs:396
MeshPass passFloor
Definition: BaseTileMap.cs:145
virtual void Draw()
Definition: BaseTileMap.cs:533
int GetRoofLight(Lot lot)
MeshPass passIcon
Definition: BaseTileMap.cs:185
int floorMatColor
Definition: BaseTileMap.cs:438
RenderData rendererInnerBlock
Definition: BaseTileMap.cs:203
Vector3[] wallHangFix
Definition: BaseTileMap.cs:116
float heightModDeco
Definition: BaseTileMap.cs:52
SourceFloor.Row sourceBridge
Definition: BaseTileMap.cs:482
Collider2D mouseCollider
Definition: BaseTileMap.cs:41
MeshPass passFloorEx
Definition: BaseTileMap.cs:163
float blockLight
Definition: BaseTileMap.cs:378
MeshPass passObj
Definition: BaseTileMap.cs:153
bool showAllCards
Definition: BaseTileMap.cs:454
Vector3 roofFix3
Definition: BaseTileMap.cs:77
bool highlightArea
Definition: BaseTileMap.cs:275
int maxColliderCheck
Definition: BaseTileMap.cs:45
float slopeFixZ
Definition: BaseTileMap.cs:50
InnerMode defaultInnerMode
Definition: BaseTileMap.cs:90
Point HitPoint
Definition: BaseTileMap.cs:508
Vector3 cornerWallFix2
Definition: BaseTileMap.cs:98
ScreenHighlight screenHighlight
Definition: BaseTileMap.cs:332
SourceMaterial.Row matBridge
Definition: BaseTileMap.cs:376
MeshPass passFloorMarker
Definition: BaseTileMap.cs:181
byte[] groundLights
Definition: BaseTileMap.cs:266
RenderData rendererFogRoomSolid
Definition: BaseTileMap.cs:217
float snowLight
Definition: BaseTileMap.cs:398
const int BlocklightMTP
Definition: BaseTileMap.cs:506
InnerMode innerMode
Definition: BaseTileMap.cs:233
MeshPass passChara
Definition: BaseTileMap.cs:187
float modSublight2
Definition: BaseTileMap.cs:410
MeshPass passRamp
Definition: BaseTileMap.cs:143
RenderData rendererWaterBlock
Definition: BaseTileMap.cs:225
Vector3 waterEdgeFixShoreSand
Definition: BaseTileMap.cs:110
int GetApproximateBlocklight(Cell cell)
MeshPass passGuideBlock
Definition: BaseTileMap.cs:137
float waterAnimeTimer
Definition: BaseTileMap.cs:400
MeshPass passShadow
Definition: BaseTileMap.cs:133
bool showBorder
Definition: BaseTileMap.cs:468
bool isSnowCovered
Definition: BaseTileMap.cs:460
float floatY
Definition: BaseTileMap.cs:323
int lowWallObjAltitude
Definition: BaseTileMap.cs:370
RenderData renderBorder
Definition: BaseTileMap.cs:211
bool cinemaMode
Definition: BaseTileMap.cs:464
bool alwaysLowblock
Definition: BaseTileMap.cs:466
Vector3 waterEdgeFixShore
Definition: BaseTileMap.cs:108
bool hideRoomFog
Definition: BaseTileMap.cs:281
static int GetColorInt(ref Color matColor, int p)
float _lightMod
Definition: BaseTileMap.cs:305
Vector3 roofRampFix
Definition: BaseTileMap.cs:71
float[] lightLookUp
Definition: BaseTileMap.cs:302
TileType tileType
Definition: BaseTileMap.cs:494
float lightLimit
Definition: BaseTileMap.cs:406
int snowColorToken
Definition: BaseTileMap.cs:366
float modSublight1
Definition: BaseTileMap.cs:408
bool showFullWall
Definition: BaseTileMap.cs:287
SceneLightProfile lightSetting
Definition: BaseTileMap.cs:496
const int DefColor
Definition: BaseTileMap.cs:502
void OnActivate(BaseGameScreen _screen)
Definition: BaseTileMap.cs:510
bool fogBounds
Definition: BaseTileMap.cs:456
RenderParam param
Definition: BaseTileMap.cs:428
Vector3 ugFix
Definition: BaseTileMap.cs:58
float floorLight
Definition: BaseTileMap.cs:380
MeshPass passWaterBlock
Definition: BaseTileMap.cs:183
float lotLight2
Definition: BaseTileMap.cs:83
bool noRoofMode
Definition: BaseTileMap.cs:296
MeshPass passAutoTileWater
Definition: BaseTileMap.cs:177
new BaseGameScreen screen
Definition: BaseTileMap.cs:348
RenderData rendererFov
Definition: BaseTileMap.cs:205
WallClipMode wallClipMode
Definition: BaseTileMap.cs:88
Vector3 edgeBlockFix
Definition: BaseTileMap.cs:92
MeshPass passFov
Definition: BaseTileMap.cs:171
Vector3 heightMod
Definition: BaseTileMap.cs:56
bool usingHouseBoard
Definition: BaseTileMap.cs:293
Vector3 altitudeFix
Definition: BaseTileMap.cs:102
Vector3 thingPos
Definition: BaseTileMap.cs:470
MeshPass passDecal
Definition: BaseTileMap.cs:157
float floorShadowStrength
Definition: BaseTileMap.cs:326
RenderData rendererFov2
Definition: BaseTileMap.cs:207
Vector3[] transitionFix
Definition: BaseTileMap.cs:114
float _baseBrightness
Definition: BaseTileMap.cs:308
Vector3 waterEdgeFix
Definition: BaseTileMap.cs:104
virtual void DrawTile()
Definition: BaseTileMap.cs:900
void RefreshHeight()
Definition: BaseTileMap.cs:888
Room currentRoom
Definition: BaseTileMap.cs:484
bool noSlopMode
Definition: BaseTileMap.cs:498
MeshPass passFloorWater
Definition: BaseTileMap.cs:165
float rightWallShade
Definition: BaseTileMap.cs:69
RenderData rendererFloorMarker
Definition: BaseTileMap.cs:201
float lotLight
Definition: BaseTileMap.cs:81
Vector3 _actorPos
Definition: BaseTileMap.cs:432
GameSetting.RenderSetting renderSetting
Definition: BaseTileMap.cs:356
MeshPass passAutoTile
Definition: BaseTileMap.cs:175
Vector3 _heightMod
Definition: BaseTileMap.cs:329
float _shadowStrength
Definition: BaseTileMap.cs:414
float floatTimer
Definition: BaseTileMap.cs:402
float pcMaxLight
Definition: BaseTileMap.cs:386
float lowblockTimer
Definition: BaseTileMap.cs:311
RenderData rendererShore
Definition: BaseTileMap.cs:209
Vector3 bridgeFix
Definition: BaseTileMap.cs:94
Vector3 orgPos
Definition: BaseTileMap.cs:472
void DrawRoof(Lot lot)
float _rightWallShade
Definition: BaseTileMap.cs:317
float snowLimit
Definition: BaseTileMap.cs:420
float fogBrightness
Definition: BaseTileMap.cs:416
float floatSpeed
Definition: BaseTileMap.cs:122
Vector3 ugFixBridgeBottom
Definition: BaseTileMap.cs:62
SourceMaterial.Row matBlock
Definition: BaseTileMap.cs:372
RenderDataEffect rendererEffect
Definition: BaseTileMap.cs:229
bool hasBridge
Definition: BaseTileMap.cs:342
float nightRatio
Definition: BaseTileMap.cs:426
SourceBlock.Row _sourceBlock
Definition: BaseTileMap.cs:492
float heightBlockSize
Definition: BaseTileMap.cs:48
float destBrightness
Definition: BaseTileMap.cs:404
bool buildMode
Definition: BaseTileMap.cs:340
RenderData renderFootmark
Definition: BaseTileMap.cs:197
Vector3[] waterEdgeBlockFix
Definition: BaseTileMap.cs:118
Vector3 roofFix
Definition: BaseTileMap.cs:73
Vector3 freePos
Definition: BaseTileMap.cs:434
float defaultBlockHeight
Definition: BaseTileMap.cs:418
bool subtleHighlightArea
Definition: BaseTileMap.cs:278
MeshPass passGuideFloor
Definition: BaseTileMap.cs:139
MeshBatch batch
Definition: BaseTileMap.cs:430
MeshPass passEdge
Definition: BaseTileMap.cs:173
Vector3 ugFixBridgeTop
Definition: BaseTileMap.cs:64
RenderData rendererBlockMarker
Definition: BaseTileMap.cs:199
Point TestPoint
Definition: BaseTileMap.cs:231
MeshPass passCharaL
Definition: BaseTileMap.cs:189
MeshPass passLiquid
Definition: BaseTileMap.cs:135
float snowColor2
Definition: BaseTileMap.cs:424
Vector3[] ambientShadowFix
Definition: BaseTileMap.cs:112
float heightLimitDeco
Definition: BaseTileMap.cs:54
float heightLightMod
Definition: BaseTileMap.cs:314
MeshPass passObjSS
Definition: BaseTileMap.cs:151
float shadowModStrength
Definition: BaseTileMap.cs:124
RenderData rendererFogRoomBlockSolid
Definition: BaseTileMap.cs:219
MeshPass passShore
Definition: BaseTileMap.cs:195
float snowColor
Definition: BaseTileMap.cs:422
SourceMaterial.Row matFloor
Definition: BaseTileMap.cs:374
bool highlightCells
Definition: BaseTileMap.cs:462
float roofLightSnow
Definition: BaseTileMap.cs:85
Vector3 ugFixBridge
Definition: BaseTileMap.cs:60
Vector3 cornerWallFix3
Definition: BaseTileMap.cs:100
RenderData rendererWallDeco
Definition: BaseTileMap.cs:223
MeshPass passRoof
Definition: BaseTileMap.cs:159
CellDetail detail
Definition: BaseTileMap.cs:476
RaycastHit2D[] rays
Definition: BaseTileMap.cs:334
MeshPass passCharaLL
Definition: BaseTileMap.cs:193
SourceBlock.Row sourceBlock
Definition: BaseTileMap.cs:478
int[] seaAnimeIndexes
Definition: BaseTileMap.cs:128
MeshPass passCharaLW
Definition: BaseTileMap.cs:191
Vector3 waterEdgeBridgeFix
Definition: BaseTileMap.cs:106
float roofLightMod
Definition: BaseTileMap.cs:79
RenderData rendererFogRoomWallSolid
Definition: BaseTileMap.cs:221
RoofStyle[] roofStyles
Definition: BaseTileMap.cs:500
MeshPass passObjL
Definition: BaseTileMap.cs:155
RenderData rendererFogFloorSolid
Definition: BaseTileMap.cs:215
int waterAnimeIndex
Definition: BaseTileMap.cs:368
float roomHeight
Definition: BaseTileMap.cs:394
MeshPass passBlockMarker
Definition: BaseTileMap.cs:179
Vector3 colliderFix
Definition: BaseTileMap.cs:43
void SetRoofHeight(MeshPassParam _param, Cell _cell, int _cx, int _cz, int h=0, int altitude=0, int dirWall=-1, bool ignoreAltitudeY=false)
static bool forceShowHang
Definition: BaseTileMap.cs:36
RenderDataObjDummy rendererObjDummy
Definition: BaseTileMap.cs:227
BaseTileSelector selector
Definition: BaseTileMap.cs:354
MeshPass passObjS
Definition: BaseTileMap.cs:149
Vector3 heightModRoofBlock
Definition: BaseTileMap.cs:66
NoiseLayer layerGroundLights
Definition: BaseTileMap.cs:131
RenderData rendererFogBlockSolid
Definition: BaseTileMap.cs:213
float roofLightLimitMod
Definition: BaseTileMap.cs:320
GameSetting.RenderSetting.ZSetting zSetting
Definition: BaseTileMap.cs:358
MeshPass pass
Definition: BaseTileMap.cs:352
float shadowStrength
Definition: BaseTileMap.cs:412
bool _lowblock
Definition: BaseTileMap.cs:344
MeshPass passInner
Definition: BaseTileMap.cs:167
MeshPass passBlockEx
Definition: BaseTileMap.cs:161
SourceFloor.Row sourceFloor
Definition: BaseTileMap.cs:480
MeshPass passBlock
Definition: BaseTileMap.cs:147
CardIconMode iconMode
Definition: BaseTileMap.cs:336
float floorLight2
Definition: BaseTileMap.cs:382
Vector3 GetThingPosition(Card tg, Point p)
int currentHeight
Definition: BaseTileMap.cs:442
bool pressing
Definition: ButtonState.cs:35
ScreenGrading grading
override void Draw(RenderParam p)
Definition: CardRenderer.cs:49
Vector3 position
Definition: CardRenderer.cs:21
virtual bool IsMoving
Definition: CardRenderer.cs:31
virtual void SetFirst(bool first, Vector3 pos)
Definition: Card.cs:11
bool isMasked
Definition: Card.cs:562
string id
Definition: Card.cs:31
bool isNPCProperty
Definition: Card.cs:526
bool isFloating
Definition: Card.cs:622
bool isRoofItem
Definition: Card.cs:550
bool isRestrained
Definition: Card.cs:538
float fy
Definition: Card.cs:250
float fx
Definition: Card.cs:238
PlaceState placeState
Definition: Card.cs:79
TileType TileType
Definition: Card.cs:2011
virtual SourcePref Pref
Definition: Card.cs:1983
Point pos
Definition: Card.cs:55
Trait trait
Definition: Card.cs:49
int altitude
Definition: Card.cs:214
bool isDeconstructing
Definition: Card.cs:418
bool IsInstalled
Definition: Card.cs:2241
virtual bool isChara
Definition: Card.cs:1959
TraitShackle GetRestrainer()
Definition: Card.cs:6329
int dir
Definition: Card.cs:142
virtual CardRow sourceCard
Definition: Card.cs:2007
bool noShadow
Definition: Card.cs:790
SourceCategory.Row category
Definition: Card.cs:1925
bool freePos
Definition: Card.cs:490
CardRenderer renderer
Definition: Card.cs:57
virtual bool flipX
Definition: Card.cs:1992
bool ignoreStackHeight
Definition: Card.cs:610
TaskDesignation designation
Definition: CellDetail.cs:19
List< Thing > things
Definition: CellDetail.cs:11
TransAnime anime
Definition: CellDetail.cs:21
List< Chara > charas
Definition: CellDetail.cs:13
Area area
Definition: CellDetail.cs:15
Footmark footmark
Definition: CellDetail.cs:17
int FireAmount
Definition: CellEffect.cs:150
bool IsFire
Definition: CellEffect.cs:135
bool IsLiquid
Definition: CellEffect.cs:138
SourceCellEffect.Row source
Definition: CellEffect.cs:133
Definition: Cell.cs:7
byte _block
Definition: Cell.cs:30
Room room
Definition: Cell.cs:102
byte TopHeight
Definition: Cell.cs:117
bool HasWallOrFence
Definition: Cell.cs:831
static List< SourceBlock.Row > blockList
Definition: Cell.cs:14
SourceBlock.Row sourceBlock
Definition: Cell.cs:1052
Cell BackRight
Definition: Cell.cs:201
bool lotShade
Definition: Cell.cs:534
bool IsSnowTile
Definition: Cell.cs:782
bool castFloorShadow
Definition: Cell.cs:522
SourceMaterial.Row matBlock
Definition: Cell.cs:1030
byte autotile
Definition: Cell.cs:62
bool HasBlock
Definition: Cell.cs:643
byte shadow
Definition: Cell.cs:70
SourceFloor.Row sourceFloor
Definition: Cell.cs:1054
CellEffect effect
Definition: Cell.cs:94
byte _bridge
Definition: Cell.cs:46
bool isDeck
Definition: Cell.cs:510
Cell Back
Definition: Cell.cs:153
bool lotWall
Definition: Cell.cs:486
bool IsBridgeWater
Definition: Cell.cs:770
byte decal
Definition: Cell.cs:44
Critter critter
Definition: Cell.cs:96
bool isClearSnow
Definition: Cell.cs:450
bool isFloating
Definition: Cell.cs:474
Cell Front
Definition: Cell.cs:129
SourceMaterial.Row matObj
Definition: Cell.cs:1036
List< Thing > Things
Definition: Cell.cs:986
SourceMaterial.Row matBridge
Definition: Cell.cs:1034
bool IsFloorWater
Definition: Cell.cs:727
bool pcSync
Definition: Cell.cs:104
bool UseLowBlock
Definition: Cell.cs:861
byte shore
Definition: Cell.cs:68
bool skipRender
Definition: Cell.cs:270
ushort lightG
Definition: Cell.cs:88
byte _roofBlock
Definition: Cell.cs:50
bool IsTopWater
Definition: Cell.cs:700
byte height
Definition: Cell.cs:72
byte autotileObj
Definition: Cell.cs:66
GrowSystem growth
Definition: Cell.cs:225
ushort lightB
Definition: Cell.cs:90
bool isWatered
Definition: Cell.cs:342
SourceFloor.Row sourceBridge
Definition: Cell.cs:1056
bool isClearArea
Definition: Cell.cs:606
CellDetail detail
Definition: Cell.cs:92
bool isShadowed
Definition: Cell.cs:246
byte _roofBlockDir
Definition: Cell.cs:54
bool HasFloodBlock
Definition: Cell.cs:1017
byte autotileBridge
Definition: Cell.cs:64
bool isToggleWallPillar
Definition: Cell.cs:558
bool HasRoof
Definition: Cell.cs:648
Cell Left
Definition: Cell.cs:165
bool isSkyFloor
Definition: Cell.cs:594
SourceMaterial.Row matFloor
Definition: Cell.cs:1032
int floorDir
Definition: Cell.cs:922
byte _roofBlockMat
Definition: Cell.cs:52
bool isSeen
Definition: Cell.cs:282
byte obj
Definition: Cell.cs:38
bool isSlopeEdge
Definition: Cell.cs:354
bool isShoreSand
Definition: Cell.cs:546
SourceObj.Row sourceObj
Definition: Cell.cs:1072
byte highlight
Definition: Cell.cs:84
int objDir
Definition: Cell.cs:910
Cell BackLeft
Definition: Cell.cs:213
bool isForceFloat
Definition: Cell.cs:306
SourceCellEffect.Row sourceEffect
Definition: Cell.cs:1070
bool isSurrounded
Definition: Cell.cs:234
bool isWallEdge
Definition: Cell.cs:426
bool outOfBounds
Definition: Cell.cs:414
Point GetPoint()
Definition: Cell.cs:1101
Cell Right
Definition: Cell.cs:141
Cell FrontLeft
Definition: Cell.cs:189
bool HasRamp
Definition: Cell.cs:837
bool ignoreObjShadow
Definition: Cell.cs:378
byte bridgeHeight
Definition: Cell.cs:74
bool fullWall
Definition: Cell.cs:462
int liquidLv
Definition: Cell.cs:946
bool isBridgeEdge
Definition: Cell.cs:366
bool hasDoor
Definition: Cell.cs:258
int blockDir
Definition: Cell.cs:898
static List< SourceMaterial.Row > matList
Definition: Cell.cs:12
bool IsRoomEdge
Definition: Cell.cs:868
bool HasFullBlock
Definition: Cell.cs:817
Cell FrontRight
Definition: Cell.cs:177
ushort lightR
Definition: Cell.cs:86
byte bridgePillar
Definition: Cell.cs:82
Definition: Chara.cs:10
override bool IsAliveInCurrentZone
Definition: Chara.cs:546
AIAct ai
Definition: Chara.cs:187
override bool IsPC
Definition: Chara.cs:597
Chara host
Definition: Chara.cs:33
override bool IsDeadOrSleeping
Definition: Chara.cs:558
SourceChara.Row source
Definition: Chara.cs:143
override bool IsMoving
Definition: Chara.cs:593
override CardRow sourceCard
Definition: Chara.cs:435
bool IsInActiveZone
Definition: Chara.cs:791
override void SetRenderParam(RenderParam p)
Definition: Chara.cs:6082
override bool IsPCC
Definition: Chara.cs:667
bool hasTelepathy
Definition: Chara.cs:135
BlockColors blockColors
new GameConfig game
Definition: CoreConfig.cs:596
bool godBuild
Definition: CoreDebug.cs:303
Definition: Core.cs:14
static float fixedFrame
Definition: Core.cs:25
static float delta
Definition: Core.cs:17
CoreConfig config
Definition: Core.cs:70
bool reverse
Definition: Critter.cs:23
void Update()
Definition: Critter.cs:102
virtual int SnowTile
Definition: Critter.cs:33
int tile
Definition: Critter.cs:7
bool IsNight
Definition: Date.cs:112
Definition: EInput.cs:8
static bool isAltDown
Definition: EInput.cs:265
static bool isShiftDown
Definition: EInput.cs:261
static ButtonState rightMouse
Definition: EInput.cs:351
static Vector3 mposWorld
Definition: EInput.cs:339
Definition: EMono.cs:4
static GameSetting setting
Definition: EMono.cs:31
static ColorProfile Colors
Definition: EMono.cs:35
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 Game game
Definition: EMono.cs:7
static Scene scene
Definition: EMono.cs:27
static SoundManager Sound
Definition: EMono.cs:39
static Map _map
Definition: EMono.cs:17
static CoreDebug debug
Definition: EMono.cs:45
static SourceManager sources
Definition: EMono.cs:41
Definition: FLOOR.cs:2
static SourceFloor.Row sourceSnow
Definition: FLOOR.cs:31
static SourceFloor.Row sourceSnow2
Definition: FLOOR.cs:33
static SourceFloor.Row sourceIce
Definition: FLOOR.cs:35
int tile
Definition: Footmark.cs:7
EffectSetting effect
Definition: GameSetting.cs:299
RenderSetting render
Definition: GameSetting.cs:301
int slopeMod
Definition: Game.cs:60
bool buildLight
Definition: Game.cs:36
int animeSpeed
Definition: Game.cs:84
bool showRoof
Definition: Game.cs:12
bool showWall
Definition: Game.cs:15
int lowWallObjAltitude
Definition: Game.cs:87
bool reverseSnow
Definition: Game.cs:48
bool slope
Definition: Game.cs:24
Config config
Definition: Game.cs:215
virtual bool IsMature
Definition: GrowSystem.cs:99
virtual void OnRenderTileMap(RenderParam p)
Definition: GrowSystem.cs:189
static Card alwaysVisible
Definition: LayerDrama.cs:22
Definition: Lot.cs:5
int colDeco2
Definition: Lot.cs:36
bool altRoof
Definition: Lot.cs:46
int colBlock
Definition: Lot.cs:32
int decoFix
Definition: Lot.cs:38
int idRamp
Definition: Lot.cs:24
int decoFix2
Definition: Lot.cs:40
int colRoof
Definition: Lot.cs:30
int mh
Definition: Lot.cs:58
int colDeco
Definition: Lot.cs:34
int idRoofStyle
Definition: Lot.cs:14
int heightFix
Definition: Lot.cs:18
float realHeight
Definition: Lot.cs:64
float light
Definition: Lot.cs:66
int idBlock
Definition: Lot.cs:22
int height
Definition: Lot.cs:12
int idDeco2
Definition: Lot.cs:28
int idDeco
Definition: Lot.cs:26
int idRoofTile
Definition: Lot.cs:20
bool reverse
Definition: Lot.cs:42
int idBGM
Definition: Lot.cs:16
static SourceMaterial.Row sourceSnow
Definition: MATERIAL.cs:33
static SourceMaterial.Row sourceGold
Definition: MATERIAL.cs:37
int Size
Definition: MapBounds.cs:20
int maxZ
Definition: MapBounds.cs:17
int maxX
Definition: MapBounds.cs:14
int x
Definition: MapBounds.cs:8
float heightLightMod
Definition: MapConfig.cs:53
bool fullWallHeight
Definition: MapConfig.cs:32
int skyBlockHeight
Definition: MapConfig.cs:89
float blockHeight
Definition: MapConfig.cs:68
Definition: Map.cs:13
bool IsIndoor
Definition: Map.cs:131
int SizeXZ
Definition: Map.cs:133
RoomManager rooms
Definition: Map.cs:31
Cell[,] cells
Definition: Map.cs:85
MapConfig config
Definition: Map.cs:37
static HashSet< int > sunMap
Definition: Map.cs:14
MapBounds bounds
Definition: Map.cs:52
float[] matColors
Definition: MeshBatch.cs:11
Matrix4x4[] matrices
Definition: MeshBatch.cs:5
float[] tiles
Definition: MeshBatch.cs:7
float[] colors
Definition: MeshBatch.cs:9
int batchIdx
Definition: MeshPass.cs:60
void Add(Point point, float tile=0f, float color=0f)
Definition: MeshPass.cs:122
void NextBatch()
Definition: MeshPass.cs:417
int batchSize
Definition: MeshPass.cs:63
void AddShadow(MeshPassParam p, ref Vector3 fix)
Definition: MeshPass.cs:195
List< MeshBatch > batches
Definition: MeshPass.cs:66
int idx
Definition: MeshPass.cs:57
bool CanSee(Chara c)
Definition: Player.cs:2221
CinemaConfig cinemaConfig
Definition: Player.cs:913
float lightPower
Definition: Player.cs:998
int lightRadius
Definition: Player.cs:990
Definition: Point.cs:9
static Point shared
Definition: Point.cs:20
ref Vector3 Position(int height)
Definition: Point.cs:524
Point Set(int _x, int _z)
Definition: Point.cs:479
int x
Definition: Point.cs:36
int z
Definition: Point.cs:39
bool IsValid
Definition: Point.cs:88
Point Clamp(bool useBounds=false)
Definition: Point.cs:972
Cell cell
Definition: Point.cs:51
Definition: Rand.cs:4
static int MaxBytes
Definition: Rand.cs:5
static byte[] bytes
Definition: Rand.cs:9
static void InitBytes(int a)
Definition: Rand.cs:11
new void Draw(RenderParam p, int tile=0)
void Draw(RenderParam p, int tile)
Definition: RenderData.cs:128
Vector3 offsetShadow
Definition: RenderData.cs:22
void DrawRepeat(RenderParam p, int count, float size, bool skipFirst=false)
Definition: RenderData.cs:214
float stackZ
Definition: RenderData.cs:44
int ConvertTile(int tile)
Definition: RenderData.cs:110
SourcePref shadowPref
Definition: RenderData.cs:48
int idShadow
Definition: RenderData.cs:14
float hangedFixZ
Definition: RenderData.cs:42
RenderData data
Definition: RenderObject.cs:34
SourceMaterial.Row mat
Definition: RenderParam.cs:17
int liquidLv
Definition: RenderParam.cs:7
void SetRenderParam(RenderParam p, SourceMaterial.Row mat, int dir)
Definition: RenderRow.cs:371
bool multisize
Definition: RenderRow.cs:64
RenderData renderData
Definition: RenderRow.cs:71
SourcePref pref
Definition: RenderRow.cs:68
bool useAltColor
Definition: RenderRow.cs:80
TileType tileType
Definition: RenderRow.cs:77
int[] _tiles
Definition: RenderRow.cs:12
SourceMaterial.Row DefaultMaterial
Definition: RenderRow.cs:86
int colorMod
Definition: RenderRow.cs:16
int snowTile
Definition: RenderRow.cs:28
Vector3 lowRoofFix
Definition: RoofStyle.cs:39
Vector3 posFix
Definition: RoofStyle.cs:35
int flatW
Definition: RoofStyle.cs:23
float snowZ
Definition: RoofStyle.cs:43
bool coverLot
Definition: RoofStyle.cs:33
Vector3 posFixBlock
Definition: RoofStyle.cs:37
bool wing
Definition: RoofStyle.cs:29
Vector3 snowFix
Definition: RoofStyle.cs:41
Type type
Definition: RoofStyle.cs:17
List< Lot > listLot
Definition: RoomManager.cs:20
void Refresh()
Definition: RoomManager.cs:52
Definition: Room.cs:4
bool HasRoof
Definition: Room.cs:29
Lot lot
Definition: Room.cs:21
AnimationCurve baseBrightnessCurve
AnimationCurve shadowCurveFloor
AnimationCurve dynamicBrightnessCurve2
float dynamicBrightnessLightBonus
AnimationCurve lightLimit
AnimationCurve fogBrightness
AnimationCurve dynamicBrightnessCurve
AnimationCurve shadowCurve
AnimationCurve nightRatioCurve
AnimationCurve lightModCurve
SceneGlobalProfile global
Definition: SceneProfile.cs:6
SceneLightProfile light
Definition: SceneProfile.cs:10
Definition: Scene.cs:8
List< ISyncScreen > syncList
Definition: Scene.cs:131
static Point HitPoint
Definition: Scene.cs:21
float timeRatio
Definition: Scene.cs:124
CameraSupport camSupport
Definition: Scene.cs:41
ParticleSystem psFey
Definition: Scene.cs:113
GameSetting.RenderSetting.MapBGSetting bg
Definition: Scene.cs:118
SoundSource sfxFire
Definition: Scene.cs:85
ActionMode actionMode
Definition: Scene.cs:77
SceneProfile profile
Definition: Scene.cs:73
void DrawWall(Point point, int color, bool useMarkerPass=false, float offsetZ=0f)
Definition: ScreenGuide.cs:42
MeshPass passGuideFloor
Definition: ScreenGuide.cs:7
List< Item > items
Definition: ShadowData.cs:101
static ShadowData Instance
Definition: ShadowData.cs:99
SourceObj objs
SourceBlock blocks
SourceFloor floors
bool HasGrowth
Definition: SourceObj.cs:26
GrowSystem growth
Definition: SourceObj.cs:31
bool bypassShadow
Definition: SourcePref.cs:299
int liquidModMax
Definition: SourcePref.cs:71
float height
Definition: SourcePref.cs:47
int liquidMod
Definition: SourcePref.cs:59
bool Float
Definition: SourcePref.cs:312
int shadow
Definition: SourcePref.cs:35
bool IsPlayerFaction
Definition: Spatial.cs:443
virtual bool IsRegion
Definition: Spatial.cs:501
virtual bool IsSnowCovered
Definition: Spatial.cs:531
virtual void Draw(int x, int z, RenderParam p)
Definition: Thing.cs:8
override void SetRenderParam(RenderParam p)
Definition: Thing.cs:1401
override SourcePref Pref
Definition: Thing.cs:50
override CardRow sourceCard
Definition: Thing.cs:47
int id
Definition: TileRow.cs:8
virtual bool IsUseBlockDir
Definition: TileType.cs:129
virtual bool UseHangZFix
Definition: TileType.cs:211
static TileTypeSky Sky
Definition: TileType.cs:67
virtual bool CanStack
Definition: TileType.cs:121
virtual void GetMountHeight(ref Vector3 v, Point p, int d, Card target=null)
Definition: TileType.cs:367
static TileTypeIllumination Illumination
Definition: TileType.cs:83
static TileTypeWaterShallow FloorWaterShallow
Definition: TileType.cs:57
bool IsRamp
Definition: TileType.cs:143
virtual bool AlwaysShowShadow
Definition: TileType.cs:241
virtual bool UseLowWallTiles
Definition: TileType.cs:207
virtual bool IsFullBlock
Definition: TileType.cs:165
virtual bool IsWall
Definition: TileType.cs:133
virtual bool ForceRpeatBlock
Definition: TileType.cs:245
virtual bool IsSkipLowBlock
Definition: TileType.cs:125
virtual bool UseMountHeight
Definition: TileType.cs:209
virtual bool IsFence
Definition: TileType.cs:167
virtual BlockRenderMode blockRenderMode
Definition: TileType.cs:265
Vector3 GetRampFix(int dir, SourcePref pref=null)
Definition: TileType.cs:372
virtual bool IsWaterTop
Definition: TileType.cs:175
virtual bool RepeatBlock
Definition: TileType.cs:243
virtual bool IsOpen()
Definition: TraitDoor.cs:97
virtual Vector3 GetRestrainPos
Definition: TraitShackle.cs:5
virtual bool IgnoreLastStackHeight
Definition: Trait.cs:113
virtual bool AlwaysHideOnLowWall
Definition: Trait.cs:341
virtual bool UseLowblock
Definition: Trait.cs:427
virtual TileType tileType
Definition: Trait.cs:48
virtual bool IsChangeFloorHeight
Definition: Trait.cs:68
virtual bool IsGround
Definition: Trait.cs:64
Card owner
Definition: Trait.cs:26
Vector3 v
Definition: TransAnime.cs:5
bool animeBlock
Definition: TransAnime.cs:21
bool drawBlock
Definition: TransAnime.cs:25
GameDate date
Definition: World.cs:6
Definition: Zone.cs:12
virtual bool IsSkyLevel
Definition: Zone.cs:262
void RefreshBGM()
Definition: Zone.cs:2742
virtual bool UseFog
Definition: Zone.cs:384
virtual bool AlwaysLowblock
Definition: Zone.cs:388
bool IsPCFaction
Definition: Zone.cs:464
Map map
Definition: Zone.cs:60