Elin Decompiled Documentation EA 23.102 Nightly
Loading...
Searching...
No Matches
BaseTileMap Class Reference
Inheritance diagram for BaseTileMap:
EMono TileMap TileMapElona

Public Types

enum  WallClipMode { ByRoom , ByLot }
 
enum  InnerMode { None , InnerBlock , Height , BuildMode }
 
enum  CardIconMode {
  None , Inspect , Deconstruct , State ,
  Visibility
}
 
enum  ScreenHighlight { None , SunMap }
 

Public Member Functions

void OnActivate (BaseGameScreen _screen)
 
virtual void Draw ()
 
void RefreshHeight ()
 
virtual void DrawTile ()
 
Vector3 GetThingPosition (Card tg, Point p)
 
int GetApproximateBlocklight (Cell cell)
 
int GetRoofLight (Lot lot)
 
void DrawRoof (Lot lot)
 
void SetRoofHeight (MeshPassParam _param, Cell _cell, int _cx, int _cz, int h=0, int altitude=0, int dirWall=-1, bool ignoreAltitudeY=false)
 

Static Public Member Functions

static int GetColorInt (ref Color matColor, int p)
 
- Static Public Member Functions inherited from EMono
static int rnd (int a)
 

Public Attributes

int count
 
Collider2D mouseCollider
 
Vector3 colliderFix
 
int maxColliderCheck
 
float heightBlockSize
 
float slopeFixZ
 
float heightModDeco
 
float heightLimitDeco
 
Vector3 heightMod
 
Vector3 ugFix
 
Vector3 ugFixBridge
 
Vector3 ugFixBridgeBottom
 
Vector3 ugFixBridgeTop
 
Vector3 heightModRoofBlock
 
float rightWallShade
 
Vector3 roofRampFix
 
Vector3 roofFix
 
Vector3 roofFix2
 
Vector3 roofFix3
 
float roofLightMod
 
float lotLight
 
float lotLight2
 
float roofLightSnow
 
WallClipMode wallClipMode
 
InnerMode defaultInnerMode
 
Vector3 edgeBlockFix
 
Vector3 bridgeFix
 
Vector3 cornerWallFix
 
Vector3 cornerWallFix2
 
Vector3 cornerWallFix3
 
Vector3 altitudeFix
 
Vector3 waterEdgeFix
 
Vector3 waterEdgeBridgeFix
 
Vector3 waterEdgeFixShore
 
Vector3 waterEdgeFixShoreSand
 
Vector3[] ambientShadowFix
 
Vector3[] transitionFix
 
Vector3[] wallHangFix
 
Vector3[] waterEdgeBlockFix
 
int fogTile
 
float floatSpeed
 
float shadowModStrength
 
int maxFloat
 
int[] seaAnimeIndexes
 
NoiseLayer layerGroundLights
 
MeshPass passShadow
 
MeshPass passLiquid
 
MeshPass passGuideBlock
 
MeshPass passGuideFloor
 
MeshPass passArea
 
MeshPass passRamp
 
MeshPass passFloor
 
MeshPass passBlock
 
MeshPass passObjS
 
MeshPass passObjSS
 
MeshPass passObj
 
MeshPass passObjL
 
MeshPass passDecal
 
MeshPass passRoof
 
MeshPass passBlockEx
 
MeshPass passFloorEx
 
MeshPass passFloorWater
 
MeshPass passInner
 
MeshPass passFog
 
MeshPass passFov
 
MeshPass passEdge
 
MeshPass passAutoTile
 
MeshPass passAutoTileWater
 
MeshPass passBlockMarker
 
MeshPass passFloorMarker
 
MeshPass passWaterBlock
 
MeshPass passIcon
 
MeshPass passChara
 
MeshPass passCharaL
 
MeshPass passCharaLW
 
MeshPass passCharaLL
 
MeshPass passShore
 
RenderData renderFootmark
 
RenderData rendererBlockMarker
 
RenderData rendererFloorMarker
 
RenderData rendererInnerBlock
 
RenderData rendererFov
 
RenderData rendererFov2
 
RenderData rendererShore
 
RenderData renderBorder
 
RenderData rendererFogBlockSolid
 
RenderData rendererFogFloorSolid
 
RenderData rendererFogRoomSolid
 
RenderData rendererFogRoomBlockSolid
 
RenderData rendererFogRoomWallSolid
 
RenderData rendererWallDeco
 
RenderData rendererWaterBlock
 
RenderDataObjDummy rendererObjDummy
 
RenderDataEffect rendererEffect
 
Point TestPoint = new Point()
 
int Size
 
int SizeXZ
 
int mx
 
int mz
 
int x
 
int z
 
int cx
 
int cz
 
int activeCount
 
int floatV = 1
 
byte[] groundLights
 
bool lowBlock
 
bool lowObj
 
bool highlightArea
 
bool subtleHighlightArea
 
bool hideRoomFog
 
bool showRoof
 
bool showFullWall
 
bool hideHang
 
bool usingHouseBoard
 
bool noRoofMode
 
bool fogged
 
float[] lightLookUp
 
float _lightMod
 
float _baseBrightness
 
float lowblockTimer
 
float heightLightMod
 
float _rightWallShade
 
float roofLightLimitMod
 
float floatY
 
float floorShadowStrength
 
Vector3 _heightMod
 
ScreenHighlight screenHighlight
 
new BaseGameScreen screen
 
RoofStyle[] roofStyles
 

Static Public Attributes

static bool forceShowHang
 
const int DefColor = 104025
 
const int BlocklightToken = 262144
 
const int BlocklightMTP = 50
 
- Static Public Attributes inherited from EMono
static Core core
 

Protected Attributes

InnerMode innerMode
 
RaycastHit2D[] rays = new RaycastHit2D[1]
 
CardIconMode iconMode
 
bool isMining
 
bool buildMode
 
bool hasBridge
 
bool _lowblock
 
bool isIndoor
 
Map map
 
MeshPass pass
 
BaseTileSelector selector
 
GameSetting.RenderSetting renderSetting
 
GameSetting.RenderSetting.ZSetting zSetting
 
int liquidLv
 
int index
 
int totalFire
 
int snowColorToken
 
int waterAnimeIndex
 
int lowWallObjAltitude
 
SourceMaterial.Row matBlock
 
SourceMaterial.Row matFloor
 
SourceMaterial.Row matBridge
 
float blockLight
 
float floorLight
 
float floorLight2
 
float light
 
float pcMaxLight
 
float orgX
 
float orgY
 
float orgZ
 
float roomHeight
 
float maxHeight
 
float snowLight
 
float waterAnimeTimer
 
float floatTimer
 
float destBrightness
 
float lightLimit
 
float modSublight1
 
float modSublight2
 
float shadowStrength
 
float _shadowStrength
 
float fogBrightness
 
float defaultBlockHeight
 
float snowLimit
 
float snowColor
 
float snowColor2
 
float nightRatio
 
RenderParam param = new RenderParam()
 
MeshBatch batch
 
Vector3 _actorPos
 
Vector3 freePos
 
int tile
 
int floorMatColor
 
int height
 
int currentHeight
 
int pcX
 
int pcZ
 
int floorDir
 
bool roof
 
bool isSeen
 
bool showAllCards
 
bool fogBounds
 
bool snowed
 
bool isSnowCovered
 
bool highlightCells
 
bool cinemaMode
 
bool alwaysLowblock
 
bool showBorder
 
Vector3 thingPos
 
Vector3 orgPos
 
Cell cell
 
CellDetail detail
 
SourceBlock.Row sourceBlock
 
SourceFloor.Row sourceFloor
 
SourceFloor.Row sourceBridge
 
Room currentRoom
 
Room lastRoom
 
Room room
 
Lot currentLot
 
SourceBlock.Row _sourceBlock
 
TileType tileType
 
SceneLightProfile lightSetting
 

Properties

Point HitPoint [get]
 
- Properties inherited from EMono
static Game game [get]
 
static bool AdvMode [get]
 
static Player player [get]
 
static Chara pc [get]
 
static UI ui [get]
 
static Map _map [get]
 
static Zone _zone [get]
 
static FactionBranch Branch [get]
 
static FactionBranch BranchOrHomeBranch [get]
 
static Faction Home [get]
 
static Scene scene [get]
 
static BaseGameScreen screen [get]
 
static GameSetting setting [get]
 
static GameData gamedata [get]
 
static ColorProfile Colors [get]
 
static World world [get]
 
static SoundManager Sound [get]
 
static SourceManager sources [get]
 
static SourceManager editorSources [get]
 
static CoreDebug debug [get]
 

Private Attributes

bool noSlopMode
 

Detailed Description

Definition at line 5 of file BaseTileMap.cs.

Member Enumeration Documentation

◆ CardIconMode

Enumerator
None 
Inspect 
Deconstruct 
State 
Visibility 

Definition at line 21 of file BaseTileMap.cs.

◆ InnerMode

Enumerator
None 
InnerBlock 
Height 
BuildMode 

Definition at line 13 of file BaseTileMap.cs.

◆ ScreenHighlight

Enumerator
None 
SunMap 

Definition at line 30 of file BaseTileMap.cs.

◆ WallClipMode

Enumerator
ByRoom 
ByLot 

Definition at line 7 of file BaseTileMap.cs.

Member Function Documentation

◆ Draw()

virtual void BaseTileMap.Draw ( )
inlinevirtual

Reimplemented in TileMapElona.

