diff --git a/UndertaleModLib/Models/UndertaleRoom.cs b/UndertaleModLib/Models/UndertaleRoom.cs
index 1be0e33c4..649f5ce47 100644
--- a/UndertaleModLib/Models/UndertaleRoom.cs
+++ b/UndertaleModLib/Models/UndertaleRoom.cs
@@ -3,6 +3,7 @@
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Drawing;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -42,7 +43,8 @@ public enum RoomEntryFlags : uint
         public float GravityX { get; set; } = 0;
         public float GravityY { get; set; } = 10;
         public float MetersPerPixel { get; set; } = 0.1f;
-        public double Grid { get; set; } = 16d;
+        public double GridWidth { get; set; } = 16d;
+        public double GridHeight { get; set; } = 16d;
         public double GridThicknessPx { get; set; } = 1d;
         public UndertalePointerList<Background> Backgrounds { get; private set; } = new UndertalePointerList<Background>();
         public UndertalePointerList<View> Views { get; private set; } = new UndertalePointerList<View>();
@@ -237,6 +239,30 @@ public void SetupRoom()
             }
             foreach (UndertaleRoom.Background bgnd in Backgrounds)
                 bgnd.ParentRoom = this;
+
+            // Automagically set the grid size to whatever most tiles are sized
+
+            Dictionary<Point, uint> tileSizes = new Dictionary<Point, uint>();
+
+            // Loop through each tile and save how many times their sizes are used
+            foreach (UndertaleRoom.Tile tile in Tiles)
+            {
+                Point scale = new((int)tile.Width, (int)tile.Height);
+                if (tileSizes.ContainsKey(scale))
+                {
+                    tileSizes[scale]++;
+                } else {
+                    tileSizes.Add(scale, 1);
+                }
+            }
+
+            // If tiles exist at all, grab the most used tile size and use that as our grid size
+            if (tileSizes.Count > 0)
+            {
+                var largestKey = tileSizes.Aggregate((x, y) => x.Value > y.Value ? x : y).Key;
+                GridWidth = largestKey.X;
+                GridHeight = largestKey.Y;
+            }
         }
 
         public override string ToString()