Definition at line 533 of file BaseTileMap.cs.

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 }
AreaHighlightMode
if(item3.idFile==idFirstFile &&item3.id==idFirstTopic)
Definition: UIBook.cs:627
SceneProfile profile
Definition: AM_Cinema.cs:5
static bool IsAdv
Definition: ActionMode.cs:117
static AM_ViewMap ViewMap
Definition: ActionMode.cs:63
virtual BaseTileMap.CardIconMode cardIconMode
Definition: ActionMode.cs:229
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
Vector3 tileWeight
virtual void RefreshWeather()
float blockLight
Definition: BaseTileMap.cs:378
bool showAllCards
Definition: BaseTileMap.cs:454
bool highlightArea
Definition: BaseTileMap.cs:275
int maxColliderCheck
Definition: BaseTileMap.cs:45
InnerMode defaultInnerMode
Definition: BaseTileMap.cs:90
Point HitPoint
Definition: BaseTileMap.cs:508
ScreenHighlight screenHighlight
Definition: BaseTileMap.cs:332
float snowLight
Definition: BaseTileMap.cs:398
InnerMode innerMode
Definition: BaseTileMap.cs:233
float modSublight2
Definition: BaseTileMap.cs:410
float waterAnimeTimer
Definition: BaseTileMap.cs:400
bool showBorder
Definition: BaseTileMap.cs:468
bool isSnowCovered
Definition: BaseTileMap.cs:460
float floatY
Definition: BaseTileMap.cs:323
int lowWallObjAltitude
Definition: BaseTileMap.cs:370
bool cinemaMode
Definition: BaseTileMap.cs:464
bool alwaysLowblock
Definition: BaseTileMap.cs:466
bool hideRoomFog
Definition: BaseTileMap.cs:281
float _lightMod
Definition: BaseTileMap.cs:305
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
bool fogBounds
Definition: BaseTileMap.cs:456
RenderParam param
Definition: BaseTileMap.cs:428
bool noRoofMode
Definition: BaseTileMap.cs:296
new BaseGameScreen screen
Definition: BaseTileMap.cs:348
Vector3 edgeBlockFix
Definition: BaseTileMap.cs:92
bool usingHouseBoard
Definition: BaseTileMap.cs:293
float floorShadowStrength
Definition: BaseTileMap.cs:326
RenderData rendererFov2
Definition: BaseTileMap.cs:207
float _baseBrightness
Definition: BaseTileMap.cs:308
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
float rightWallShade
Definition: BaseTileMap.cs:69
Vector3 _heightMod
Definition: BaseTileMap.cs:329
float floatTimer
Definition: BaseTileMap.cs:402
float pcMaxLight
Definition: BaseTileMap.cs:386
float lowblockTimer
Definition: BaseTileMap.cs:311
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
float nightRatio
Definition: BaseTileMap.cs:426
float destBrightness
Definition: BaseTileMap.cs:404
bool buildMode
Definition: BaseTileMap.cs:340
float defaultBlockHeight
Definition: BaseTileMap.cs:418
bool subtleHighlightArea
Definition: BaseTileMap.cs:278
MeshBatch batch
Definition: BaseTileMap.cs:430
Point TestPoint
Definition: BaseTileMap.cs:231
float snowColor2
Definition: BaseTileMap.cs:424
float heightLightMod
Definition: BaseTileMap.cs:314
float snowColor
Definition: BaseTileMap.cs:422
bool highlightCells
Definition: BaseTileMap.cs:462
RaycastHit2D[] rays
Definition: BaseTileMap.cs:334
int waterAnimeIndex
Definition: BaseTileMap.cs:368
Vector3 colliderFix
Definition: BaseTileMap.cs:43
static bool forceShowHang
Definition: BaseTileMap.cs:36
float roofLightLimitMod
Definition: BaseTileMap.cs:320
MeshPass pass
Definition: BaseTileMap.cs:352
float shadowStrength
Definition: BaseTileMap.cs:412
MeshPass passInner
Definition: BaseTileMap.cs:167
CardIconMode iconMode
Definition: BaseTileMap.cs:336
int currentHeight
Definition: BaseTileMap.cs:442
bool pressing
Definition: ButtonState.cs:35
ScreenGrading grading
Point pos
Definition: Card.cs:55
Room room
Definition: Cell.cs:102
byte TopHeight
Definition: Cell.cs:117
Cell Front
Definition: Cell.cs:129
bool UseLowBlock
Definition: Cell.cs:861
byte height
Definition: Cell.cs:72
bool isWallEdge
Definition: Cell.cs:426
Cell Right
Definition: Cell.cs:141
override bool IsMoving
Definition: Chara.cs:593
bool IsInActiveZone
Definition: Chara.cs:791
new GameConfig game
Definition: CoreConfig.cs:596
Definition: Core.cs:14
static float delta
Definition: Core.cs:17
CoreConfig config
Definition: Core.cs:70
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 Core core
Definition: EMono.cs:5
static Chara pc
Definition: EMono.cs:13
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
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
Config config
Definition: Game.cs:215
Definition: Lot.cs:5
int idRoofStyle
Definition: Lot.cs:14
int idBGM
Definition: Lot.cs:16
int Size
Definition: MapBounds.cs:20
float heightLightMod
Definition: MapConfig.cs:53
float blockHeight
Definition: MapConfig.cs:68
bool IsIndoor
Definition: Map.cs:131
int SizeXZ
Definition: Map.cs:133
RoomManager rooms
Definition: Map.cs:31
MapConfig config
Definition: Map.cs:37
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 NextBatch()
Definition: MeshPass.cs:417
int batchSize
Definition: MeshPass.cs:63
List< MeshBatch > batches
Definition: MeshPass.cs:66
int idx
Definition: MeshPass.cs:57
CinemaConfig cinemaConfig
Definition: Player.cs:913
int lightRadius
Definition: Player.cs:990
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
void Draw(RenderParam p, int tile)
Definition: RenderData.cs:128
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
float timeRatio
Definition: Scene.cs:124
CameraSupport camSupport
Definition: Scene.cs:41
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
bool IsPlayerFaction
Definition: Spatial.cs:443
virtual bool IsRegion
Definition: Spatial.cs:501
virtual bool IsSnowCovered
Definition: Spatial.cs:531
Definition: Zone.cs:12
virtual bool IsSkyLevel
Definition: Zone.cs:262
void RefreshBGM()
Definition: Zone.cs:2742
virtual bool AlwaysLowblock
Definition: Zone.cs:388
Map map
Definition: Zone.cs:60

References _baseBrightness, _heightMod, _lightMod, EMono._map, _rightWallShade, EMono._zone, Scene.actionMode, activeCount, alwaysLowblock, Zone.AlwaysLowblock, Game.Config.animeSpeed, SceneLightProfile.baseBrightnessCurve, batch, MeshPass.batches, MeshPass.batchIdx, MeshPass.batchSize, Scene.bg, ActionMode.Bird, MapConfig.blockHeight, blockLight, CinemaConfig.brightness, Game.Config.buildLight, buildMode, Scene.camSupport, ActionMode.cardIconMode, Point.cell, ActionMode.Cinema, Player.cinemaConfig, cinemaMode, Point.Clamp(), colliderFix, MeshBatch.colors, Core.config, Game.config, Map.config, EMono.core, count, currentHeight, currentLot, currentRoom, cx, cz, defaultBlockHeight, defaultInnerMode, Core.delta, destBrightness, RenderData.Draw(), DrawRoof(), DrawTile(), SceneLightProfile.dynamicBrightnessCurve, SceneLightProfile.dynamicBrightnessCurve2, SceneLightProfile.dynamicBrightnessLightBonus, SceneLightProfile.dynamicBrightnessSpeed, edgeBlockFix, ActionMode.FlagCell, floatSpeed, floatTimer, floatV, floatY, floorShadowStrength, fogBounds, fogBrightness, SceneLightProfile.fogBrightness, forceShowHang, Cell.Front, CoreConfig.game, EMono.game, SceneProfile.global, CameraSupport.grading, BaseGameScreen.grid, Room.HasRoof, BaseGameScreen.height, height, Cell.height, heightLightMod, MapConfig.heightLightMod, hideHang, hideRoomFog, highlightArea, highlightCells, HitPoint, iconMode, Lot.idBGM, Lot.idRoofStyle, MeshPass.idx, if(), innerMode, ActionMode.IsActive, ActionMode.IsAdv, EInput.isAltDown, ActionMode.IsBuildMode, Chara.IsInActiveZone, isIndoor, Map.IsIndoor, isMining, Chara.IsMoving, Spatial.IsPlayerFaction, Spatial.IsRegion, EInput.isShiftDown, Zone.IsSkyLevel, isSnowCovered, Spatial.IsSnowCovered, Point.IsValid, Cell.isWallEdge, item, lastRoom, CinemaConfig.light, SceneProfile.light, lightLimit, SceneLightProfile.lightLimit, SceneLightProfile.lightModCurve, Player.lightRadius, lightSetting, RoomManager.listLot, Room.lot, lowBlock, lowblockTimer, lowObj, lowWallObjAltitude, Game.Config.lowWallObjAltitude, map, Zone.map, MeshBatch.matColors, MeshBatch.matrices, maxColliderCheck, maxFloat, ActionMode.Mine, modSublight1, modSublight2, EInput.mposWorld, mx, mz, MeshPass.NextBatch(), nightRatio, SceneLightProfile.nightRatioCurve, noRoofMode, noSlopMode, param, pass, passInner, EMono.pc, pcMaxLight, pcX, pcZ, EMono.player, Card.pos, Point.Position(), ButtonState.pressing, AM_Cinema.profile, Scene.profile, rays, RoomManager.Refresh(), Zone.RefreshBGM(), RefreshHeight(), BaseGameScreen.RefreshWeather(), rendererFov2, Game.Config.reverseSnow, Cell.Right, EInput.rightMouse, rightWallShade, roofLightLimitMod, room, Cell.room, Map.rooms, EMono.scene, screen, screenHighlight, Point.Set(), Scene.sfxFire, SceneLightProfile.shadowCurve, SceneLightProfile.shadowCurveFloor, shadowStrength, showAllCards, showBorder, CoreConfig.GameConfig.showBorder, showFullWall, showRoof, Game.Config.showRoof, Game.Config.showWall, Size, MapBounds.Size, SizeXZ, Map.SizeXZ, snowColor, snowColor2, snowColorToken, snowLight, snowLimit, EMono.Sound, subtleHighlightArea, TestPoint, BaseGameScreen.tileAlign, MeshBatch.tiles, BaseGameScreen.tileWeight, Scene.timeRatio, Cell.TopHeight, totalFire, Cell.UseLowBlock, usingHouseBoard, ActionMode.ViewMap, waterAnimeIndex, waterAnimeTimer, BaseGameScreen.width, x, MeshPassParam.x, Point.x, MeshPassParam.y, z, MeshPassParam.z, Point.z, and CameraSupport.Zoom.

Referenced by BaseGameScreen.Draw(), and DrawTile().

◆ DrawRoof()

void BaseTileMap.DrawRoof ( Lot  lot)
inline

Definition at line 3294 of file BaseTileMap.cs.

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 }
Vector3 roofFix2
Definition: BaseTileMap.cs:75
int GetRoofLight(Lot lot)
Vector3 roofFix3
Definition: BaseTileMap.cs:77
Vector3 roofRampFix
Definition: BaseTileMap.cs:71
SourceMaterial.Row matBlock
Definition: BaseTileMap.cs:372
RenderDataEffect rendererEffect
Definition: BaseTileMap.cs:229
Vector3 roofFix
Definition: BaseTileMap.cs:73
RoofStyle[] roofStyles
Definition: BaseTileMap.cs:500
int FireAmount
Definition: CellEffect.cs:150
CellEffect effect
Definition: Cell.cs:94
Cell Back
Definition: Cell.cs:153
bool isClearSnow
Definition: Cell.cs:450
Cell Left
Definition: Cell.cs:165
bool IsRoomEdge
Definition: Cell.cs:868
bool HasFullBlock
Definition: Cell.cs:817
Cell FrontRight
Definition: Cell.cs:177
static SourceManager sources
Definition: EMono.cs:41
bool altRoof
Definition: Lot.cs:46
int colBlock
Definition: Lot.cs:32
int idRamp
Definition: Lot.cs:24
int colRoof
Definition: Lot.cs:30
int mh
Definition: Lot.cs:58
int heightFix
Definition: Lot.cs:18
float realHeight
Definition: Lot.cs:64
int idBlock
Definition: Lot.cs:22
int height
Definition: Lot.cs:12
int idRoofTile
Definition: Lot.cs:20
bool reverse
Definition: Lot.cs:42
static SourceMaterial.Row sourceGold
Definition: MATERIAL.cs:37
Cell[,] cells
Definition: Map.cs:85
Definition: Rand.cs:4
static int MaxBytes
Definition: Rand.cs:5
static byte[] bytes
Definition: Rand.cs:9
new void Draw(RenderParam p, int tile=0)
int ConvertTile(int tile)
Definition: RenderData.cs:110
void SetRenderParam(RenderParam p, SourceMaterial.Row mat, int dir)
Definition: RenderRow.cs:371
RenderData renderData
Definition: RenderRow.cs:71
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
SourceObj objs
SourceBlock blocks
SourceFloor floors

References _heightMod, Lot.altRoof, Cell.Back, SourceManager.blocks, Rand.bytes, cell, Map.cells, Lot.colBlock, Lot.colRoof, RenderData.ConvertTile(), RoofStyle.coverLot, cx, cz, RenderData.Draw(), RenderDataEffect.Draw(), Cell.effect, CellEffect.FireAmount, RoofStyle.flatW, SourceManager.floors, Cell.Front, Cell.FrontRight, GetRoofLight(), RoofStyle.h, Cell.HasFullBlock, height, Lot.height, Lot.heightFix, Lot.idBlock, Lot.idRamp, Lot.idRoofStyle, Lot.idRoofTile, if(), index, Cell.isClearSnow, Cell.IsRoomEdge, isSnowCovered, Cell.Left, Room.lot, RoofStyle.lowRoofFix, map, matBlock, Rand.MaxBytes, Lot.mh, SourceManager.objs, param, RoofStyle.posFix, RoofStyle.posFixBlock, Lot.realHeight, RenderRow.renderData, rendererEffect, Lot.reverse, Cell.Right, roofFix, roofFix2, roofFix3, roofRampFix, roofStyles, room, Cell.room, screen, RenderRow.SetRenderParam(), Size, RoofStyle.snowFix, RenderRow.snowTile, RoofStyle.snowZ, MATERIAL.sourceGold, EMono.sources, BaseGameScreen.tileAlign, BaseGameScreen.tileWeight, Cell.TopHeight, RoofStyle.type, RoofStyle.w, RoofStyle.wing, MeshPassParam.y, and MeshPassParam.z.

Referenced by Draw().

◆ DrawTile()

virtual void BaseTileMap.DrawTile ( )
inlinevirtual

Reimplemented in TileMapElona.