diff --git a/UndertaleModTool/Converters/GridConverter.cs b/UndertaleModTool/Converters/GridConverter.cs
index 80784b86b..4f2e28a20 100644
--- a/UndertaleModTool/Converters/GridConverter.cs
+++ b/UndertaleModTool/Converters/GridConverter.cs
@@ -9,14 +9,14 @@
 
 namespace UndertaleModTool
 {
-    public class GridConverter : IValueConverter
+    public class GridConverter : IMultiValueConverter
     {
-        public object Convert(object value, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)
+        public object Convert(object[] values, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)
         {
-            return "0,0,"+value.ToString()+","+value.ToString();
+            return new Rect(0, 0, (double)values[0], (double)values[1]);
         }
 
-        public object ConvertBack(object value, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)
+        public object[] ConvertBack(object value, System.Type[] targetType, object parameter, System.Globalization.CultureInfo culture)
         {
             return null;
         }
diff --git a/UndertaleModTool/Editors/UndertaleRoomEditor.xaml b/UndertaleModTool/Editors/UndertaleRoomEditor.xaml
index 6933273c3..36217cfde 100644
--- a/UndertaleModTool/Editors/UndertaleRoomEditor.xaml
+++ b/UndertaleModTool/Editors/UndertaleRoomEditor.xaml
@@ -351,11 +351,14 @@
                                 <TextBox Grid.Column="1" Margin="3" Text="{Binding GravityY}" ToolTip="Y"/>
                             </Grid>
 
-                            <TextBlock Grid.Row="12" Grid.Column="0" Margin="3">Grid</TextBlock>
-                            <TextBox Grid.Row="12" Grid.Column="1" Margin="3" Text="{Binding Grid}"/>
+                            <TextBlock Grid.Row="12" Grid.Column="0" Margin="3">Grid Width</TextBlock>
+                            <TextBox Grid.Row="12" Grid.Column="1" Margin="3" Text="{Binding GridWidth}"/>
 
-                            <TextBlock Grid.Row="13" Grid.Column="0" Margin="3">Grid Thickness</TextBlock>
-                            <TextBox Grid.Row="13" Grid.Column="1" Margin="3" Text="{Binding GridThicknessPx}"/>
+                            <TextBlock Grid.Row="13" Grid.Column="0" Margin="3">Grid Height</TextBlock>
+                            <TextBox Grid.Row="13" Grid.Column="1" Margin="3" Text="{Binding GridHeight}"/>
+
+                            <TextBlock Grid.Row="14" Grid.Column="0" Margin="3">Grid Thickness</TextBlock>
+                            <TextBox Grid.Row="14" Grid.Column="1" Margin="3" Text="{Binding GridThicknessPx}"/>
                         </Grid>
                     </DataTemplate>
 
@@ -610,7 +613,7 @@
                             </Grid>
 
                             <Viewbox Grid.Row="3" Grid.Column="1" Margin="3" Stretch="Uniform" StretchDirection="DownOnly">
-                                <Canvas Width="{Binding Tpag.BoundingWidth}" Height="{Binding Tpag.BoundingHeight}" SnapsToDevicePixels="True" MouseMove="RectangleTile_MouseMove" MouseUp="RectangleTile_MouseUp">
+                                <Canvas Width="{Binding Tpag.BoundingWidth}" Height="{Binding Tpag.BoundingHeight}" SnapsToDevicePixels="True" MouseDown="RectangleTile_MouseDown" MouseMove="RectangleTile_MouseMove">
                                     <Border>
                                         <Border.Background>
                                             <DrawingBrush Stretch="None" TileMode="Tile" Viewport="0,0,20,20" ViewportUnits="Absolute">
@@ -624,7 +627,7 @@
                                         </Border.Background>
                                         <local:UndertaleTexturePageItemDisplay DataContext="{Binding Tpag}"/>
                                     </Border>
-                                    <Rectangle Canvas.Left="{Binding SourceX}" Canvas.Top="{Binding SourceY}" Width="{Binding Width}" Height="{Binding Height}" Stroke="#FFB23131" Panel.ZIndex="50" StrokeThickness="2" MouseDown="RectangleTile_MouseDown" SnapsToDevicePixels="True">
+                                    <Rectangle x:Name="TileSelector" Canvas.Left="{Binding SourceX}" Canvas.Top="{Binding SourceY}" Width="{Binding Width}" Height="{Binding Height}" Stroke="#FFB23131" Panel.ZIndex="50" StrokeThickness="2" SnapsToDevicePixels="True">
                                         <Rectangle.Fill>
                                             <SolidColorBrush Color="Red" Opacity=".1"/>
                                         </Rectangle.Fill>
@@ -903,8 +906,8 @@
 
         <GridSplitter Grid.Column="0" Grid.Row="1" HorizontalAlignment="Stretch" VerticalAlignment="Center" ShowsPreview="True" Width="Auto" Height="3"/>
 
-        <ScrollViewer Margin="0,8,0,0" Grid.Column="0" Grid.Row="2" HorizontalScrollBarVisibility="Visible" VerticalScrollBarVisibility="Visible" ScrollChanged="ScrollViewer_ScrollChanged">
-            <ItemsControl Name="RoomGraphics" Background="Black" MouseMove="Rectangle_MouseMove" MouseWheel="Canvas_MouseWheel">
+        <ScrollViewer Name="RoomGraphicsScroll" Margin="0,8,0,0" Grid.Column="0" Grid.Row="2" HorizontalScrollBarVisibility="Visible" VerticalScrollBarVisibility="Visible" ScrollChanged="ScrollViewer_ScrollChanged">
+            <ItemsControl Name="RoomGraphics" Background="Black" MouseDown="RectangleBackground_MouseDown" MouseMove="RectangleBackground_MouseMove" MouseUp="RectangleBackground_MouseUp" MouseWheel="Canvas_MouseWheel">
                 <ItemsControl.Style>
                     <Style TargetType="ItemsControl">
                         <Setter Property="ItemsSource" Value="{Binding Source={StaticResource AllObjectsGMS1}}"/>
@@ -919,16 +922,29 @@
                 </ItemsControl.Style>
                 <ItemsControl.ItemsPanel>
                     <ItemsPanelTemplate>
-                        <Canvas Width="{Binding Width}" Height="{Binding Height}" IsItemsHost="True" AllowDrop="True" DragOver="Canvas_DragOver" Drop="Canvas_Drop">
+                        <Canvas Name="RoomCanvas" Width="{Binding Width}" Height="{Binding Height}" IsItemsHost="True" AllowDrop="True" DragOver="Canvas_DragOver" Drop="Canvas_Drop" Loaded="Canvas_Loaded">
                             <!--<Canvas.RenderTransform>
                                 <ScaleTransform ScaleX="2" ScaleY="2"></ScaleTransform>
                             </Canvas.RenderTransform>-->
                             <Canvas.Background>
-                                <DrawingBrush TileMode="Tile" Viewport="{Binding Grid, Converter={StaticResource GridConverter}}" ViewportUnits="Absolute">
+                                <DrawingBrush TileMode="Tile" ViewportUnits="Absolute">
+                                    <DrawingBrush.Viewport>
+                                        <MultiBinding Converter="{StaticResource GridConverter}">
+                                            <Binding Path="GridWidth"></Binding>
+                                            <Binding Path="GridHeight"></Binding>
+                                        </MultiBinding>
+                                    </DrawingBrush.Viewport>
                                     <DrawingBrush.Drawing>
                                         <GeometryDrawing>
                                             <GeometryDrawing.Geometry>
-                                                <RectangleGeometry Rect="{Binding Grid, Converter={StaticResource GridConverter}}"/>
+                                                <RectangleGeometry>
+                                                    <RectangleGeometry.Rect>
+                                                        <MultiBinding Converter="{StaticResource GridConverter}">
+                                                            <Binding Path="GridWidth"></Binding>
+                                                            <Binding Path="GridHeight"></Binding>
+                                                        </MultiBinding>
+                                                    </RectangleGeometry.Rect>
+                                                </RectangleGeometry>
                                             </GeometryDrawing.Geometry>
                                             <GeometryDrawing.Pen>
                                                 <Pen Brush="Gray" Thickness="{Binding GridThicknessPx}"/>
diff --git a/UndertaleModTool/Editors/UndertaleRoomEditor.xaml.cs b/UndertaleModTool/Editors/UndertaleRoomEditor.xaml.cs
index 9268f4fe3..a3c9e8484 100644
--- a/UndertaleModTool/Editors/UndertaleRoomEditor.xaml.cs
+++ b/UndertaleModTool/Editors/UndertaleRoomEditor.xaml.cs
@@ -114,12 +114,31 @@ private void TreeView_SelectedItemChanged(object sender, RoutedPropertyChangedEv
         }
 
         private UndertaleObject movingObj;
-        private UndertaleRoom.Tile movingTile;
-        private double hotpointX, hotpointY, hotpointTileX, hotpointTileY;
+        private double hotpointX, hotpointY;
         private ScaleTransform canvasSt = new ScaleTransform();
 
+        private Point GetGridMouseCoordinates(Point mousePos, UndertaleRoom room)
+        {
+            int gridWidth = Math.Max(Convert.ToInt32(room.GridWidth), 1);
+            int gridHeight = Math.Max(Convert.ToInt32(room.GridHeight), 1);
+
+            if (Keyboard.Modifiers.HasFlag(ModifierKeys.Control))
+            {
+                gridWidth /= 2;
+                gridHeight /= 2;
+            }
+            else if (Keyboard.Modifiers.HasFlag(ModifierKeys.Shift))
+            {
+                gridWidth *= 2;
+                gridHeight *= 2;
+            }
+
+            return new Point(Math.Floor(mousePos.X / gridWidth) * gridWidth, Math.Floor(mousePos.Y / gridHeight) * gridHeight);
+        }
+
         private void Rectangle_MouseDown(object sender, MouseButtonEventArgs e)
         {
+            e.Handled = true;
             UndertaleObject clickedObj = (sender as Rectangle).DataContext as UndertaleObject;
             UndertaleRoom room = this.DataContext as UndertaleRoom;
             UndertaleRoom.Layer layer = ObjectEditor.Content as UndertaleRoom.Layer;
@@ -229,64 +248,115 @@ private void Rectangle_MouseDown(object sender, MouseButtonEventArgs e)
             }
         }
 
-        private void RectangleTile_MouseDown(object sender, MouseButtonEventArgs e)
-        {
-            var element = sender as Rectangle;
-            UndertaleRoom.Tile clickedObj = (sender as Rectangle).DataContext as UndertaleRoom.Tile;
-            var mousePos = e.GetPosition(element.Parent as UIElement);
-            movingTile = clickedObj;
-            hotpointTileX = mousePos.X - movingTile.SourceX;
-            hotpointTileY = mousePos.Y - movingTile.SourceY;
-        }
+        bool placingTiles = false;
+        List<Point> placedTiles = new();
 
-        private void RectangleTile_MouseMove(object sender, MouseEventArgs e)
+        private void PaintObjects(Point gridMouse, UndertaleObject other, UndertaleRoom room)
         {
-            if (movingTile != null)
+            if ((Mouse.LeftButton != MouseButtonState.Pressed) || !(Keyboard.Modifiers.HasFlag(ModifierKeys.Alt)))
             {
-                var element = sender as UIElement;
-                UndertaleRoom room = this.DataContext as UndertaleRoom;
-
-                var maxX = movingTile.Tpag.BoundingWidth;
-                var maxY = movingTile.Tpag.BoundingHeight;
-
-                var mousePos = e.GetPosition(element);
-
-                int tgtX = (int)Math.Clamp(mousePos.X - hotpointTileX, 0, maxX - movingTile.Width);
-                int tgtY = (int)Math.Clamp(mousePos.Y - hotpointTileY, 0, maxY - movingTile.Height);
+                placingTiles = false;
+                return;
+            }
+            UndertaleRoom.Layer layer = ObjectEditor.Content as UndertaleRoom.Layer;
 
-                int scaleX = (int)Math.Clamp(mousePos.X - movingTile.SourceX, 0, maxX);
-                int scaleY = (int)Math.Clamp(mousePos.Y - movingTile.SourceY, 0, maxY);
+            if (layer != null && layer.AssetsData == null)
+            {
+                return;
+            }
 
-                int gridSize = Convert.ToInt32(room.Grid);
-                if (gridSize <= 0)
-                    gridSize = 1;
-                else if (Keyboard.Modifiers.HasFlag(ModifierKeys.Control))
-                    gridSize = gridSize / 2;
-                else if (Keyboard.Modifiers.HasFlag(ModifierKeys.Shift))
-                    gridSize = gridSize * 2;
+            if (placedTiles.Contains(gridMouse)) return;
 
-                // Snap to grid
-                tgtX = (tgtX + gridSize / 2) / gridSize * gridSize;
-                tgtY = (tgtY + gridSize / 2) / gridSize * gridSize;
+            placedTiles.Add(gridMouse);
+            placingTiles = true;
 
-                scaleX = (scaleX + gridSize / 2) / gridSize * gridSize;
-                scaleY = (scaleY + gridSize / 2) / gridSize * gridSize;
-                if (Keyboard.Modifiers.HasFlag(ModifierKeys.Alt))
+            if (other is UndertaleRoom.Tile)
+            {
+                var otherTile = other as UndertaleRoom.Tile;
+                var newObj = new UndertaleRoom.Tile
                 {
-                    movingTile.Width = (uint)scaleX;
-                    movingTile.Height = (uint)scaleY;
-                }
+                    X = (int)gridMouse.X,
+                    Y = (int)gridMouse.Y,
+                    _SpriteMode = otherTile._SpriteMode,
+                    ObjectDefinition = otherTile.ObjectDefinition,
+                    SpriteDefinition = otherTile.SpriteDefinition,
+                    SourceX = otherTile.SourceX,
+                    SourceY = otherTile.SourceY,
+                    Width = otherTile.Width,
+                    Height = otherTile.Height,
+                    TileDepth = otherTile.TileDepth,
+                    InstanceID = (Application.Current.MainWindow as MainWindow).Data.GeneralInfo.LastTile++,
+                    ScaleX = otherTile.ScaleX,
+                    ScaleY = otherTile.ScaleY,
+                    Color = otherTile.Color
+                };
+                if (layer != null)
+                    layer.AssetsData.LegacyTiles.Add(newObj);
                 else
+                    room.Tiles.Add(newObj);
+                SelectObject(newObj);
+            }
+            else if (other is UndertaleRoom.GameObject)
+            {
+                var otherObject = other as UndertaleRoom.GameObject;
+                var newObj = new UndertaleRoom.GameObject
                 {
-                    movingTile.SourceX = (uint)tgtX;
-                    movingTile.SourceY = (uint)tgtY;
-                }
+                    X = (int)gridMouse.X,
+                    Y = (int)gridMouse.Y,
+                    ObjectDefinition = otherObject.ObjectDefinition,
+                    InstanceID = (Application.Current.MainWindow as MainWindow).Data.GeneralInfo.LastObj++,
+                    CreationCode = otherObject.CreationCode,
+                    ScaleX = otherObject.ScaleX,
+                    ScaleY = otherObject.ScaleY,
+                    Color = otherObject.Color,
+                    Rotation = otherObject.Rotation,
+                    PreCreateCode = otherObject.PreCreateCode
+                };
+                room.GameObjects.Add(newObj);
+                if (layer != null)
+                    layer.InstancesData.Instances.Add(newObj);
+                SelectObject(newObj);
             }
         }
 