Definition at line 900 of file BaseTileMap.cs.

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;
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 {
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 {
955 {
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 {
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 {
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 {
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 {
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 }
BlockRenderMode
PlaceState
Definition: PlaceState.cs:2
TraitTrolley trolley
Definition: AI_Trolley.cs:23
virtual bool ShowMaskedThings
Definition: ActionMode.cs:221
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
MeshPass passArea
Definition: BaseTileMap.cs:141
Vector3 cornerWallFix
Definition: BaseTileMap.cs:96
float maxHeight
Definition: BaseTileMap.cs:396
MeshPass passFloor
Definition: BaseTileMap.cs:145
virtual void Draw()
Definition: BaseTileMap.cs:533
int floorMatColor
Definition: BaseTileMap.cs:438
RenderData rendererInnerBlock
Definition: BaseTileMap.cs:203
float heightModDeco
Definition: BaseTileMap.cs:52
SourceFloor.Row sourceBridge
Definition: BaseTileMap.cs:482
float slopeFixZ
Definition: BaseTileMap.cs:50
Vector3 cornerWallFix2
Definition: BaseTileMap.cs:98
SourceMaterial.Row matBridge
Definition: BaseTileMap.cs:376
RenderData rendererFogRoomSolid
Definition: BaseTileMap.cs:217
RenderData rendererWaterBlock
Definition: BaseTileMap.cs:225
Vector3 waterEdgeFixShoreSand
Definition: BaseTileMap.cs:110
MeshPass passGuideBlock
Definition: BaseTileMap.cs:137
MeshPass passShadow
Definition: BaseTileMap.cs:133
RenderData renderBorder
Definition: BaseTileMap.cs:211
Vector3 waterEdgeFixShore
Definition: BaseTileMap.cs:108
static int GetColorInt(ref Color matColor, int p)
float[] lightLookUp
Definition: BaseTileMap.cs:302
TileType tileType
Definition: BaseTileMap.cs:494
Vector3 ugFix
Definition: BaseTileMap.cs:58
float floorLight
Definition: BaseTileMap.cs:380
float lotLight2
Definition: BaseTileMap.cs:83
MeshPass passAutoTileWater
Definition: BaseTileMap.cs:177
RenderData rendererFov
Definition: BaseTileMap.cs:205
WallClipMode wallClipMode
Definition: BaseTileMap.cs:88
Vector3 altitudeFix
Definition: BaseTileMap.cs:102
Vector3 thingPos
Definition: BaseTileMap.cs:470
MeshPass passDecal
Definition: BaseTileMap.cs:157
Vector3[] transitionFix
Definition: BaseTileMap.cs:114
Vector3 waterEdgeFix
Definition: BaseTileMap.cs:104
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
float _shadowStrength
Definition: BaseTileMap.cs:414
RenderData rendererShore
Definition: BaseTileMap.cs:209
Vector3 bridgeFix
Definition: BaseTileMap.cs:94
Vector3 ugFixBridgeBottom
Definition: BaseTileMap.cs:62
bool hasBridge
Definition: BaseTileMap.cs:342
SourceBlock.Row _sourceBlock
Definition: BaseTileMap.cs:492
float heightBlockSize
Definition: BaseTileMap.cs:48
RenderData renderFootmark
Definition: BaseTileMap.cs:197
Vector3 freePos
Definition: BaseTileMap.cs:434
MeshPass passGuideFloor
Definition: BaseTileMap.cs:139
MeshPass passEdge
Definition: BaseTileMap.cs:173
Vector3 ugFixBridgeTop
Definition: BaseTileMap.cs:64
Vector3[] ambientShadowFix
Definition: BaseTileMap.cs:112
float heightLimitDeco
Definition: BaseTileMap.cs:54
MeshPass passObjSS
Definition: BaseTileMap.cs:151
float shadowModStrength
Definition: BaseTileMap.cs:124
RenderData rendererFogRoomBlockSolid
Definition: BaseTileMap.cs:219
MeshPass passShore
Definition: BaseTileMap.cs:195
SourceMaterial.Row matFloor
Definition: BaseTileMap.cs:374
Vector3 ugFixBridge
Definition: BaseTileMap.cs:60
Vector3 cornerWallFix3
Definition: BaseTileMap.cs:100
RenderData rendererWallDeco
Definition: BaseTileMap.cs:223
CellDetail detail
Definition: BaseTileMap.cs:476
SourceBlock.Row sourceBlock
Definition: BaseTileMap.cs:478
int[] seaAnimeIndexes
Definition: BaseTileMap.cs:128
Vector3 waterEdgeBridgeFix
Definition: BaseTileMap.cs:106
RenderData rendererFogRoomWallSolid
Definition: BaseTileMap.cs:221
RenderData rendererFogFloorSolid
Definition: BaseTileMap.cs:215
float roomHeight
Definition: BaseTileMap.cs:394
void SetRoofHeight(MeshPassParam _param, Cell _cell, int _cx, int _cz, int h=0, int altitude=0, int dirWall=-1, bool ignoreAltitudeY=false)
RenderDataObjDummy rendererObjDummy
Definition: BaseTileMap.cs:227
RenderData rendererFogBlockSolid
Definition: BaseTileMap.cs:213
GameSetting.RenderSetting.ZSetting zSetting
Definition: BaseTileMap.cs:358
bool _lowblock
Definition: BaseTileMap.cs:344
SourceFloor.Row sourceFloor
Definition: BaseTileMap.cs:480
float floorLight2
Definition: BaseTileMap.cs:382
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)
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
Trait trait
Definition: Card.cs:49
int altitude
Definition: Card.cs:214
bool isDeconstructing
Definition: Card.cs:418
bool IsInstalled
Definition: Card.cs:2241
TraitShackle GetRestrainer()
Definition: Card.cs:6329
int dir
Definition: Card.cs:142
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
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
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
byte _bridge
Definition: Cell.cs:46
bool isDeck
Definition: Cell.cs:510
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 isFloating
Definition: Cell.cs:474
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
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 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
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 outOfBounds
Definition: Cell.cs:414
Point GetPoint()
Definition: Cell.cs:1101
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
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 CardRow sourceCard
Definition: Chara.cs:435
override void SetRenderParam(RenderParam p)
Definition: Chara.cs:6082
override bool IsPCC
Definition: Chara.cs:667
bool hasTelepathy
Definition: Chara.cs:135
BlockColors blockColors
bool godBuild
Definition: CoreDebug.cs:303
static float fixedFrame
Definition: Core.cs:25
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
static GameSetting setting
Definition: EMono.cs:31
static ColorProfile Colors
Definition: EMono.cs:35
static World world
Definition: EMono.cs:37
static CoreDebug debug
Definition: EMono.cs:45
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
virtual bool IsMature
Definition: GrowSystem.cs:99
virtual void OnRenderTileMap(RenderParam p)
Definition: GrowSystem.cs:189
static Card alwaysVisible
Definition: LayerDrama.cs:22
int colDeco2
Definition: Lot.cs:36
int decoFix
Definition: Lot.cs:38
int decoFix2
Definition: Lot.cs:40
int colDeco
Definition: Lot.cs:34
float light
Definition: Lot.cs:66
int idDeco2
Definition: Lot.cs:28
int idDeco
Definition: Lot.cs:26
static SourceMaterial.Row sourceSnow
Definition: MATERIAL.cs:33
int maxZ
Definition: MapBounds.cs:17
int maxX
Definition: MapBounds.cs:14
int x
Definition: MapBounds.cs:8
bool fullWallHeight
Definition: MapConfig.cs:32
int skyBlockHeight
Definition: MapConfig.cs:89
Definition: Map.cs:13
static HashSet< int > sunMap
Definition: Map.cs:14
MapBounds bounds
Definition: Map.cs:52
void Add(Point point, float tile=0f, float color=0f)
Definition: MeshPass.cs:122
void AddShadow(MeshPassParam p, ref Vector3 fix)
Definition: MeshPass.cs:195
bool CanSee(Chara c)
Definition: Player.cs:2221
float lightPower
Definition: Player.cs:998
Definition: Point.cs:9
static Point shared
Definition: Point.cs:20
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
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
bool multisize
Definition: RenderRow.cs:64
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
ParticleSystem psFey
Definition: Scene.cs:113
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
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
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
virtual bool UseFog
Definition: Zone.cs:384
bool IsPCFaction
Definition: Zone.cs:464

References _actorPos, _baseBrightness, Cell._block, Cell._bridge, _heightMod, _lightMod, _lowblock, EMono._map, _rightWallShade, Cell._roofBlock, Cell._roofBlockDir, Cell._roofBlockMat, _shadowStrength, _sourceBlock, RenderRow._tiles, EMono._zone, Scene.actionMode, BaseCore.actionsLateUpdate, MeshPass.Add(), MeshPass.AddShadow(), Chara.ai, Card.altitude, altitudeFix, Trait.AlwaysHideOnLowWall, alwaysLowblock, TileType.AlwaysShowShadow, LayerDrama.alwaysVisible, ambientShadowFix, CellDetail.anime, SourceCellEffect.Row.anime, TransAnime.animeBlock, CellDetail.area, AreaData.atrium, Cell.autotile, Cell.autotileBridge, Cell.autotileObj, Cell.Back, back, Cell.BackLeft, Cell.BackRight, batch, MeshPass.batches, MeshPass.batchIdx, MeshPass.batchSize, ColorProfile.blockColors, Cell.blockDir, blockLight, Cell.blockList, TileType.blockRenderMode, SourceManager.blocks, Map.bounds, bridgeFix, Cell.bridgeHeight, Cell.bridgePillar, buildMode, SourcePref.bypassShadow, Rand.bytes, Player.CanSee(), TileType.CanStack, Cell.castFloorShadow, Card.category, cell, Map.cells, CellDetail.charas, ActionMode.Cinema, cinemaMode, Lot.colDeco, Lot.colDeco2, CellEffect.color, MeshPassParam.color, RenderRow.colorMod, EMono.Colors, MeshBatch.colors, Map.config, EMono.core, cornerWallFix, cornerWallFix2, cornerWallFix3, count, Cell.critter, currentHeight, currentLot, currentRoom, cx, cz, BaseArea.data, RenderObject.data, World.date, EMono.debug, Cell.decal, Lot.decoFix, Lot.decoFix2, defaultBlockHeight, RenderRow.DefaultMaterial, SourceMaterial.Row.defBlock, GameSetting.RenderSetting.defCharaHeight, CellDetail.designation, detail, Cell.detail, Card.dir, RenderParam.dir, Draw(), TaskDesignation.Draw(), CardRenderer.Draw(), RenderData.Draw(), RenderDataEffect.Draw(), TransAnime.drawBlock, RenderData.DrawRepeat(), ScreenGuide.DrawWall(), Cell.effect, GameSetting.effect, Core.fixedFrame, ActionMode.FlagCell, Card.flipX, SourcePref.Float, floatY, floorDir, Cell.floorDir, TileTypeWaterShallow.FloorHeight, floorLight, floorLight2, floorMatColor, floorShadowStrength, TileType.FloorWaterShallow, fogBounds, fogBrightness, fogged, CellDetail.footmark, TileType.ForceRpeatBlock, freePos, Card.freePos, Cell.Front, Cell.FrontLeft, Cell.FrontRight, Cell.fullWall, MapConfig.fullWallHeight, Card.fx, Card.fy, GetColorInt(), TileType.GetMountHeight(), Cell.GetPoint(), TileType.GetRampFix(), Card.GetRestrainer(), TraitShackle.GetRestrainPos, GetRoofLight(), Area.GetTile(), CoreDebug.godBuild, Cell.growth, SourceObj.Row.growth, BaseGameScreen.guide, RenderData.hangedFixZ, Cell.HasBlock, hasBridge, Cell.hasDoor, Cell.HasFloodBlock, Cell.HasFullBlock, SourceObj.Row.HasGrowth, Cell.HasRamp, Cell.HasRoof, Room.HasRoof, Chara.hasTelepathy, Cell.HasWallOrFence, height, Cell.height, Lot.height, SourcePref.height, heightBlockSize, Lot.heightFix, heightLightMod, heightLimitDeco, heightModDeco, hideHang, Cell.highlight, highlightArea, highlightCells, Chara.host, iconMode, Card.id, TileRow.id, Lot.idDeco, Lot.idDeco2, Lot.idRoofStyle, RenderData.idShadow, MeshPass.idx, if(), Trait.IgnoreLastStackHeight, Cell.ignoreObjShadow, Card.ignoreStackHeight, TileType.Illumination, index, innerMode, ShadowData.Instance, ActionMode.IsActive, Chara.IsAliveInCurrentZone, Cell.isBridgeEdge, Cell.IsBridgeWater, Trait.IsChangeFloorHeight, Cell.isClearArea, Cell.isClearSnow, Chara.IsDeadOrSleeping, Cell.isDeck, Card.isDeconstructing, TileType.IsFence, CellEffect.IsFire, Card.isFloating, Cell.isFloating, Cell.IsFloorWater, Cell.isForceFloat, TileType.IsFullBlock, Trait.IsGround, isIndoor, Card.IsInstalled, CellEffect.IsLiquid, Card.isMasked, GrowSystem.IsMature, CardRenderer.IsMoving, Date.IsNight, Card.isNPCProperty, TraitDoor.IsOpen(), Chara.IsPC, Chara.IsPCC, Zone.IsPCFaction, TileType.IsRamp, Card.isRestrained, Card.isRoofItem, Cell.IsRoomEdge, isSeen, Cell.isSeen, Cell.isShadowed, Cell.isShoreSand, TileType.IsSkipLowBlock, Cell.isSkyFloor, Cell.isSlopeEdge, isSnowCovered, Cell.IsSnowTile, Cell.isSurrounded, Cell.isToggleWallPillar, Cell.IsTopWater, TileType.IsUseBlockDir, TileType.IsWall, Cell.isWallEdge, Cell.isWatered, TileType.IsWaterTop, ShadowData.items, Cell.Left, left, light, Lot.light, Cell.lightB, Cell.lightG, lightLimit, lightLookUp, Player.lightPower, Cell.lightR, liquidLv, Cell.liquidLv, RenderParam.liquidLv, SourcePref.liquidMod, SourcePref.liquidModMax, Room.lot, lotLight, lotLight2, Cell.lotShade, Cell.lotWall, lowBlock, lowWallObjAltitude, map, ColorProfile.BlockColors.MapHighlight, RenderParam.mat, matBlock, Cell.matBlock, matBridge, Cell.matBridge, MeshPassParam.matColor, SourceMaterial.Row.matColor, MeshBatch.matColors, matFloor, Cell.matFloor, Cell.matList, Cell.matObj, MeshBatch.matrices, Rand.MaxBytes, AreaData.maxHeight, maxHeight, MapBounds.maxX, MapBounds.maxZ, Lot.mh, AM_FlagCell.mode, RenderRow.multisize, MeshPass.NextBatch(), nightRatio, noRoofMode, Card.noShadow, noSlopMode, Cell.obj, Cell.objDir, RenderData.offsetShadow, GrowSystem.OnRenderTileMap(), orgX, orgY, orgZ, Cell.outOfBounds, Trait.owner, param, pass, passArea, passAutoTile, passAutoTileWater, passDecal, passEdge, passFloor, passGuideBlock, passGuideFloor, ScreenGuide.passGuideFloor, passObjSS, passShadow, passShore, EMono.pc, Cell.pcSync, Card.placeState, EMono.player, Card.pos, CardRenderer.position, Card.Pref, RenderRow.pref, Thing.Pref, Scene.psFey, Lot.realHeight, GameSetting.render, renderBorder, RenderRow.renderData, Card.renderer, rendererEffect, rendererFogBlockSolid, rendererFogFloorSolid, rendererFogRoomBlockSolid, rendererFogRoomSolid, rendererFogRoomWallSolid, rendererFov, rendererFov2, rendererInnerBlock, rendererObjDummy, rendererShore, rendererWallDeco, rendererWaterBlock, renderFootmark, renderSetting, TileType.RepeatBlock, Critter.reverse, Cell.Right, roof, room, Cell.room, roomHeight, GameSetting.RenderSetting.roomHeightMod, EMono.scene, screen, screenHighlight, seaAnimeIndexes, Point.Set(), CardRenderer.SetFirst(), Chara.SetRenderParam(), Thing.SetRenderParam(), SetRoofHeight(), EMono.setting, Cell.shadow, SourcePref.shadow, shadowModStrength, RenderData.shadowPref, shadowStrength, Point.shared, Cell.shore, showAllCards, showBorder, showFullWall, ActionMode.ShowMaskedThings, showRoof, AreaData.showWallItem, Size, Cell.skipRender, TileType.Sky, MapConfig.skyBlockHeight, slopeFixZ, MeshPassParam.snow, snowColor, snowColor2, snowColorToken, snowed, snowLight, snowLimit, Critter.SnowTile, RenderRow.snowTile, CellEffect.source, Chara.source, sourceBlock, Cell.sourceBlock, sourceBridge, Cell.sourceBridge, Chara.sourceCard, Thing.sourceCard, Cell.sourceEffect, sourceFloor, Cell.sourceFloor, FLOOR.sourceIce, Cell.sourceObj, EMono.sources, FLOOR.sourceSnow, MATERIAL.sourceSnow, FLOOR.sourceSnow2, RenderData.stackZ, subtleHighlightArea, Map.sunMap, thingPos, Cell.Things, CellDetail.things, tile, Critter.tile, Footmark.tile, MeshPassParam.tile, BaseGameScreen.tileAlign, MeshBatch.tiles, tileType, Card.TileType, RenderRow.tileType, Trait.tileType, BaseGameScreen.tileWeight, totalFire, Card.trait, transitionFix, AI_Trolley.trolley, ugFix, ugFixBridge, ugFixBridgeBottom, ugFixBridgeTop, Critter.Update(), RenderRow.useAltColor, Zone.UseFog, TileType.UseHangZFix, Trait.UseLowblock, TileType.UseLowWallTiles, TileType.UseMountHeight, TransAnime.v, wallClipMode, waterAnimeIndex, waterEdgeBridgeFix, waterEdgeFix, waterEdgeFixShore, waterEdgeFixShoreSand, EMono.world, MapBounds.x, MeshPassParam.x, Point.x, MeshPassParam.y, SourcePref.y, MapBounds.z, MeshPassParam.z, Point.z, SourcePref.z, and zSetting.

Referenced by Draw().

◆ GetApproximateBlocklight()

int BaseTileMap.GetApproximateBlocklight ( Cell  cell)
inline

Definition at line 3268 of file BaseTileMap.cs.

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 }

References _baseBrightness, cell, Cell.IsSnowTile, Cell.lightB, Cell.lightG, Cell.lightR, snowColor, and snowColorToken.

Referenced by EffectIRenderer.OnUpdate().

◆ GetColorInt()

static int BaseTileMap.GetColorInt ( ref Color  matColor,
int  p 
)
inlinestatic

Definition at line 3648 of file BaseTileMap.cs.

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 }

Referenced by DrawTile(), TileMapElona.DrawTile(), RenderRow.GetColorInt(), SourceBlock.Row.GetRenderParam(), TraitShrine.OnRenderExtra(), ActEffect.ProcAt(), Card.RefreshColor(), Lot.RefreshData(), and Lot.SetBaseRoom().

◆ GetRoofLight()

int BaseTileMap.GetRoofLight ( Lot  lot)
inline

Definition at line 3275 of file BaseTileMap.cs.

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 }
float roofLightSnow
Definition: BaseTileMap.cs:85
float roofLightMod
Definition: BaseTileMap.cs:79

References isSnowCovered, Lot.light, lightLimit, nightRatio, roofLightLimitMod, roofLightMod, roofLightSnow, and snowColorToken.

Referenced by DrawRoof(), and DrawTile().

◆ GetThingPosition()

Vector3 BaseTileMap.GetThingPosition ( Card  tg,
Point  p 
)
inline

Definition at line 3150 of file BaseTileMap.cs.

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 }
static AM_Inspect Inspect
Definition: ActionMode.cs:23
virtual bool IsRoofEditMode(Card c=null)
Definition: ActionMode.cs:311
Vector3 heightMod
Definition: BaseTileMap.cs:56
Definition: Card.cs:11
virtual bool isChara
Definition: Card.cs:1959
virtual CardRow sourceCard
Definition: Card.cs:2007

References Scene.actionMode, Card.altitude, altitudeFix, Cell.blockDir, TileType.CanStack, card, cell, Point.cell, RenderObject.data, detail, Cell.detail, Card.dir, Card.flipX, TileType.GetRampFix(), Cell.HasRamp, SourcePref.height, heightMod, if(), Trait.IgnoreLastStackHeight, Card.ignoreStackHeight, ActionMode.Inspect, Card.isChara, Cell.isFloating, Card.IsInstalled, TileType.IsRamp, ActionMode.IsRoofEditMode(), Cell.IsSnowTile, RenderRow.multisize, Card.Pref, Thing.Pref, Card.renderer, EMono.scene, Cell.sourceBlock, Cell.sourceBridge, Card.sourceCard, Thing.sourceCard, sourceFloor, Cell.sourceFloor, RenderData.stackZ, AM_MoveInstalled.target, CellDetail.things, tileType, Card.TileType, Trait.tileType, Card.trait, TileType.UseMountHeight, SourcePref.z, and zSetting.

Referenced by Card.RenderMarker(), and Card.SetFreePos().

◆ OnActivate()

void BaseTileMap.OnActivate ( BaseGameScreen  _screen)
inline

Definition at line 510 of file BaseTileMap.cs.

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 }
BaseTileSelector tileSelector
BaseTileSelector selector
Definition: BaseTileMap.cs:354
static void InitBytes(int a)
Definition: Rand.cs:11
List< ISyncScreen > syncList
Definition: Scene.cs:131