-        private void RectangleTile_MouseUp(object sender, MouseButtonEventArgs e)
+        Canvas roomCanvas;
+
+        private void Canvas_Loaded(object sender, RoutedEventArgs e)
+        {
+            roomCanvas = sender as Canvas;
+        }
+
+        private void RectangleBackground_MouseDown(object sender, MouseButtonEventArgs e)
+        {
+            UndertaleRoom room = DataContext as UndertaleRoom;
+            var other = selectedObject as UndertaleObject;
+
+            var mousePos = e.GetPosition(roomCanvas);
+
+            placedTiles.Clear();
+
+            PaintObjects(GetGridMouseCoordinates(mousePos, room), other, room);
+        }
+
+        private void RectangleBackground_MouseUp(object sender, MouseButtonEventArgs e)
+        {
+            placingTiles = false;
+            placedTiles.Clear();
+        }
+
+        private void RectangleBackground_MouseMove(object sender, MouseEventArgs e)
         {
-            movingTile = null;
+            if (placingTiles)
+            {
+                UndertaleRoom room = this.DataContext as UndertaleRoom;
+                var other = selectedObject as UndertaleObject;
+
+                var mousePos = e.GetPosition(roomCanvas);
+
+                PaintObjects(GetGridMouseCoordinates(mousePos, room), other, room);
+                return;
+            }
+            Rectangle_MouseMove(sender, e);
         }
 
         private void Rectangle_MouseMove(object sender, MouseEventArgs e)