References altitudeFix, Rand.bytes, SceneProfile.global, Rand.InitBytes(), lightLookUp, Scene.profile, RefreshHeight(), GameSetting.render, renderSetting, EMono.scene, screen, selector, EMono.setting, Scene.syncList, BaseGameScreen.tileSelector, and zSetting.

Referenced by BaseGameScreen.Activate().

◆ RefreshHeight()

void BaseTileMap.RefreshHeight ( )
inline

Definition at line 888 of file BaseTileMap.cs.

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 }
int slopeMod
Definition: Game.cs:60
bool slope
Definition: Game.cs:24

References _heightMod, buildMode, Game.config, EMono.game, heightMod, noSlopMode, Game.Config.slope, and Game.Config.slopeMod.

Referenced by Draw(), TileMapElona.Draw(), AM_Adv.OnActivate(), and OnActivate().

◆ SetRoofHeight()

void BaseTileMap.SetRoofHeight ( MeshPassParam  _param,
Cell  _cell,
int  _cx,
int  _cz,
int  h = 0,
int  altitude = 0,
int  dirWall = -1,
bool  ignoreAltitudeY = false 
)
inline

Definition at line 3657 of file BaseTileMap.cs.

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 }
Vector3 heightModRoofBlock
Definition: BaseTileMap.cs:66

References _heightMod, Cell.Front, Lot.height, heightModRoofBlock, Lot.idRoofStyle, Room.lot, RoofStyle.lowRoofFix, Lot.mh, param, RoofStyle.posFix, Lot.realHeight, Cell.Right, roofFix, roofFix2, roofStyles, room, Cell.room, screen, BaseGameScreen.tileWeight, MeshPassParam.x, and MeshPassParam.y.

Referenced by DrawTile(), Recipe.OnRenderMarker(), and Card.RenderMarker().

Member Data Documentation

◆ _actorPos

Vector3 BaseTileMap._actorPos
protected

Definition at line 432 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ _baseBrightness

float BaseTileMap._baseBrightness

◆ _heightMod

Vector3 BaseTileMap._heightMod

◆ _lightMod

float BaseTileMap._lightMod

Definition at line 305 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ _lowblock

bool BaseTileMap._lowblock
protected

Definition at line 344 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ _rightWallShade

float BaseTileMap._rightWallShade

Definition at line 317 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ _shadowStrength

float BaseTileMap._shadowStrength
protected

Definition at line 414 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ _sourceBlock

SourceBlock.Row BaseTileMap._sourceBlock
protected

Definition at line 492 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ activeCount

int BaseTileMap.activeCount

Definition at line 260 of file BaseTileMap.cs.

Referenced by Draw().

◆ altitudeFix

Vector3 BaseTileMap.altitudeFix

Definition at line 102 of file BaseTileMap.cs.

Referenced by DrawTile(), GetThingPosition(), and OnActivate().

◆ alwaysLowblock

bool BaseTileMap.alwaysLowblock
protected

Definition at line 466 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ ambientShadowFix

Vector3 [] BaseTileMap.ambientShadowFix

Definition at line 112 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ batch

MeshBatch BaseTileMap.batch
protected

Definition at line 430 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ blockLight

float BaseTileMap.blockLight
protected

Definition at line 378 of file BaseTileMap.cs.

Referenced by Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ BlocklightMTP

const int BaseTileMap.BlocklightMTP = 50
static

Definition at line 506 of file BaseTileMap.cs.

◆ BlocklightToken

const int BaseTileMap.BlocklightToken = 262144
static

Definition at line 504 of file BaseTileMap.cs.

◆ bridgeFix

Vector3 BaseTileMap.bridgeFix

Definition at line 94 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ buildMode

bool BaseTileMap.buildMode
protected

Definition at line 340 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and RefreshHeight().

◆ cell

Cell BaseTileMap.cell
protected

◆ cinemaMode

bool BaseTileMap.cinemaMode
protected

Definition at line 464 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ colliderFix

Vector3 BaseTileMap.colliderFix

Definition at line 43 of file BaseTileMap.cs.

Referenced by Draw().

◆ cornerWallFix

Vector3 BaseTileMap.cornerWallFix

Definition at line 96 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ cornerWallFix2

Vector3 BaseTileMap.cornerWallFix2

Definition at line 98 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ cornerWallFix3

Vector3 BaseTileMap.cornerWallFix3

Definition at line 100 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ count

int BaseTileMap.count

Definition at line 38 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ currentHeight

int BaseTileMap.currentHeight
protected

Definition at line 442 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), and DrawTile().

◆ currentLot

Lot BaseTileMap.currentLot
protected

Definition at line 490 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ currentRoom

Room BaseTileMap.currentRoom
protected

Definition at line 484 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), and DrawTile().

◆ cx

int BaseTileMap.cx

Definition at line 254 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawRoof(), DrawTile(), and TileMapElona.DrawTile().

◆ cz

int BaseTileMap.cz

Definition at line 257 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawRoof(), DrawTile(), and TileMapElona.DrawTile().

◆ defaultBlockHeight

float BaseTileMap.defaultBlockHeight
protected

Definition at line 418 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ defaultInnerMode

InnerMode BaseTileMap.defaultInnerMode

Definition at line 90 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ DefColor

const int BaseTileMap.DefColor = 104025
static

Definition at line 502 of file BaseTileMap.cs.

◆ destBrightness

float BaseTileMap.destBrightness
protected

Definition at line 404 of file BaseTileMap.cs.

Referenced by Draw().

◆ detail

CellDetail BaseTileMap.detail
protected

Definition at line 476 of file BaseTileMap.cs.

Referenced by DrawTile(), TileMapElona.DrawTile(), and GetThingPosition().

◆ edgeBlockFix

Vector3 BaseTileMap.edgeBlockFix

Definition at line 92 of file BaseTileMap.cs.

Referenced by Draw().

◆ floatSpeed

float BaseTileMap.floatSpeed

Definition at line 122 of file BaseTileMap.cs.

Referenced by Draw().

◆ floatTimer

float BaseTileMap.floatTimer
protected

Definition at line 402 of file BaseTileMap.cs.

Referenced by Draw().

◆ floatV

int BaseTileMap.floatV = 1

Definition at line 263 of file BaseTileMap.cs.

Referenced by Draw(), and CardActor.OnRender().

◆ floatY

float BaseTileMap.floatY

Definition at line 323 of file BaseTileMap.cs.

Referenced by Draw(), DrawTile(), and CardActor.OnRender().

◆ floorDir

int BaseTileMap.floorDir
protected

Definition at line 448 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ floorLight

float BaseTileMap.floorLight
protected

Definition at line 380 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ floorLight2

float BaseTileMap.floorLight2
protected

Definition at line 382 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ floorMatColor

int BaseTileMap.floorMatColor
protected

Definition at line 438 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ floorShadowStrength

float BaseTileMap.floorShadowStrength

Definition at line 326 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ fogBounds

bool BaseTileMap.fogBounds
protected

Definition at line 456 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ fogBrightness

float BaseTileMap.fogBrightness
protected

Definition at line 416 of file BaseTileMap.cs.

Referenced by Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ fogged

bool BaseTileMap.fogged

Definition at line 299 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ fogTile

int BaseTileMap.fogTile

Definition at line 120 of file BaseTileMap.cs.

◆ forceShowHang

bool BaseTileMap.forceShowHang
static

Definition at line 36 of file BaseTileMap.cs.

Referenced by Draw().

◆ freePos

Vector3 BaseTileMap.freePos
protected

Definition at line 434 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ groundLights

byte [] BaseTileMap.groundLights

Definition at line 266 of file BaseTileMap.cs.

◆ hasBridge

bool BaseTileMap.hasBridge
protected

Definition at line 342 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ height

int BaseTileMap.height
protected

Definition at line 440 of file BaseTileMap.cs.

Referenced by Draw(), DrawRoof(), DrawTile(), and TileMapElona.DrawTile().

◆ heightBlockSize

float BaseTileMap.heightBlockSize

Definition at line 48 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ heightLightMod

float BaseTileMap.heightLightMod

Definition at line 314 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ heightLimitDeco

float BaseTileMap.heightLimitDeco

Definition at line 54 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ heightMod

Vector3 BaseTileMap.heightMod

Definition at line 56 of file BaseTileMap.cs.

Referenced by GetThingPosition(), and RefreshHeight().

◆ heightModDeco

float BaseTileMap.heightModDeco

Definition at line 52 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ heightModRoofBlock

Vector3 BaseTileMap.heightModRoofBlock

Definition at line 66 of file BaseTileMap.cs.

Referenced by SetRoofHeight().

◆ hideHang

bool BaseTileMap.hideHang

Definition at line 290 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ hideRoomFog

bool BaseTileMap.hideRoomFog

Definition at line 281 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), and TileMapElona.DrawTile().

◆ highlightArea

bool BaseTileMap.highlightArea

Definition at line 275 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ highlightCells

bool BaseTileMap.highlightCells
protected

Definition at line 462 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ iconMode

CardIconMode BaseTileMap.iconMode
protected

Definition at line 336 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ index

int BaseTileMap.index
protected

Definition at line 362 of file BaseTileMap.cs.

Referenced by DrawRoof(), DrawTile(), and TileMapElona.DrawTile().

◆ innerMode

InnerMode BaseTileMap.innerMode
protected

Definition at line 233 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ isIndoor

bool BaseTileMap.isIndoor
protected

Definition at line 346 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ isMining

bool BaseTileMap.isMining
protected

Definition at line 338 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ isSeen

bool BaseTileMap.isSeen
protected

Definition at line 452 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ isSnowCovered

bool BaseTileMap.isSnowCovered
protected

Definition at line 460 of file BaseTileMap.cs.

Referenced by Draw(), DrawRoof(), DrawTile(), and GetRoofLight().

◆ lastRoom

Room BaseTileMap.lastRoom
protected