@@ -300,17 +370,23 @@ private void Rectangle_MouseMove(object sender, MouseEventArgs e)
                 int tgtX = (int)(mousePos.X - hotpointX);
                 int tgtY = (int)(mousePos.Y - hotpointY);
 
-                int gridSize = Convert.ToInt32(room.Grid);
-                if (gridSize <= 0)
-                    gridSize = 1;
-                else if (Keyboard.Modifiers.HasFlag(ModifierKeys.Control))
-                    gridSize = gridSize/2;
+                int gridWidth  = Math.Max(Convert.ToInt32(room.GridWidth ), 1);
+                int gridHeight = Math.Max(Convert.ToInt32(room.GridHeight), 1);
+
+                if (Keyboard.Modifiers.HasFlag(ModifierKeys.Control))
+                {
+                    gridWidth  /= 2;
+                    gridHeight /= 2;
+                }
                 else if (Keyboard.Modifiers.HasFlag(ModifierKeys.Shift))
-                    gridSize = gridSize*2;
+                {
+                    gridWidth  *= 2;
+                    gridHeight *= 2;
+                }
 
                 // Snap to grid
-                tgtX = ((tgtX + gridSize / 2) / gridSize) * gridSize;
-                tgtY = ((tgtY + gridSize / 2) / gridSize) * gridSize;
+                tgtX = ((tgtX + gridWidth  / 2) / gridWidth ) * gridWidth;
+                tgtY = ((tgtY + gridHeight / 2) / gridHeight) * gridHeight;
 
                 if (movingObj is UndertaleRoom.GameObject)
                 {
@@ -325,6 +401,62 @@ private void Rectangle_MouseMove(object sender, MouseEventArgs e)
             }
         }
 
+        double scaleOriginX, scaleOriginY;
+        private void RectangleTile_MouseDown(object sender, MouseButtonEventArgs e)
+        {
+            var element = sender as Canvas;
+            var tileSelector = element.FindName("TileSelector") as Rectangle;
+            var mousePos = e.GetPosition(element);
+            var clickedTile = tileSelector.DataContext as UndertaleRoom.Tile;
+            UndertaleRoom room = this.DataContext as UndertaleRoom;
+
+            Point gridMouseCoordinates = GetGridMouseCoordinates(mousePos, room);
+            scaleOriginX = gridMouseCoordinates.X;
+            scaleOriginY = gridMouseCoordinates.Y;
+            clickedTile.SourceX = (uint)gridMouseCoordinates.X;
+            clickedTile.SourceY = (uint)gridMouseCoordinates.Y;
+            clickedTile.Width = (uint)room.GridWidth;
+            clickedTile.Height = (uint)room.GridHeight;
+        }
+
+        private void RectangleTile_MouseMove(object sender, MouseEventArgs e)
+        {
+            if (e.LeftButton != MouseButtonState.Pressed) return;
+
+            var element = sender as Canvas;
+            var tileSelector = element.FindName("TileSelector") as Rectangle;
+            var mousePos = e.GetPosition(element);
+
+            var clickedTile = tileSelector.DataContext as UndertaleRoom.Tile;
+
+            UndertaleRoom room = this.DataContext as UndertaleRoom;
+
+            Point gridMouseCoordinates = GetGridMouseCoordinates(mousePos, room);
+
+            if (Keyboard.Modifiers.HasFlag(ModifierKeys.Alt))
+            {
+                double differenceX = gridMouseCoordinates.X - scaleOriginX;
+                double differenceY = gridMouseCoordinates.Y - scaleOriginY;
+                clickedTile.Width  = (uint)Math.Clamp(Math.Abs(differenceX), 0, clickedTile.Tpag.BoundingWidth ) + (uint)room.GridWidth;
+                clickedTile.Height = (uint)Math.Clamp(Math.Abs(differenceY), 0, clickedTile.Tpag.BoundingHeight) + (uint)room.GridHeight;
+
+                if (differenceX < 0)
+                    clickedTile.SourceX = (uint)gridMouseCoordinates.X;
+                else
+                    clickedTile.SourceX = (uint)scaleOriginX;
+
+                if (differenceY < 0)
+                    clickedTile.SourceY = (uint)gridMouseCoordinates.Y;
+                else
+                    clickedTile.SourceY = (uint)scaleOriginY;
+            }
+            else
+            {
+                clickedTile.SourceX = (uint)gridMouseCoordinates.X;
+                clickedTile.SourceY = (uint)gridMouseCoordinates.Y;
+            }
+        }
+
         private void Canvas_MouseWheel(object sender, MouseWheelEventArgs e)
         {
             e.Handled = true;
@@ -369,14 +501,18 @@ private void ScrollViewer_ScrollChanged(object sender, ScrollChangedEventArgs e)
 
         private void Rectangle_MouseUp(object sender, MouseButtonEventArgs e)
         {
+            e.Handled = true;
             movingObj = null;
         }
 
+        UndertaleObject selectedObject;
         private void SelectObject(UndertaleObject obj)
         {
             // TODO: This sometimes fails to open objects in non-expanded tree
             // Note that this prefers to select the object inside a layer than the 'floating' one in GameObjects
 
+            selectedObject = obj;
+
             foreach (var child in (RoomObjectsTree.Items[0] as TreeViewItem).Items)
             {
                 foreach (var layer in (child as TreeViewItem).Items)
@@ -428,7 +564,7 @@ private void Canvas_Drop(object sender, DragEventArgs e)
                 else if (sourceItem is UndertaleGameObject)
                 {
                     UndertaleGameObject droppedObject = sourceItem as UndertaleGameObject;
-                    var mousePos = e.GetPosition(RoomGraphics);
+                    var mousePos = e.GetPosition(roomCanvas);
 
                     UndertaleRoom room = this.DataContext as UndertaleRoom;
                     UndertaleRoom.Layer layer = ObjectEditor.Content as UndertaleRoom.Layer;