Definition at line 486 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ layerGroundLights

NoiseLayer BaseTileMap.layerGroundLights

Definition at line 131 of file BaseTileMap.cs.

◆ light

float BaseTileMap.light
protected

Definition at line 384 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ lightLimit

float BaseTileMap.lightLimit
protected

◆ lightLookUp

float [] BaseTileMap.lightLookUp

Definition at line 302 of file BaseTileMap.cs.

Referenced by DrawTile(), TileMapElona.DrawTile(), and OnActivate().

◆ lightSetting

SceneLightProfile BaseTileMap.lightSetting
protected

Definition at line 496 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ liquidLv

int BaseTileMap.liquidLv
protected

Definition at line 360 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ lotLight

float BaseTileMap.lotLight

Definition at line 81 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ lotLight2

float BaseTileMap.lotLight2

Definition at line 83 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ lowBlock

bool BaseTileMap.lowBlock

Definition at line 269 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ lowblockTimer

float BaseTileMap.lowblockTimer

Definition at line 311 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ lowObj

bool BaseTileMap.lowObj

Definition at line 272 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ lowWallObjAltitude

int BaseTileMap.lowWallObjAltitude
protected

Definition at line 370 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ map

Map BaseTileMap.map
protected

Definition at line 350 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawRoof(), DrawTile(), and TileMapElona.DrawTile().

◆ matBlock

SourceMaterial.Row BaseTileMap.matBlock
protected

Definition at line 372 of file BaseTileMap.cs.

Referenced by DrawRoof(), DrawTile(), and TileMapElona.DrawTile().

◆ matBridge

SourceMaterial.Row BaseTileMap.matBridge
protected

Definition at line 376 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ matFloor

SourceMaterial.Row BaseTileMap.matFloor
protected

Definition at line 374 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ maxColliderCheck

int BaseTileMap.maxColliderCheck

Definition at line 45 of file BaseTileMap.cs.

Referenced by Draw().

◆ maxFloat

int BaseTileMap.maxFloat

Definition at line 126 of file BaseTileMap.cs.

Referenced by Draw().

◆ maxHeight

float BaseTileMap.maxHeight
protected

Definition at line 396 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ modSublight1

float BaseTileMap.modSublight1
protected

Definition at line 408 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), and TileMapElona.DrawTile().

◆ modSublight2

float BaseTileMap.modSublight2
protected

Definition at line 410 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ mouseCollider

Collider2D BaseTileMap.mouseCollider

Definition at line 41 of file BaseTileMap.cs.

◆ mx

int BaseTileMap.mx

Definition at line 242 of file BaseTileMap.cs.

Referenced by Draw().

◆ mz

int BaseTileMap.mz

Definition at line 245 of file BaseTileMap.cs.

Referenced by Draw(), and WidgetDebug.UpdateText().

◆ nightRatio

float BaseTileMap.nightRatio
protected

Definition at line 426 of file BaseTileMap.cs.

Referenced by Draw(), DrawTile(), and GetRoofLight().

◆ noRoofMode

bool BaseTileMap.noRoofMode

Definition at line 296 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ noSlopMode

bool BaseTileMap.noSlopMode
private

Definition at line 498 of file BaseTileMap.cs.

Referenced by Draw(), DrawTile(), and RefreshHeight().

◆ orgPos

Vector3 BaseTileMap.orgPos
protected

Definition at line 472 of file BaseTileMap.cs.

◆ orgX

float BaseTileMap.orgX
protected

Definition at line 388 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ orgY

float BaseTileMap.orgY
protected

Definition at line 390 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ orgZ

float BaseTileMap.orgZ
protected

Definition at line 392 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ param

RenderParam BaseTileMap.param = new RenderParam()
protected

Definition at line 428 of file BaseTileMap.cs.

Referenced by Draw(), DrawRoof(), DrawTile(), TileMapElona.DrawTile(), and SetRoofHeight().

◆ pass

MeshPass BaseTileMap.pass
protected

Definition at line 352 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ passArea

MeshPass BaseTileMap.passArea

Definition at line 141 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ passAutoTile

MeshPass BaseTileMap.passAutoTile

Definition at line 175 of file BaseTileMap.cs.

Referenced by DrawTile(), and TextureManager.Init().

◆ passAutoTileWater

MeshPass BaseTileMap.passAutoTileWater

◆ passBlock

MeshPass BaseTileMap.passBlock

Definition at line 147 of file BaseTileMap.cs.

Referenced by TextureManager.Init(), Recipe.OnRenderMarker(), and Core.Update().

◆ passBlockEx

MeshPass BaseTileMap.passBlockEx

Definition at line 161 of file BaseTileMap.cs.

Referenced by TextureManager.Init(), and Recipe.OnRenderMarker().

◆ passBlockMarker

MeshPass BaseTileMap.passBlockMarker

Definition at line 179 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passChara

MeshPass BaseTileMap.passChara

Definition at line 187 of file BaseTileMap.cs.

Referenced by PostEffectProfile.Apply(), and TextureManager.Init().

◆ passCharaL

MeshPass BaseTileMap.passCharaL

Definition at line 189 of file BaseTileMap.cs.

Referenced by PostEffectProfile.Apply(), and TextureManager.Init().

◆ passCharaLL

MeshPass BaseTileMap.passCharaLL

Definition at line 193 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passCharaLW

MeshPass BaseTileMap.passCharaLW

Definition at line 191 of file BaseTileMap.cs.

Referenced by PostEffectProfile.Apply(), and TextureManager.Init().

◆ passDecal

MeshPass BaseTileMap.passDecal

Definition at line 157 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ passEdge

MeshPass BaseTileMap.passEdge

Definition at line 173 of file BaseTileMap.cs.

Referenced by DrawTile(), and TextureManager.Init().

◆ passFloor

MeshPass BaseTileMap.passFloor

◆ passFloorEx

MeshPass BaseTileMap.passFloorEx

Definition at line 163 of file BaseTileMap.cs.

Referenced by TextureManager.Init(), and Recipe.OnRenderMarker().

◆ passFloorMarker

MeshPass BaseTileMap.passFloorMarker

Definition at line 181 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passFloorWater

◆ passFog

MeshPass BaseTileMap.passFog

Definition at line 169 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passFov

MeshPass BaseTileMap.passFov

Definition at line 171 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passGuideBlock

MeshPass BaseTileMap.passGuideBlock

◆ passGuideFloor

MeshPass BaseTileMap.passGuideFloor

Definition at line 139 of file BaseTileMap.cs.

Referenced by TaskDesignation.DrawMarker(), DrawTile(), and GameUpdater.Update().

◆ passIcon

MeshPass BaseTileMap.passIcon

Definition at line 185 of file BaseTileMap.cs.

Referenced by UIInspector.DrawHighlight(), and TextureManager.Init().

◆ passInner

MeshPass BaseTileMap.passInner

Definition at line 167 of file BaseTileMap.cs.

Referenced by Draw(), and TextureManager.Init().

◆ passLiquid

◆ passObj

MeshPass BaseTileMap.passObj

Definition at line 153 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passObjL

MeshPass BaseTileMap.passObjL

Definition at line 155 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passObjS

MeshPass BaseTileMap.passObjS

Definition at line 149 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passObjSS

MeshPass BaseTileMap.passObjSS

Definition at line 151 of file BaseTileMap.cs.

Referenced by DrawTile(), and TextureManager.Init().

◆ passRamp

MeshPass BaseTileMap.passRamp

Definition at line 143 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passRoof

MeshPass BaseTileMap.passRoof

Definition at line 159 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ passShadow

◆ passShore

MeshPass BaseTileMap.passShore

Definition at line 195 of file BaseTileMap.cs.

Referenced by DrawTile(), and TextureManager.Init().

◆ passWaterBlock

MeshPass BaseTileMap.passWaterBlock

Definition at line 183 of file BaseTileMap.cs.

Referenced by TextureManager.Init().

◆ pcMaxLight

float BaseTileMap.pcMaxLight
protected

Definition at line 386 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), and TileMapElona.DrawTile().

◆ pcX

int BaseTileMap.pcX
protected

Definition at line 444 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), and TileMapElona.DrawTile().

◆ pcZ

int BaseTileMap.pcZ
protected

Definition at line 446 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), and TileMapElona.DrawTile().

◆ rays

RaycastHit2D [] BaseTileMap.rays = new RaycastHit2D[1]
protected

Definition at line 334 of file BaseTileMap.cs.

Referenced by Draw().

◆ renderBorder

RenderData BaseTileMap.renderBorder

Definition at line 211 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ rendererBlockMarker

RenderData BaseTileMap.rendererBlockMarker

Definition at line 199 of file BaseTileMap.cs.

Referenced by Recipe.OnRenderMarker().

◆ rendererEffect

RenderDataEffect BaseTileMap.rendererEffect

Definition at line 229 of file BaseTileMap.cs.

Referenced by RenderData.DrawRepeatTo(), DrawRoof(), DrawTile(), and TileMapElona.DrawTile().

◆ rendererFloorMarker

RenderData BaseTileMap.rendererFloorMarker

Definition at line 201 of file BaseTileMap.cs.

Referenced by Recipe.OnRenderMarker().

◆ rendererFogBlockSolid

RenderData BaseTileMap.rendererFogBlockSolid

Definition at line 213 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ rendererFogFloorSolid

RenderData BaseTileMap.rendererFogFloorSolid

Definition at line 215 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ rendererFogRoomBlockSolid

RenderData BaseTileMap.rendererFogRoomBlockSolid

Definition at line 219 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ rendererFogRoomSolid

RenderData BaseTileMap.rendererFogRoomSolid

Definition at line 217 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ rendererFogRoomWallSolid

RenderData BaseTileMap.rendererFogRoomWallSolid

Definition at line 221 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ rendererFov

RenderData BaseTileMap.rendererFov

Definition at line 205 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ rendererFov2

RenderData BaseTileMap.rendererFov2

Definition at line 207 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ rendererInnerBlock

RenderData BaseTileMap.rendererInnerBlock

Definition at line 203 of file BaseTileMap.cs.

Referenced by DrawTile(), TileMapElona.DrawTile(), and CoreDebug.UpdateAlways().

◆ rendererObjDummy

RenderDataObjDummy BaseTileMap.rendererObjDummy

Definition at line 227 of file BaseTileMap.cs.

Referenced by Core.Awake(), CardRenderer.Draw(), and DrawTile().

◆ rendererShore

RenderData BaseTileMap.rendererShore

Definition at line 209 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ rendererWallDeco

RenderData BaseTileMap.rendererWallDeco

Definition at line 223 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ rendererWaterBlock

RenderData BaseTileMap.rendererWaterBlock

Definition at line 225 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ renderFootmark

RenderData BaseTileMap.renderFootmark

Definition at line 197 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ renderSetting

GameSetting.RenderSetting BaseTileMap.renderSetting
protected

Definition at line 356 of file BaseTileMap.cs.

Referenced by DrawTile(), TileMapElona.DrawTile(), and OnActivate().

◆ rightWallShade

float BaseTileMap.rightWallShade

Definition at line 69 of file BaseTileMap.cs.

Referenced by Draw().

◆ roof

bool BaseTileMap.roof
protected

Definition at line 450 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ roofFix

Vector3 BaseTileMap.roofFix

Definition at line 73 of file BaseTileMap.cs.

Referenced by DrawRoof(), and SetRoofHeight().

◆ roofFix2

Vector3 BaseTileMap.roofFix2

Definition at line 75 of file BaseTileMap.cs.

Referenced by DrawRoof(), and SetRoofHeight().

◆ roofFix3

Vector3 BaseTileMap.roofFix3

Definition at line 77 of file BaseTileMap.cs.

Referenced by DrawRoof().

◆ roofLightLimitMod

float BaseTileMap.roofLightLimitMod

Definition at line 320 of file BaseTileMap.cs.

Referenced by Draw(), and GetRoofLight().

◆ roofLightMod

float BaseTileMap.roofLightMod

Definition at line 79 of file BaseTileMap.cs.

Referenced by GetRoofLight().

◆ roofLightSnow

float BaseTileMap.roofLightSnow

Definition at line 85 of file BaseTileMap.cs.

Referenced by GetRoofLight().

◆ roofRampFix

Vector3 BaseTileMap.roofRampFix

Definition at line 71 of file BaseTileMap.cs.

Referenced by DrawRoof().

◆ roofStyles

RoofStyle [] BaseTileMap.roofStyles

◆ room

Room BaseTileMap.room
protected

Definition at line 488 of file BaseTileMap.cs.

Referenced by Draw(), DrawRoof(), DrawTile(), TileMapElona.DrawTile(), and SetRoofHeight().

◆ roomHeight

float BaseTileMap.roomHeight
protected

Definition at line 394 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ screen

new BaseGameScreen BaseTileMap.screen

◆ screenHighlight

ScreenHighlight BaseTileMap.screenHighlight

Definition at line 332 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ seaAnimeIndexes

int [] BaseTileMap.seaAnimeIndexes

Definition at line 128 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ selector

BaseTileSelector BaseTileMap.selector
protected

Definition at line 354 of file BaseTileMap.cs.

Referenced by OnActivate().

◆ shadowModStrength

float BaseTileMap.shadowModStrength

Definition at line 124 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ shadowStrength

float BaseTileMap.shadowStrength
protected

Definition at line 412 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ showAllCards

bool BaseTileMap.showAllCards
protected

Definition at line 454 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ showBorder

bool BaseTileMap.showBorder
protected

Definition at line 468 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ showFullWall

bool BaseTileMap.showFullWall

Definition at line 287 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ showRoof

bool BaseTileMap.showRoof

Definition at line 284 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), and DrawTile().

◆ Size

int BaseTileMap.Size

Definition at line 236 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawRoof(), DrawTile(), and TileMapElona.DrawTile().

◆ SizeXZ

int BaseTileMap.SizeXZ

Definition at line 239 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ slopeFixZ

float BaseTileMap.slopeFixZ

Definition at line 50 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ snowColor

float BaseTileMap.snowColor
protected

Definition at line 422 of file BaseTileMap.cs.

Referenced by Draw(), DrawTile(), and GetApproximateBlocklight().

◆ snowColor2

float BaseTileMap.snowColor2
protected

Definition at line 424 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ snowColorToken

int BaseTileMap.snowColorToken
protected

Definition at line 366 of file BaseTileMap.cs.

Referenced by Draw(), DrawTile(), GetApproximateBlocklight(), and GetRoofLight().

◆ snowed

bool BaseTileMap.snowed
protected

Definition at line 458 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ snowLight

float BaseTileMap.snowLight
protected

Definition at line 398 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ snowLimit

float BaseTileMap.snowLimit
protected

Definition at line 420 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ sourceBlock

SourceBlock.Row BaseTileMap.sourceBlock
protected

Definition at line 478 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ sourceBridge

SourceFloor.Row BaseTileMap.sourceBridge
protected

Definition at line 482 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ sourceFloor

SourceFloor.Row BaseTileMap.sourceFloor
protected

Definition at line 480 of file BaseTileMap.cs.

Referenced by DrawTile(), TileMapElona.DrawTile(), and GetThingPosition().

◆ subtleHighlightArea

bool BaseTileMap.subtleHighlightArea

Definition at line 278 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ TestPoint

Point BaseTileMap.TestPoint = new Point()

Definition at line 231 of file BaseTileMap.cs.

Referenced by Draw().

◆ thingPos

Vector3 BaseTileMap.thingPos
protected

Definition at line 470 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ tile

int BaseTileMap.tile
protected

Definition at line 436 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ tileType

TileType BaseTileMap.tileType
protected

Definition at line 494 of file BaseTileMap.cs.

Referenced by DrawTile(), TileMapElona.DrawTile(), and GetThingPosition().

◆ totalFire

int BaseTileMap.totalFire
protected

Definition at line 364 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), DrawTile(), and TileMapElona.DrawTile().

◆ transitionFix

Vector3 [] BaseTileMap.transitionFix

Definition at line 114 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ ugFix

Vector3 BaseTileMap.ugFix

Definition at line 58 of file BaseTileMap.cs.

Referenced by DrawTile(), and TileMapElona.DrawTile().

◆ ugFixBridge

Vector3 BaseTileMap.ugFixBridge

Definition at line 60 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ ugFixBridgeBottom

Vector3 BaseTileMap.ugFixBridgeBottom

Definition at line 62 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ ugFixBridgeTop

Vector3 BaseTileMap.ugFixBridgeTop

Definition at line 64 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ usingHouseBoard

bool BaseTileMap.usingHouseBoard

Definition at line 293 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ wallClipMode

WallClipMode BaseTileMap.wallClipMode

Definition at line 88 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ wallHangFix

Vector3 [] BaseTileMap.wallHangFix

Definition at line 116 of file BaseTileMap.cs.

Referenced by TileTypeWallHang.GetMountHeight().

◆ waterAnimeIndex

int BaseTileMap.waterAnimeIndex
protected

Definition at line 368 of file BaseTileMap.cs.

Referenced by Draw(), and DrawTile().

◆ waterAnimeTimer

float BaseTileMap.waterAnimeTimer
protected

Definition at line 400 of file BaseTileMap.cs.

Referenced by Draw().

◆ waterEdgeBlockFix

Vector3 [] BaseTileMap.waterEdgeBlockFix

Definition at line 118 of file BaseTileMap.cs.

◆ waterEdgeBridgeFix

Vector3 BaseTileMap.waterEdgeBridgeFix

Definition at line 106 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ waterEdgeFix

Vector3 BaseTileMap.waterEdgeFix

Definition at line 104 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ waterEdgeFixShore

Vector3 BaseTileMap.waterEdgeFixShore

Definition at line 108 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ waterEdgeFixShoreSand

Vector3 BaseTileMap.waterEdgeFixShoreSand

Definition at line 110 of file BaseTileMap.cs.

Referenced by DrawTile().

◆ x

int BaseTileMap.x

Definition at line 248 of file BaseTileMap.cs.

Referenced by Draw(), TileMapElona.Draw(), and RenderRow.GetRenderParam().

◆ z

int BaseTileMap.z

Definition at line 251 of file BaseTileMap.cs.

Referenced by Draw(), and TileMapElona.Draw().

◆ zSetting

GameSetting.RenderSetting.ZSetting BaseTileMap.zSetting
protected

Definition at line 358 of file BaseTileMap.cs.

Referenced by DrawTile(), TileMapElona.DrawTile(), GetThingPosition(), and OnActivate().

Property Documentation

◆ HitPoint

Point BaseTileMap.HitPoint
get

Definition at line 508 of file BaseTileMap.cs.

Referenced by Draw().


The documentation for this class was generated from the following file: