blockType() public method

public blockType ( ) : int
return int
Esempio n. 1
0
        public static bool Place(TileObject toBePlaced)
        {
            TileObjectData tileData = TileObjectData.GetTileData(toBePlaced.type, toBePlaced.style, toBePlaced.alternate);

            if (tileData == null)
            {
                return(false);
            }
            if (tileData.HookPlaceOverride.hook != null)
            {
                int num1;
                int num2;
                if (tileData.HookPlaceOverride.processedCoordinates)
                {
                    num1 = toBePlaced.xCoord;
                    num2 = toBePlaced.yCoord;
                }
                else
                {
                    num1 = toBePlaced.xCoord + (int)tileData.Origin.X;
                    num2 = toBePlaced.yCoord + (int)tileData.Origin.Y;
                }
                if (tileData.HookPlaceOverride.hook(num1, num2, toBePlaced.type, toBePlaced.style, 1, toBePlaced.alternate) == tileData.HookPlaceOverride.badReturn)
                {
                    return(false);
                }
            }
            else
            {
                ushort type           = (ushort)toBePlaced.type;
                int    placementStyle = tileData.CalculatePlacementStyle(toBePlaced.style, toBePlaced.alternate, toBePlaced.random);
                int    num1           = 0;
                if (tileData.StyleWrapLimit > 0)
                {
                    num1            = placementStyle / tileData.StyleWrapLimit * tileData.StyleLineSkip;
                    placementStyle %= tileData.StyleWrapLimit;
                }
                int num2;
                int num3;
                if (tileData.StyleHorizontal)
                {
                    num2 = tileData.CoordinateFullWidth * placementStyle;
                    num3 = tileData.CoordinateFullHeight * num1;
                }
                else
                {
                    num2 = tileData.CoordinateFullWidth * num1;
                    num3 = tileData.CoordinateFullHeight * placementStyle;
                }
                int xCoord = toBePlaced.xCoord;
                int yCoord = toBePlaced.yCoord;
                for (int index1 = 0; index1 < tileData.Width; ++index1)
                {
                    for (int index2 = 0; index2 < tileData.Height; ++index2)
                    {
                        Tile tileSafely = Framing.GetTileSafely(xCoord + index1, yCoord + index2);
                        if (tileSafely.active() && tileSafely.type != (ushort)484 && (Main.tileCut[(int)tileSafely.type] || TileID.Sets.BreakableWhenPlacing[(int)tileSafely.type]))
                        {
                            WorldGen.KillTile(xCoord + index1, yCoord + index2, false, false, false);
                            if (!Main.tile[xCoord + index1, yCoord + index2].active() && Main.netMode == 1)
                            {
                                NetMessage.SendData(17, -1, -1, (NetworkText)null, 0, (float)(yCoord + index1), (float)(yCoord + index2), 0.0f, 0, 0, 0);
                            }
                        }
                    }
                }
                for (int index1 = 0; index1 < tileData.Width; ++index1)
                {
                    int num4 = num2 + index1 * (tileData.CoordinateWidth + tileData.CoordinatePadding);
                    int num5 = num3;
                    for (int index2 = 0; index2 < tileData.Height; ++index2)
                    {
                        Tile tileSafely = Framing.GetTileSafely(xCoord + index1, yCoord + index2);
                        if (!tileSafely.active())
                        {
                            tileSafely.active(true);
                            tileSafely.frameX = (short)num4;
                            tileSafely.frameY = (short)num5;
                            tileSafely.type   = type;
                        }
                        num5 += tileData.CoordinateHeights[index2] + tileData.CoordinatePadding;
                    }
                }
            }
            if (tileData.FlattenAnchors)
            {
                AnchorData anchorBottom = tileData.AnchorBottom;
                if (anchorBottom.tileCount != 0 && (anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int num = toBePlaced.xCoord + anchorBottom.checkStart;
                    int j   = toBePlaced.yCoord + tileData.Height;
                    for (int index = 0; index < anchorBottom.tileCount; ++index)
                    {
                        Tile tileSafely = Framing.GetTileSafely(num + index, j);
                        if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && tileSafely.blockType() != 0)
                        {
                            WorldGen.SlopeTile(num + index, j, 0, false);
                        }
                    }
                }
                AnchorData anchorTop = tileData.AnchorTop;
                if (anchorTop.tileCount != 0 && (anchorTop.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int num = toBePlaced.xCoord + anchorTop.checkStart;
                    int j   = toBePlaced.yCoord - 1;
                    for (int index = 0; index < anchorTop.tileCount; ++index)
                    {
                        Tile tileSafely = Framing.GetTileSafely(num + index, j);
                        if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && tileSafely.blockType() != 0)
                        {
                            WorldGen.SlopeTile(num + index, j, 0, false);
                        }
                    }
                }
                AnchorData anchorRight = tileData.AnchorRight;
                if (anchorRight.tileCount != 0 && (anchorRight.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int i   = toBePlaced.xCoord + tileData.Width;
                    int num = toBePlaced.yCoord + anchorRight.checkStart;
                    for (int index = 0; index < anchorRight.tileCount; ++index)
                    {
                        Tile tileSafely = Framing.GetTileSafely(i, num + index);
                        if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && tileSafely.blockType() != 0)
                        {
                            WorldGen.SlopeTile(i, num + index, 0, false);
                        }
                    }
                }
                AnchorData anchorLeft = tileData.AnchorLeft;
                if (anchorLeft.tileCount != 0 && (anchorLeft.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int i   = toBePlaced.xCoord - 1;
                    int num = toBePlaced.yCoord + anchorLeft.checkStart;
                    for (int index = 0; index < anchorLeft.tileCount; ++index)
                    {
                        Tile tileSafely = Framing.GetTileSafely(i, num + index);
                        if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && tileSafely.blockType() != 0)
                        {
                            WorldGen.SlopeTile(i, num + index, 0, false);
                        }
                    }
                }
            }
            return(true);
        }
Esempio n. 2
0
 private static BlockStyle FindBlockStyle(Tile blockTile)
 {
     return(blockStyleLookup[blockTile.blockType()]);
 }
Esempio n. 3
0
 private static Framing.BlockStyle FindBlockStyle(Tile blockTile)
 {
     return(Framing.blockStyleLookup[blockTile.blockType()]);
 }
Esempio n. 4
0
        public static bool CanPlace(
            int x,
            int y,
            int type,
            int style,
            int dir,
            out TileObject objectData,
            bool onlyCheck = false)
        {
            TileObjectData tileData1 = TileObjectData.GetTileData(type, style, 0);

            objectData = TileObject.Empty;
            if (tileData1 == null)
            {
                return(false);
            }
            int num1 = x - (int)tileData1.Origin.X;
            int num2 = y - (int)tileData1.Origin.Y;

            if (num1 < 0 || num1 + tileData1.Width >= Main.maxTilesX || (num2 < 0 || num2 + tileData1.Height >= Main.maxTilesY))
            {
                return(false);
            }
            bool flag1 = tileData1.RandomStyleRange > 0;

            if (TileObjectPreviewData.placementCache == null)
            {
                TileObjectPreviewData.placementCache = new TileObjectPreviewData();
            }
            TileObjectPreviewData.placementCache.Reset();
            int num3 = 0;

            if (tileData1.AlternatesCount != 0)
            {
                num3 = tileData1.AlternatesCount;
            }
            float          num4           = -1f;
            float          num5           = -1f;
            int            num6           = 0;
            TileObjectData tileObjectData = (TileObjectData)null;
            int            alternate      = 0 - 1;

            while (alternate < num3)
            {
                ++alternate;
                TileObjectData tileData2 = TileObjectData.GetTileData(type, style, alternate);
                if (tileData2.Direction == TileObjectDirection.None || (tileData2.Direction != TileObjectDirection.PlaceLeft || dir != 1) && (tileData2.Direction != TileObjectDirection.PlaceRight || dir != -1))
                {
                    int num7 = x - (int)tileData2.Origin.X;
                    int num8 = y - (int)tileData2.Origin.Y;
                    if (num7 < 5 || num7 + tileData2.Width > Main.maxTilesX - 5 || (num8 < 5 || num8 + tileData2.Height > Main.maxTilesY - 5))
                    {
                        return(false);
                    }
                    Rectangle rectangle = new Rectangle(0, 0, tileData2.Width, tileData2.Height);
                    int       X         = 0;
                    int       Y         = 0;
                    if (tileData2.AnchorTop.tileCount != 0)
                    {
                        if (rectangle.Y == 0)
                        {
                            rectangle.Y = -1;
                            ++rectangle.Height;
                            ++Y;
                        }
                        int checkStart = tileData2.AnchorTop.checkStart;
                        if (checkStart < rectangle.X)
                        {
                            rectangle.Width += rectangle.X - checkStart;
                            X          += rectangle.X - checkStart;
                            rectangle.X = checkStart;
                        }
                        int num9  = checkStart + tileData2.AnchorTop.tileCount - 1;
                        int num10 = rectangle.X + rectangle.Width - 1;
                        if (num9 > num10)
                        {
                            rectangle.Width += num9 - num10;
                        }
                    }
                    if (tileData2.AnchorBottom.tileCount != 0)
                    {
                        if (rectangle.Y + rectangle.Height == tileData2.Height)
                        {
                            ++rectangle.Height;
                        }
                        int checkStart = tileData2.AnchorBottom.checkStart;
                        if (checkStart < rectangle.X)
                        {
                            rectangle.Width += rectangle.X - checkStart;
                            X          += rectangle.X - checkStart;
                            rectangle.X = checkStart;
                        }
                        int num9  = checkStart + tileData2.AnchorBottom.tileCount - 1;
                        int num10 = rectangle.X + rectangle.Width - 1;
                        if (num9 > num10)
                        {
                            rectangle.Width += num9 - num10;
                        }
                    }
                    if (tileData2.AnchorLeft.tileCount != 0)
                    {
                        if (rectangle.X == 0)
                        {
                            rectangle.X = -1;
                            ++rectangle.Width;
                            ++X;
                        }
                        int checkStart = tileData2.AnchorLeft.checkStart;
                        if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            --checkStart;
                        }
                        if (checkStart < rectangle.Y)
                        {
                            rectangle.Width += rectangle.Y - checkStart;
                            Y          += rectangle.Y - checkStart;
                            rectangle.Y = checkStart;
                        }
                        int num9 = checkStart + tileData2.AnchorLeft.tileCount - 1;
                        if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            num9 += 2;
                        }
                        int num10 = rectangle.Y + rectangle.Height - 1;
                        if (num9 > num10)
                        {
                            rectangle.Height += num9 - num10;
                        }
                    }
                    if (tileData2.AnchorRight.tileCount != 0)
                    {
                        if (rectangle.X + rectangle.Width == tileData2.Width)
                        {
                            ++rectangle.Width;
                        }
                        int checkStart = tileData2.AnchorLeft.checkStart;
                        if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            --checkStart;
                        }
                        if (checkStart < rectangle.Y)
                        {
                            rectangle.Width += rectangle.Y - checkStart;
                            Y          += rectangle.Y - checkStart;
                            rectangle.Y = checkStart;
                        }
                        int num9 = checkStart + tileData2.AnchorRight.tileCount - 1;
                        if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            num9 += 2;
                        }
                        int num10 = rectangle.Y + rectangle.Height - 1;
                        if (num9 > num10)
                        {
                            rectangle.Height += num9 - num10;
                        }
                    }
                    if (onlyCheck)
                    {
                        TileObject.objectPreview.Reset();
                        TileObject.objectPreview.Active      = true;
                        TileObject.objectPreview.Type        = (ushort)type;
                        TileObject.objectPreview.Style       = (short)style;
                        TileObject.objectPreview.Alternate   = alternate;
                        TileObject.objectPreview.Size        = new Point16(rectangle.Width, rectangle.Height);
                        TileObject.objectPreview.ObjectStart = new Point16(X, Y);
                        TileObject.objectPreview.Coordinates = new Point16(num7 - X, num8 - Y);
                    }
                    float num11 = 0.0f;
                    float num12 = (float)(tileData2.Width * tileData2.Height);
                    float num13 = 0.0f;
                    float num14 = 0.0f;
                    for (int index1 = 0; index1 < tileData2.Width; ++index1)
                    {
                        for (int index2 = 0; index2 < tileData2.Height; ++index2)
                        {
                            Tile tileSafely = Framing.GetTileSafely(num7 + index1, num8 + index2);
                            bool flag2      = !tileData2.LiquidPlace(tileSafely);
                            bool flag3      = false;
                            if (tileData2.AnchorWall)
                            {
                                ++num14;
                                if (!tileData2.isValidWallAnchor((int)tileSafely.wall))
                                {
                                    flag3 = true;
                                }
                                else
                                {
                                    ++num13;
                                }
                            }
                            bool flag4 = false;
                            if (tileSafely.active() && (!Main.tileCut[(int)tileSafely.type] || tileSafely.type == (ushort)484) && !TileID.Sets.BreakableWhenPlacing[(int)tileSafely.type])
                            {
                                flag4 = true;
                            }
                            if (flag4 | flag2 | flag3)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[index1 + X, index2 + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[index1 + X, index2 + Y] = 1;
                                }
                                ++num11;
                            }
                        }
                    }
                    AnchorData anchorBottom = tileData2.AnchorBottom;
                    if (anchorBottom.tileCount != 0)
                    {
                        num14 += (float)anchorBottom.tileCount;
                        int height = tileData2.Height;
                        for (int index = 0; index < anchorBottom.tileCount; ++index)
                        {
                            int  num9       = anchorBottom.checkStart + index;
                            Tile tileSafely = Framing.GetTileSafely(num7 + num9, num8 + height);
                            bool flag2      = false;
                            if (tileSafely.nactive())
                            {
                                if ((anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile && Main.tileSolid[(int)tileSafely.type] && (!Main.tileSolidTop[(int)tileSafely.type] && !Main.tileNoAttach[(int)tileSafely.type]) && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag2 && ((anchorBottom.type & AnchorType.SolidWithTop) == AnchorType.SolidWithTop || (anchorBottom.type & AnchorType.Table) == AnchorType.Table))
                                {
                                    if (TileID.Sets.Platforms[(int)tileSafely.type])
                                    {
                                        int num10 = (int)tileSafely.frameX / TileObjectData.PlatformFrameWidth();
                                        if (!tileSafely.halfBrick() && WorldGen.PlatformProperTopFrame(tileSafely.frameX))
                                        {
                                            flag2 = true;
                                        }
                                    }
                                    else if (Main.tileSolid[(int)tileSafely.type] && Main.tileSolidTop[(int)tileSafely.type])
                                    {
                                        flag2 = true;
                                    }
                                }
                                if (!flag2 && (anchorBottom.type & AnchorType.Table) == AnchorType.Table && (!TileID.Sets.Platforms[(int)tileSafely.type] && Main.tileTable[(int)tileSafely.type]) && tileSafely.blockType() == 0)
                                {
                                    flag2 = true;
                                }
                                if (!flag2 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type]))
                                {
                                    switch (tileSafely.blockType())
                                    {
                                    case 4:
                                    case 5:
                                        flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                        break;
                                    }
                                }
                                if (!flag2 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely.type))
                                {
                                    flag2 = true;
                                }
                            }
                            else if (!flag2 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag2 = true;
                            }
                            if (!flag2)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num9 + X, height + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num9 + X, height + Y] = 1;
                                }
                                ++num13;
                            }
                        }
                    }
                    AnchorData anchorTop = tileData2.AnchorTop;
                    if (anchorTop.tileCount != 0)
                    {
                        num14 += (float)anchorTop.tileCount;
                        int num9 = -1;
                        for (int index = 0; index < anchorTop.tileCount; ++index)
                        {
                            int  num10      = anchorTop.checkStart + index;
                            Tile tileSafely = Framing.GetTileSafely(num7 + num10, num8 + num9);
                            bool flag2      = false;
                            if (tileSafely.nactive())
                            {
                                if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && !Main.tileNoAttach[(int)tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag2 && (anchorTop.type & AnchorType.SolidBottom) == AnchorType.SolidBottom && (Main.tileSolid[(int)tileSafely.type] && (!Main.tileSolidTop[(int)tileSafely.type] || TileID.Sets.Platforms[(int)tileSafely.type] && (tileSafely.halfBrick() || tileSafely.topSlope())) || (tileSafely.halfBrick() || tileSafely.topSlope())) && (!TileID.Sets.NotReallySolid[(int)tileSafely.type] && !tileSafely.bottomSlope()))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag2 && (anchorTop.type & AnchorType.SolidSide) == AnchorType.SolidSide && (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type]))
                                {
                                    switch (tileSafely.blockType())
                                    {
                                    case 2:
                                    case 3:
                                        flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                        break;
                                    }
                                }
                                if (!flag2 && (anchorTop.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely.type))
                                {
                                    flag2 = true;
                                }
                            }
                            else if (!flag2 && (anchorTop.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag2 = true;
                            }
                            if (!flag2)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num10 + X, num9 + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num10 + X, num9 + Y] = 1;
                                }
                                ++num13;
                            }
                        }
                    }
                    AnchorData anchorRight = tileData2.AnchorRight;
                    if (anchorRight.tileCount != 0)
                    {
                        num14 += (float)anchorRight.tileCount;
                        int width = tileData2.Width;
                        for (int index = 0; index < anchorRight.tileCount; ++index)
                        {
                            int  num9        = anchorRight.checkStart + index;
                            Tile tileSafely1 = Framing.GetTileSafely(num7 + width, num8 + num9);
                            bool flag2       = false;
                            if (tileSafely1.nactive())
                            {
                                if (Main.tileSolid[(int)tileSafely1.type] && !Main.tileSolidTop[(int)tileSafely1.type] && !Main.tileNoAttach[(int)tileSafely1.type] && (tileData2.FlattenAnchors || tileSafely1.blockType() == 0))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely1.type);
                                }
                                if (!flag2 && (anchorRight.type & AnchorType.SolidSide) == AnchorType.SolidSide && (Main.tileSolid[(int)tileSafely1.type] && !Main.tileSolidTop[(int)tileSafely1.type]))
                                {
                                    switch (tileSafely1.blockType())
                                    {
                                    case 2:
                                    case 4:
                                        flag2 = tileData2.isValidTileAnchor((int)tileSafely1.type);
                                        break;
                                    }
                                }
                                if (!flag2 && (anchorRight.type & AnchorType.Tree) == AnchorType.Tree && TileID.Sets.IsATreeTrunk[(int)tileSafely1.type])
                                {
                                    flag2 = true;
                                    if (index == 0)
                                    {
                                        ++num14;
                                        Tile tileSafely2 = Framing.GetTileSafely(num7 + width, num8 + num9 - 1);
                                        if (tileSafely2.nactive() && TileID.Sets.IsATreeTrunk[(int)tileSafely2.type])
                                        {
                                            ++num13;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[width + X, num9 + Y - 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[width + X, num9 + Y - 1] = 2;
                                        }
                                    }
                                    if (index == anchorRight.tileCount - 1)
                                    {
                                        ++num14;
                                        Tile tileSafely2 = Framing.GetTileSafely(num7 + width, num8 + num9 + 1);
                                        if (tileSafely2.nactive() && TileID.Sets.IsATreeTrunk[(int)tileSafely2.type])
                                        {
                                            ++num13;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[width + X, num9 + Y + 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[width + X, num9 + Y + 1] = 2;
                                        }
                                    }
                                }
                                if (!flag2 && (anchorRight.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely1.type))
                                {
                                    flag2 = true;
                                }
                            }
                            else if (!flag2 && (anchorRight.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag2 = true;
                            }
                            if (!flag2)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[width + X, num9 + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[width + X, num9 + Y] = 1;
                                }
                                ++num13;
                            }
                        }
                    }
                    AnchorData anchorLeft = tileData2.AnchorLeft;
                    if (anchorLeft.tileCount != 0)
                    {
                        num14 += (float)anchorLeft.tileCount;
                        int num9 = -1;
                        for (int index = 0; index < anchorLeft.tileCount; ++index)
                        {
                            int  num10       = anchorLeft.checkStart + index;
                            Tile tileSafely1 = Framing.GetTileSafely(num7 + num9, num8 + num10);
                            bool flag2       = false;
                            if (tileSafely1.nactive())
                            {
                                if (Main.tileSolid[(int)tileSafely1.type] && !Main.tileSolidTop[(int)tileSafely1.type] && !Main.tileNoAttach[(int)tileSafely1.type] && (tileData2.FlattenAnchors || tileSafely1.blockType() == 0))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely1.type);
                                }
                                if (!flag2 && (anchorLeft.type & AnchorType.SolidSide) == AnchorType.SolidSide && (Main.tileSolid[(int)tileSafely1.type] && !Main.tileSolidTop[(int)tileSafely1.type]))
                                {
                                    switch (tileSafely1.blockType())
                                    {
                                    case 3:
                                    case 5:
                                        flag2 = tileData2.isValidTileAnchor((int)tileSafely1.type);
                                        break;
                                    }
                                }
                                if (!flag2 && (anchorLeft.type & AnchorType.Tree) == AnchorType.Tree && TileID.Sets.IsATreeTrunk[(int)tileSafely1.type])
                                {
                                    flag2 = true;
                                    if (index == 0)
                                    {
                                        ++num14;
                                        Tile tileSafely2 = Framing.GetTileSafely(num7 + num9, num8 + num10 - 1);
                                        if (tileSafely2.nactive() && TileID.Sets.IsATreeTrunk[(int)tileSafely2.type])
                                        {
                                            ++num13;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[num9 + X, num10 + Y - 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[num9 + X, num10 + Y - 1] = 2;
                                        }
                                    }
                                    if (index == anchorLeft.tileCount - 1)
                                    {
                                        ++num14;
                                        Tile tileSafely2 = Framing.GetTileSafely(num7 + num9, num8 + num10 + 1);
                                        if (tileSafely2.nactive() && TileID.Sets.IsATreeTrunk[(int)tileSafely2.type])
                                        {
                                            ++num13;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[num9 + X, num10 + Y + 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[num9 + X, num10 + Y + 1] = 2;
                                        }
                                    }
                                }
                                if (!flag2 && (anchorLeft.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely1.type))
                                {
                                    flag2 = true;
                                }
                            }
                            else if (!flag2 && (anchorLeft.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag2 = true;
                            }
                            if (!flag2)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num9 + X, num10 + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num9 + X, num10 + Y] = 1;
                                }
                                ++num13;
                            }
                        }
                    }
                    if (tileData2.HookCheckIfCanPlace.hook != null)
                    {
                        if (tileData2.HookCheckIfCanPlace.processedCoordinates)
                        {
                            Point16 origin1 = tileData2.Origin;
                            Point16 origin2 = tileData2.Origin;
                        }
                        if (tileData2.HookCheckIfCanPlace.hook(x, y, type, style, dir, alternate) == tileData2.HookCheckIfCanPlace.badReturn && tileData2.HookCheckIfCanPlace.badResponse == 0)
                        {
                            num13 = 0.0f;
                            num11 = 0.0f;
                            TileObject.objectPreview.AllInvalid();
                        }
                    }
                    float num15 = num13 / num14;
                    float num16 = num11 / num12;
                    if ((double)num16 == 1.0 && (double)num14 == 0.0)
                    {
                        num15 = 1f;
                        num16 = 1f;
                    }
                    if ((double)num15 == 1.0 && (double)num16 == 1.0)
                    {
                        num4           = 1f;
                        num5           = 1f;
                        num6           = alternate;
                        tileObjectData = tileData2;
                        break;
                    }
                    if ((double)num15 > (double)num4 || (double)num15 == (double)num4 && (double)num16 > (double)num5)
                    {
                        TileObjectPreviewData.placementCache.CopyFrom(TileObject.objectPreview);
                        num4           = num15;
                        num5           = num16;
                        tileObjectData = tileData2;
                        num6           = alternate;
                    }
                }
            }
            int num17 = -1;

            if (flag1)
            {
                if (TileObjectPreviewData.randomCache == null)
                {
                    TileObjectPreviewData.randomCache = new TileObjectPreviewData();
                }
                bool flag2 = false;
                if ((int)TileObjectPreviewData.randomCache.Type == type)
                {
                    Point16 coordinates = TileObjectPreviewData.randomCache.Coordinates;
                    Point16 objectStart = TileObjectPreviewData.randomCache.ObjectStart;
                    int     num7        = (int)coordinates.X + (int)objectStart.X;
                    int     num8        = (int)coordinates.Y + (int)objectStart.Y;
                    int     num9        = x - (int)tileData1.Origin.X;
                    int     num10       = y - (int)tileData1.Origin.Y;
                    if (num7 != num9 || num8 != num10)
                    {
                        flag2 = true;
                    }
                }
                else
                {
                    flag2 = true;
                }
                num17 = !flag2 ? TileObjectPreviewData.randomCache.Random : Main.rand.Next(tileData1.RandomStyleRange);
            }
            if (onlyCheck)
            {
                if ((double)num4 != 1.0 || (double)num5 != 1.0)
                {
                    TileObject.objectPreview.CopyFrom(TileObjectPreviewData.placementCache);
                    alternate = num6;
                }
                TileObject.objectPreview.Random = num17;
                if (tileData1.RandomStyleRange > 0)
                {
                    TileObjectPreviewData.randomCache.CopyFrom(TileObject.objectPreview);
                }
            }
            if (!onlyCheck)
            {
                objectData.xCoord    = x - (int)tileObjectData.Origin.X;
                objectData.yCoord    = y - (int)tileObjectData.Origin.Y;
                objectData.type      = type;
                objectData.style     = style;
                objectData.alternate = alternate;
                objectData.random    = num17;
            }
            return((double)num4 == 1.0 && (double)num5 == 1.0);
        }
Esempio n. 5
0
        public static bool CanPlace(int x, int y, int type, int style, int dir, out TileObject objectData, bool onlyCheck = false)
        {
            TileObjectData tileData = TileObjectData.GetTileData(type, style);

            objectData = Empty;
            if (tileData == null)
            {
                return(false);
            }
            int num  = x - tileData.Origin.X;
            int num2 = y - tileData.Origin.Y;

            if (num < 0 || num + tileData.Width >= Main.maxTilesX || num2 < 0 || num2 + tileData.Height >= Main.maxTilesY)
            {
                return(false);
            }
            bool flag = tileData.RandomStyleRange > 0;

            if (TileObjectPreviewData.placementCache == null)
            {
                TileObjectPreviewData.placementCache = new TileObjectPreviewData();
            }
            TileObjectPreviewData.placementCache.Reset();
            int num3 = 0;

            if (tileData.AlternatesCount != 0)
            {
                num3 = tileData.AlternatesCount;
            }
            float          num4           = -1f;
            float          num5           = -1f;
            int            num6           = 0;
            TileObjectData tileObjectData = null;
            int            num7           = -1;

            while (num7 < num3)
            {
                num7++;
                TileObjectData tileData2 = TileObjectData.GetTileData(type, style, num7);
                if (tileData2.Direction != 0 && ((tileData2.Direction == TileObjectDirection.PlaceLeft && dir == 1) || (tileData2.Direction == TileObjectDirection.PlaceRight && dir == -1)))
                {
                    continue;
                }
                int num8 = x - tileData2.Origin.X;
                int num9 = y - tileData2.Origin.Y;
                if (num8 < 5 || num8 + tileData2.Width > Main.maxTilesX - 5 || num9 < 5 || num9 + tileData2.Height > Main.maxTilesY - 5)
                {
                    return(false);
                }
                Rectangle rectangle = new Rectangle(0, 0, tileData2.Width, tileData2.Height);
                int       num10     = 0;
                int       num11     = 0;
                if (tileData2.AnchorTop.tileCount != 0)
                {
                    if (rectangle.Y == 0)
                    {
                        rectangle.Y = -1;
                        rectangle.Height++;
                        num11++;
                    }
                    int checkStart = tileData2.AnchorTop.checkStart;
                    if (checkStart < rectangle.X)
                    {
                        rectangle.Width += rectangle.X - checkStart;
                        num10           += rectangle.X - checkStart;
                        rectangle.X      = checkStart;
                    }
                    int num12 = checkStart + tileData2.AnchorTop.tileCount - 1;
                    int num13 = rectangle.X + rectangle.Width - 1;
                    if (num12 > num13)
                    {
                        rectangle.Width += num12 - num13;
                    }
                }
                if (tileData2.AnchorBottom.tileCount != 0)
                {
                    if (rectangle.Y + rectangle.Height == tileData2.Height)
                    {
                        rectangle.Height++;
                    }
                    int checkStart2 = tileData2.AnchorBottom.checkStart;
                    if (checkStart2 < rectangle.X)
                    {
                        rectangle.Width += rectangle.X - checkStart2;
                        num10           += rectangle.X - checkStart2;
                        rectangle.X      = checkStart2;
                    }
                    int num14 = checkStart2 + tileData2.AnchorBottom.tileCount - 1;
                    int num15 = rectangle.X + rectangle.Width - 1;
                    if (num14 > num15)
                    {
                        rectangle.Width += num14 - num15;
                    }
                }
                if (tileData2.AnchorLeft.tileCount != 0)
                {
                    if (rectangle.X == 0)
                    {
                        rectangle.X = -1;
                        rectangle.Width++;
                        num10++;
                    }
                    int num16 = tileData2.AnchorLeft.checkStart;
                    if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                    {
                        num16--;
                    }
                    if (num16 < rectangle.Y)
                    {
                        rectangle.Width += rectangle.Y - num16;
                        num11           += rectangle.Y - num16;
                        rectangle.Y      = num16;
                    }
                    int num17 = num16 + tileData2.AnchorLeft.tileCount - 1;
                    if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                    {
                        num17 += 2;
                    }
                    int num18 = rectangle.Y + rectangle.Height - 1;
                    if (num17 > num18)
                    {
                        rectangle.Height += num17 - num18;
                    }
                }
                if (tileData2.AnchorRight.tileCount != 0)
                {
                    if (rectangle.X + rectangle.Width == tileData2.Width)
                    {
                        rectangle.Width++;
                    }
                    int num19 = tileData2.AnchorLeft.checkStart;
                    if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                    {
                        num19--;
                    }
                    if (num19 < rectangle.Y)
                    {
                        rectangle.Width += rectangle.Y - num19;
                        num11           += rectangle.Y - num19;
                        rectangle.Y      = num19;
                    }
                    int num20 = num19 + tileData2.AnchorRight.tileCount - 1;
                    if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                    {
                        num20 += 2;
                    }
                    int num21 = rectangle.Y + rectangle.Height - 1;
                    if (num20 > num21)
                    {
                        rectangle.Height += num20 - num21;
                    }
                }
                if (onlyCheck)
                {
                    objectPreview.Reset();
                    objectPreview.Active      = true;
                    objectPreview.Type        = (ushort)type;
                    objectPreview.Style       = (short)style;
                    objectPreview.Alternate   = num7;
                    objectPreview.Size        = new Point16(rectangle.Width, rectangle.Height);
                    objectPreview.ObjectStart = new Point16(num10, num11);
                    objectPreview.Coordinates = new Point16(num8 - num10, num9 - num11);
                }
                float num22 = 0f;
                float num23 = tileData2.Width * tileData2.Height;
                float num24 = 0f;
                float num25 = 0f;
                for (int i = 0; i < tileData2.Width; i++)
                {
                    for (int j = 0; j < tileData2.Height; j++)
                    {
                        Tile tileSafely = Framing.GetTileSafely(num8 + i, num9 + j);
                        bool flag2      = !tileData2.LiquidPlace(tileSafely);
                        bool flag3      = false;
                        if (tileData2.AnchorWall)
                        {
                            num25 += 1f;
                            if (!tileData2.isValidWallAnchor(tileSafely.wall))
                            {
                                flag3 = true;
                            }
                            else
                            {
                                num24 += 1f;
                            }
                        }
                        bool flag4 = false;
                        if (tileSafely.active() && (!Main.tileCut[tileSafely.type] || tileSafely.type == 484) && !TileID.Sets.BreakableWhenPlacing[tileSafely.type])
                        {
                            flag4 = true;
                        }
                        if (flag4 | flag2 | flag3)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[i + num10, j + num11] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[i + num10, j + num11] = 1;
                        }
                        num22 += 1f;
                    }
                }
                AnchorData anchorBottom = tileData2.AnchorBottom;
                if (anchorBottom.tileCount != 0)
                {
                    num25 += (float)anchorBottom.tileCount;
                    int height = tileData2.Height;
                    for (int k = 0; k < anchorBottom.tileCount; k++)
                    {
                        int  num26      = anchorBottom.checkStart + k;
                        Tile tileSafely = Framing.GetTileSafely(num8 + num26, num9 + height);
                        bool flag5      = false;
                        if (tileSafely.nactive())
                        {
                            if ((anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type] && !Main.tileNoAttach[tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                            {
                                flag5 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag5 && ((anchorBottom.type & AnchorType.SolidWithTop) == AnchorType.SolidWithTop || (anchorBottom.type & AnchorType.Table) == AnchorType.Table))
                            {
                                if (TileID.Sets.Platforms[tileSafely.type])
                                {
                                    _ = tileSafely.frameX / TileObjectData.PlatformFrameWidth();
                                    if (!tileSafely.halfBrick() && WorldGen.PlatformProperTopFrame(tileSafely.frameX))
                                    {
                                        flag5 = true;
                                    }
                                }
                                else if (Main.tileSolid[tileSafely.type] && Main.tileSolidTop[tileSafely.type])
                                {
                                    flag5 = true;
                                }
                            }
                            if (!flag5 && (anchorBottom.type & AnchorType.Table) == AnchorType.Table && !TileID.Sets.Platforms[tileSafely.type] && Main.tileTable[tileSafely.type] && tileSafely.blockType() == 0)
                            {
                                flag5 = true;
                            }
                            if (!flag5 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type])
                            {
                                int num27 = tileSafely.blockType();
                                if ((uint)(num27 - 4) <= 1u)
                                {
                                    flag5 = tileData2.isValidTileAnchor(tileSafely.type);
                                }
                            }
                            if (!flag5 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor(tileSafely.type))
                            {
                                flag5 = true;
                            }
                        }
                        else if (!flag5 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                        {
                            flag5 = true;
                        }
                        if (!flag5)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[num26 + num10, height + num11] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[num26 + num10, height + num11] = 1;
                        }
                        num24 += 1f;
                    }
                }
                anchorBottom = tileData2.AnchorTop;
                if (anchorBottom.tileCount != 0)
                {
                    num25 += (float)anchorBottom.tileCount;
                    int num28 = -1;
                    for (int l = 0; l < anchorBottom.tileCount; l++)
                    {
                        int  num29      = anchorBottom.checkStart + l;
                        Tile tileSafely = Framing.GetTileSafely(num8 + num29, num9 + num28);
                        bool flag6      = false;
                        if (tileSafely.nactive())
                        {
                            if (Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type] && !Main.tileNoAttach[tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                            {
                                flag6 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag6 && (anchorBottom.type & AnchorType.SolidBottom) == AnchorType.SolidBottom && ((Main.tileSolid[tileSafely.type] && (!Main.tileSolidTop[tileSafely.type] || (TileID.Sets.Platforms[tileSafely.type] && (tileSafely.halfBrick() || tileSafely.topSlope())))) || tileSafely.halfBrick() || tileSafely.topSlope()) && !TileID.Sets.NotReallySolid[tileSafely.type] && !tileSafely.bottomSlope())
                            {
                                flag6 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag6 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type])
                            {
                                int num27 = tileSafely.blockType();
                                if ((uint)(num27 - 2) <= 1u)
                                {
                                    flag6 = tileData2.isValidTileAnchor(tileSafely.type);
                                }
                            }
                            if (!flag6 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor(tileSafely.type))
                            {
                                flag6 = true;
                            }
                        }
                        else if (!flag6 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                        {
                            flag6 = true;
                        }
                        if (!flag6)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[num29 + num10, num28 + num11] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[num29 + num10, num28 + num11] = 1;
                        }
                        num24 += 1f;
                    }
                }
                anchorBottom = tileData2.AnchorRight;
                if (anchorBottom.tileCount != 0)
                {
                    num25 += (float)anchorBottom.tileCount;
                    int width = tileData2.Width;
                    for (int m = 0; m < anchorBottom.tileCount; m++)
                    {
                        int  num30      = anchorBottom.checkStart + m;
                        Tile tileSafely = Framing.GetTileSafely(num8 + width, num9 + num30);
                        bool flag7      = false;
                        if (tileSafely.nactive())
                        {
                            if (Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type] && !Main.tileNoAttach[tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                            {
                                flag7 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag7 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type])
                            {
                                int num27 = tileSafely.blockType();
                                if (num27 == 2 || num27 == 4)
                                {
                                    flag7 = tileData2.isValidTileAnchor(tileSafely.type);
                                }
                            }
                            if (!flag7 && (anchorBottom.type & AnchorType.Tree) == AnchorType.Tree && TileID.Sets.IsATreeTrunk[tileSafely.type])
                            {
                                flag7 = true;
                                if (m == 0)
                                {
                                    num25 += 1f;
                                    Tile tileSafely2 = Framing.GetTileSafely(num8 + width, num9 + num30 - 1);
                                    if (tileSafely2.nactive() && TileID.Sets.IsATreeTrunk[tileSafely2.type])
                                    {
                                        num24 += 1f;
                                        if (onlyCheck)
                                        {
                                            objectPreview[width + num10, num30 + num11 - 1] = 1;
                                        }
                                    }
                                    else if (onlyCheck)
                                    {
                                        objectPreview[width + num10, num30 + num11 - 1] = 2;
                                    }
                                }
                                if (m == anchorBottom.tileCount - 1)
                                {
                                    num25 += 1f;
                                    Tile tileSafely3 = Framing.GetTileSafely(num8 + width, num9 + num30 + 1);
                                    if (tileSafely3.nactive() && TileID.Sets.IsATreeTrunk[tileSafely3.type])
                                    {
                                        num24 += 1f;
                                        if (onlyCheck)
                                        {
                                            objectPreview[width + num10, num30 + num11 + 1] = 1;
                                        }
                                    }
                                    else if (onlyCheck)
                                    {
                                        objectPreview[width + num10, num30 + num11 + 1] = 2;
                                    }
                                }
                            }
                            if (!flag7 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor(tileSafely.type))
                            {
                                flag7 = true;
                            }
                        }
                        else if (!flag7 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                        {
                            flag7 = true;
                        }
                        if (!flag7)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[width + num10, num30 + num11] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[width + num10, num30 + num11] = 1;
                        }
                        num24 += 1f;
                    }
                }
                anchorBottom = tileData2.AnchorLeft;
                if (anchorBottom.tileCount != 0)
                {
                    num25 += (float)anchorBottom.tileCount;
                    int num31 = -1;
                    for (int n = 0; n < anchorBottom.tileCount; n++)
                    {
                        int  num32      = anchorBottom.checkStart + n;
                        Tile tileSafely = Framing.GetTileSafely(num8 + num31, num9 + num32);
                        bool flag8      = false;
                        if (tileSafely.nactive())
                        {
                            if (Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type] && !Main.tileNoAttach[tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                            {
                                flag8 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag8 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type])
                            {
                                int num27 = tileSafely.blockType();
                                if (num27 == 3 || num27 == 5)
                                {
                                    flag8 = tileData2.isValidTileAnchor(tileSafely.type);
                                }
                            }
                            if (!flag8 && (anchorBottom.type & AnchorType.Tree) == AnchorType.Tree && TileID.Sets.IsATreeTrunk[tileSafely.type])
                            {
                                flag8 = true;
                                if (n == 0)
                                {
                                    num25 += 1f;
                                    Tile tileSafely4 = Framing.GetTileSafely(num8 + num31, num9 + num32 - 1);
                                    if (tileSafely4.nactive() && TileID.Sets.IsATreeTrunk[tileSafely4.type])
                                    {
                                        num24 += 1f;
                                        if (onlyCheck)
                                        {
                                            objectPreview[num31 + num10, num32 + num11 - 1] = 1;
                                        }
                                    }
                                    else if (onlyCheck)
                                    {
                                        objectPreview[num31 + num10, num32 + num11 - 1] = 2;
                                    }
                                }
                                if (n == anchorBottom.tileCount - 1)
                                {
                                    num25 += 1f;
                                    Tile tileSafely5 = Framing.GetTileSafely(num8 + num31, num9 + num32 + 1);
                                    if (tileSafely5.nactive() && TileID.Sets.IsATreeTrunk[tileSafely5.type])
                                    {
                                        num24 += 1f;
                                        if (onlyCheck)
                                        {
                                            objectPreview[num31 + num10, num32 + num11 + 1] = 1;
                                        }
                                    }
                                    else if (onlyCheck)
                                    {
                                        objectPreview[num31 + num10, num32 + num11 + 1] = 2;
                                    }
                                }
                            }
                            if (!flag8 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor(tileSafely.type))
                            {
                                flag8 = true;
                            }
                        }
                        else if (!flag8 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                        {
                            flag8 = true;
                        }
                        if (!flag8)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[num31 + num10, num32 + num11] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[num31 + num10, num32 + num11] = 1;
                        }
                        num24 += 1f;
                    }
                }
                if (tileData2.HookCheckIfCanPlace.hook != null)
                {
                    if (tileData2.HookCheckIfCanPlace.processedCoordinates)
                    {
                        _ = tileData2.Origin;
                        _ = tileData2.Origin;
                    }
                    if (tileData2.HookCheckIfCanPlace.hook(x, y, type, style, dir, num7) == tileData2.HookCheckIfCanPlace.badReturn && tileData2.HookCheckIfCanPlace.badResponse == 0)
                    {
                        num24 = 0f;
                        num22 = 0f;
                        objectPreview.AllInvalid();
                    }
                }
                float num33 = num24 / num25;
                float num34 = num22 / num23;
                if (num34 == 1f && num25 == 0f)
                {
                    num23 = 1f;
                    num25 = 1f;
                    num33 = 1f;
                    num34 = 1f;
                }
                if (num33 == 1f && num34 == 1f)
                {
                    num4           = 1f;
                    num5           = 1f;
                    num6           = num7;
                    tileObjectData = tileData2;
                    break;
                }
                if (num33 > num4 || (num33 == num4 && num34 > num5))
                {
                    TileObjectPreviewData.placementCache.CopyFrom(objectPreview);
                    num4           = num33;
                    num5           = num34;
                    tileObjectData = tileData2;
                    num6           = num7;
                }
            }
            int num35 = -1;

            if (flag)
            {
                if (TileObjectPreviewData.randomCache == null)
                {
                    TileObjectPreviewData.randomCache = new TileObjectPreviewData();
                }
                bool flag9 = false;
                if (TileObjectPreviewData.randomCache.Type == type)
                {
                    Point16 coordinates = TileObjectPreviewData.randomCache.Coordinates;
                    Point16 objectStart = TileObjectPreviewData.randomCache.ObjectStart;
                    int     num36       = coordinates.X + objectStart.X;
                    int     num37       = coordinates.Y + objectStart.Y;
                    int     num38       = x - tileData.Origin.X;
                    int     num39       = y - tileData.Origin.Y;
                    if (num36 != num38 || num37 != num39)
                    {
                        flag9 = true;
                    }
                }
                else
                {
                    flag9 = true;
                }
                num35 = ((!flag9) ? TileObjectPreviewData.randomCache.Random : Main.rand.Next(tileData.RandomStyleRange));
            }
            if (onlyCheck)
            {
                if (num4 != 1f || num5 != 1f)
                {
                    objectPreview.CopyFrom(TileObjectPreviewData.placementCache);
                    num7 = num6;
                }
                objectPreview.Random = num35;
                if (tileData.RandomStyleRange > 0)
                {
                    TileObjectPreviewData.randomCache.CopyFrom(objectPreview);
                }
            }
            if (!onlyCheck)
            {
                objectData.xCoord    = x - tileObjectData.Origin.X;
                objectData.yCoord    = y - tileObjectData.Origin.Y;
                objectData.type      = type;
                objectData.style     = style;
                objectData.alternate = num7;
                objectData.random    = num35;
            }
            if (num4 == 1f)
            {
                return(num5 == 1f);
            }
            return(false);
        }
Esempio n. 6
0
        public static bool Place(TileObject toBePlaced)
        {
            TileObjectData tileData = TileObjectData.GetTileData(toBePlaced.type, toBePlaced.style, toBePlaced.alternate);

            if (tileData == null)
            {
                return(false);
            }
            if (tileData.HookPlaceOverride.hook != null)
            {
                int arg;
                int arg2;
                if (tileData.HookPlaceOverride.processedCoordinates)
                {
                    arg  = toBePlaced.xCoord;
                    arg2 = toBePlaced.yCoord;
                }
                else
                {
                    arg  = toBePlaced.xCoord + tileData.Origin.X;
                    arg2 = toBePlaced.yCoord + tileData.Origin.Y;
                }
                if (tileData.HookPlaceOverride.hook(arg, arg2, toBePlaced.type, toBePlaced.style, 1, toBePlaced.alternate) == tileData.HookPlaceOverride.badReturn)
                {
                    return(false);
                }
            }
            else
            {
                ushort num  = (ushort)toBePlaced.type;
                int    num2 = 0;
                int    num3 = 0;
                int    num4 = tileData.CalculatePlacementStyle(toBePlaced.style, toBePlaced.alternate, toBePlaced.random);
                int    num5 = 0;
                if (tileData.StyleWrapLimit > 0)
                {
                    num5  = num4 / tileData.StyleWrapLimit * tileData.StyleLineSkip;
                    num4 %= tileData.StyleWrapLimit;
                }
                if (tileData.StyleHorizontal)
                {
                    num2 = tileData.CoordinateFullWidth * num4;
                    num3 = tileData.CoordinateFullHeight * num5;
                }
                else
                {
                    num2 = tileData.CoordinateFullWidth * num5;
                    num3 = tileData.CoordinateFullHeight * num4;
                }
                int num6 = toBePlaced.xCoord;
                int num7 = toBePlaced.yCoord;
                for (int i = 0; i < tileData.Width; i++)
                {
                    for (int j = 0; j < tileData.Height; j++)
                    {
                        Tile tileSafely = Framing.GetTileSafely(num6 + i, num7 + j);
                        if (tileSafely.active() && tileSafely.type != 484 && (Main.tileCut[tileSafely.type] || TileID.Sets.BreakableWhenPlacing[tileSafely.type]))
                        {
                            WorldGen.KillTile(num6 + i, num7 + j);
                            if (!Main.tile[num6 + i, num7 + j].active() && Main.netMode == 1)
                            {
                                NetMessage.SendData(17, -1, -1, null, 0, num7 + i, num7 + j);
                            }
                        }
                    }
                }
                for (int k = 0; k < tileData.Width; k++)
                {
                    int num8 = num2 + k * (tileData.CoordinateWidth + tileData.CoordinatePadding);
                    int num9 = num3;
                    for (int l = 0; l < tileData.Height; l++)
                    {
                        Tile tileSafely2 = Framing.GetTileSafely(num6 + k, num7 + l);
                        if (!tileSafely2.active())
                        {
                            tileSafely2.active(active: true);
                            tileSafely2.frameX = (short)num8;
                            tileSafely2.frameY = (short)num9;
                            tileSafely2.type   = num;
                        }
                        num9 += tileData.CoordinateHeights[l] + tileData.CoordinatePadding;
                    }
                }
            }
            if (tileData.FlattenAnchors)
            {
                AnchorData anchorBottom = tileData.AnchorBottom;
                if (anchorBottom.tileCount != 0 && (anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int num10 = toBePlaced.xCoord + anchorBottom.checkStart;
                    int j2    = toBePlaced.yCoord + tileData.Height;
                    for (int m = 0; m < anchorBottom.tileCount; m++)
                    {
                        Tile tileSafely3 = Framing.GetTileSafely(num10 + m, j2);
                        if (Main.tileSolid[tileSafely3.type] && !Main.tileSolidTop[tileSafely3.type] && tileSafely3.blockType() != 0)
                        {
                            WorldGen.SlopeTile(num10 + m, j2);
                        }
                    }
                }
                anchorBottom = tileData.AnchorTop;
                if (anchorBottom.tileCount != 0 && (anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int num11 = toBePlaced.xCoord + anchorBottom.checkStart;
                    int j3    = toBePlaced.yCoord - 1;
                    for (int n = 0; n < anchorBottom.tileCount; n++)
                    {
                        Tile tileSafely4 = Framing.GetTileSafely(num11 + n, j3);
                        if (Main.tileSolid[tileSafely4.type] && !Main.tileSolidTop[tileSafely4.type] && tileSafely4.blockType() != 0)
                        {
                            WorldGen.SlopeTile(num11 + n, j3);
                        }
                    }
                }
                anchorBottom = tileData.AnchorRight;
                if (anchorBottom.tileCount != 0 && (anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int i2    = toBePlaced.xCoord + tileData.Width;
                    int num12 = toBePlaced.yCoord + anchorBottom.checkStart;
                    for (int num13 = 0; num13 < anchorBottom.tileCount; num13++)
                    {
                        Tile tileSafely5 = Framing.GetTileSafely(i2, num12 + num13);
                        if (Main.tileSolid[tileSafely5.type] && !Main.tileSolidTop[tileSafely5.type] && tileSafely5.blockType() != 0)
                        {
                            WorldGen.SlopeTile(i2, num12 + num13);
                        }
                    }
                }
                anchorBottom = tileData.AnchorLeft;
                if (anchorBottom.tileCount != 0 && (anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int i3    = toBePlaced.xCoord - 1;
                    int num14 = toBePlaced.yCoord + anchorBottom.checkStart;
                    for (int num15 = 0; num15 < anchorBottom.tileCount; num15++)
                    {
                        Tile tileSafely6 = Framing.GetTileSafely(i3, num14 + num15);
                        if (Main.tileSolid[tileSafely6.type] && !Main.tileSolidTop[tileSafely6.type] && tileSafely6.blockType() != 0)
                        {
                            WorldGen.SlopeTile(i3, num14 + num15);
                        }
                    }
                }
            }
            return(true);
        }
Esempio n. 7
0
 private static Framing.BlockStyle FindBlockStyle(Tile blockTile)
 {
     return Framing.blockStyleLookup[blockTile.blockType()];
 }
Esempio n. 8
0
        public static bool CanPlace(int x, int y, int type, int style, int dir, out TileObject objectData, bool onlyCheck = false)
        {
            TileObjectData tileData1 = TileObjectData.GetTileData(type, style, 0);

            objectData = TileObject.Empty;
            if (tileData1 == null)
            {
                return(false);
            }
            int num1 = x - (int)tileData1.Origin.X;
            int num2 = y - (int)tileData1.Origin.Y;

            if (num1 < 0 || num1 + tileData1.Width >= Main.maxTilesX || (num2 < 0 || num2 + tileData1.Height >= Main.maxTilesY))
            {
                return(false);
            }
            bool flag1 = tileData1.RandomStyleRange > 0;

            if (TileObjectPreviewData.placementCache == null)
            {
                TileObjectPreviewData.placementCache = new TileObjectPreviewData();
            }
            TileObjectPreviewData.placementCache.Reset();
            int num3 = 0;
            int num4 = 0;

            if (tileData1.AlternatesCount != 0)
            {
                num4 = tileData1.AlternatesCount;
            }
            float          num5           = -1f;
            float          num6           = -1f;
            int            num7           = 0;
            TileObjectData tileObjectData = (TileObjectData)null;
            int            alternate      = num3 - 1;

            while (alternate < num4)
            {
                ++alternate;
                TileObjectData tileData2 = TileObjectData.GetTileData(type, style, alternate);
                if (tileData2.Direction == TileObjectDirection.None || (tileData2.Direction != TileObjectDirection.PlaceLeft || dir != 1) && (tileData2.Direction != TileObjectDirection.PlaceRight || dir != -1))
                {
                    int num8 = x - (int)tileData2.Origin.X;
                    int num9 = y - (int)tileData2.Origin.Y;
                    if (num8 < 5 || num8 + tileData2.Width > Main.maxTilesX - 5 || (num9 < 5 || num9 + tileData2.Height > Main.maxTilesY - 5))
                    {
                        return(false);
                    }
                    Rectangle rectangle;
                    // ISSUE: explicit reference operation
                    ((Rectangle)@rectangle).\u002Ector(0, 0, tileData2.Width, tileData2.Height);
                    int X = 0;
                    int Y = 0;
                    if (tileData2.AnchorTop.tileCount != 0)
                    {
                        if (rectangle.Y == null)
                        {
                            rectangle.Y = (__Null) - 1;
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Height + 1;
                            // ISSUE: explicit reference operation
                            (^ local).Height = (__Null)num10;
                            ++Y;
                        }
                        int checkStart = tileData2.AnchorTop.checkStart;
                        if (checkStart < rectangle.X)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Width + (rectangle.X - checkStart);
                            // ISSUE: explicit reference operation
                            (^ local).Width = (__Null)num10;
                            X          += rectangle.X - checkStart;
                            rectangle.X = (__Null)checkStart;
                        }
                        int num11 = checkStart + tileData2.AnchorTop.tileCount - 1;
                        int num12 = rectangle.X + rectangle.Width - 1;
                        if (num11 > num12)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Width + (num11 - num12);
                            // ISSUE: explicit reference operation
                            (^ local).Width = (__Null)num10;
                        }
                    }
                    if (tileData2.AnchorBottom.tileCount != 0)
                    {
                        if (rectangle.Y + rectangle.Height == tileData2.Height)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Height + 1;
                            // ISSUE: explicit reference operation
                            (^ local).Height = (__Null)num10;
                        }
                        int checkStart = tileData2.AnchorBottom.checkStart;
                        if (checkStart < rectangle.X)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Width + (rectangle.X - checkStart);
                            // ISSUE: explicit reference operation
                            (^ local).Width = (__Null)num10;
                            X          += rectangle.X - checkStart;
                            rectangle.X = (__Null)checkStart;
                        }
                        int num11 = checkStart + tileData2.AnchorBottom.tileCount - 1;
                        int num12 = rectangle.X + rectangle.Width - 1;
                        if (num11 > num12)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Width + (num11 - num12);
                            // ISSUE: explicit reference operation
                            (^ local).Width = (__Null)num10;
                        }
                    }
                    if (tileData2.AnchorLeft.tileCount != 0)
                    {
                        if (rectangle.X == null)
                        {
                            rectangle.X = (__Null) - 1;
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Width + 1;
                            // ISSUE: explicit reference operation
                            (^ local).Width = (__Null)num10;
                            ++X;
                        }
                        int checkStart = tileData2.AnchorLeft.checkStart;
                        if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            --checkStart;
                        }
                        if (checkStart < rectangle.Y)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Width + (rectangle.Y - checkStart);
                            // ISSUE: explicit reference operation
                            (^ local).Width = (__Null)num10;
                            Y          += rectangle.Y - checkStart;
                            rectangle.Y = (__Null)checkStart;
                        }
                        int num11 = checkStart + tileData2.AnchorLeft.tileCount - 1;
                        if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            num11 += 2;
                        }
                        int num12 = rectangle.Y + rectangle.Height - 1;
                        if (num11 > num12)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Height + (num11 - num12);
                            // ISSUE: explicit reference operation
                            (^ local).Height = (__Null)num10;
                        }
                    }
                    if (tileData2.AnchorRight.tileCount != 0)
                    {
                        if (rectangle.X + rectangle.Width == tileData2.Width)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Width + 1;
                            // ISSUE: explicit reference operation
                            (^ local).Width = (__Null)num10;
                        }
                        int checkStart = tileData2.AnchorLeft.checkStart;
                        if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            --checkStart;
                        }
                        if (checkStart < rectangle.Y)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Width + (rectangle.Y - checkStart);
                            // ISSUE: explicit reference operation
                            (^ local).Width = (__Null)num10;
                            Y          += rectangle.Y - checkStart;
                            rectangle.Y = (__Null)checkStart;
                        }
                        int num11 = checkStart + tileData2.AnchorRight.tileCount - 1;
                        if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            num11 += 2;
                        }
                        int num12 = rectangle.Y + rectangle.Height - 1;
                        if (num11 > num12)
                        {
                            // ISSUE: explicit reference operation
                            // ISSUE: variable of a reference type
                            Rectangle& local = @rectangle;
                            // ISSUE: explicit reference operation
                            int num10 = (^ local).Height + (num11 - num12);
                            // ISSUE: explicit reference operation
                            (^ local).Height = (__Null)num10;
                        }
                    }
                    if (onlyCheck)
                    {
                        TileObject.objectPreview.Reset();
                        TileObject.objectPreview.Active      = true;
                        TileObject.objectPreview.Type        = (ushort)type;
                        TileObject.objectPreview.Style       = (short)style;
                        TileObject.objectPreview.Alternate   = alternate;
                        TileObject.objectPreview.Size        = new Point16((int)rectangle.Width, (int)rectangle.Height);
                        TileObject.objectPreview.ObjectStart = new Point16(X, Y);
                        TileObject.objectPreview.Coordinates = new Point16(num8 - X, num9 - Y);
                    }
                    float num13 = 0.0f;
                    float num14 = (float)(tileData2.Width * tileData2.Height);
                    float num15 = 0.0f;
                    float num16 = 0.0f;
                    for (int index1 = 0; index1 < tileData2.Width; ++index1)
                    {
                        for (int index2 = 0; index2 < tileData2.Height; ++index2)
                        {
                            Tile tileSafely = Framing.GetTileSafely(num8 + index1, num9 + index2);
                            bool flag2      = !tileData2.LiquidPlace(tileSafely);
                            bool flag3      = false;
                            if (tileData2.AnchorWall)
                            {
                                ++num16;
                                if (!tileData2.isValidWallAnchor((int)tileSafely.wall))
                                {
                                    flag3 = true;
                                }
                                else
                                {
                                    ++num15;
                                }
                            }
                            bool flag4 = false;
                            if (tileSafely.active() && !Main.tileCut[(int)tileSafely.type])
                            {
                                flag4 = true;
                            }
                            if (flag4 || flag2 || flag3)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[index1 + X, index2 + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[index1 + X, index2 + Y] = 1;
                                }
                                ++num13;
                            }
                        }
                    }
                    AnchorData anchorBottom = tileData2.AnchorBottom;
                    if (anchorBottom.tileCount != 0)
                    {
                        num16 += (float)anchorBottom.tileCount;
                        int height = tileData2.Height;
                        for (int index = 0; index < anchorBottom.tileCount; ++index)
                        {
                            int  num10      = anchorBottom.checkStart + index;
                            Tile tileSafely = Framing.GetTileSafely(num8 + num10, num9 + height);
                            bool flag2      = false;
                            if (tileSafely.nactive())
                            {
                                if ((anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile && Main.tileSolid[(int)tileSafely.type] && (!Main.tileSolidTop[(int)tileSafely.type] && !Main.tileNoAttach[(int)tileSafely.type]) && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag2 && ((anchorBottom.type & AnchorType.SolidWithTop) == AnchorType.SolidWithTop || (anchorBottom.type & AnchorType.Table) == AnchorType.Table))
                                {
                                    if (TileID.Sets.Platforms[(int)tileSafely.type])
                                    {
                                        int num11 = (int)tileSafely.frameX / TileObjectData.PlatformFrameWidth();
                                        if (!tileSafely.halfBrick() && num11 >= 0 && num11 <= 7 || (num11 >= 12 && num11 <= 16 || num11 >= 25 && num11 <= 26))
                                        {
                                            flag2 = true;
                                        }
                                    }
                                    else if (Main.tileSolid[(int)tileSafely.type] && Main.tileSolidTop[(int)tileSafely.type])
                                    {
                                        flag2 = true;
                                    }
                                }
                                if (!flag2 && (anchorBottom.type & AnchorType.Table) == AnchorType.Table && (!TileID.Sets.Platforms[(int)tileSafely.type] && Main.tileTable[(int)tileSafely.type]) && tileSafely.blockType() == 0)
                                {
                                    flag2 = true;
                                }
                                if (!flag2 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type]))
                                {
                                    switch (tileSafely.blockType())
                                    {
                                    case 4:
                                    case 5:
                                        flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                        break;
                                    }
                                }
                                if (!flag2 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely.type))
                                {
                                    flag2 = true;
                                }
                            }
                            else if (!flag2 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag2 = true;
                            }
                            if (!flag2)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num10 + X, height + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num10 + X, height + Y] = 1;
                                }
                                ++num15;
                            }
                        }
                    }
                    AnchorData anchorTop = tileData2.AnchorTop;
                    if (anchorTop.tileCount != 0)
                    {
                        num16 += (float)anchorTop.tileCount;
                        int num10 = -1;
                        for (int index = 0; index < anchorTop.tileCount; ++index)
                        {
                            int  num11      = anchorTop.checkStart + index;
                            Tile tileSafely = Framing.GetTileSafely(num8 + num11, num9 + num10);
                            bool flag2      = false;
                            if (tileSafely.nactive())
                            {
                                if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && !Main.tileNoAttach[(int)tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag2 && (anchorTop.type & AnchorType.SolidBottom) == AnchorType.SolidBottom && (Main.tileSolid[(int)tileSafely.type] && (!Main.tileSolidTop[(int)tileSafely.type] || TileID.Sets.Platforms[(int)tileSafely.type] && (tileSafely.halfBrick() || tileSafely.topSlope())) || (tileSafely.halfBrick() || tileSafely.topSlope())) && (!TileID.Sets.NotReallySolid[(int)tileSafely.type] && !tileSafely.bottomSlope()))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag2 && (anchorTop.type & AnchorType.SolidSide) == AnchorType.SolidSide && (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type]))
                                {
                                    switch (tileSafely.blockType())
                                    {
                                    case 2:
                                    case 3:
                                        flag2 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                        break;
                                    }
                                }
                                if (!flag2 && (anchorTop.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely.type))
                                {
                                    flag2 = true;
                                }
                            }
                            else if (!flag2 && (anchorTop.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag2 = true;
                            }
                            if (!flag2)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num11 + X, num10 + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num11 + X, num10 + Y] = 1;
                                }
                                ++num15;
                            }
                        }
                    }
                    AnchorData anchorRight = tileData2.AnchorRight;
                    if (anchorRight.tileCount != 0)
                    {
                        num16 += (float)anchorRight.tileCount;
                        int width = tileData2.Width;
                        for (int index = 0; index < anchorRight.tileCount; ++index)
                        {
                            int  num10       = anchorRight.checkStart + index;
                            Tile tileSafely1 = Framing.GetTileSafely(num8 + width, num9 + num10);
                            bool flag2       = false;
                            if (tileSafely1.nactive())
                            {
                                if (Main.tileSolid[(int)tileSafely1.type] && !Main.tileSolidTop[(int)tileSafely1.type] && !Main.tileNoAttach[(int)tileSafely1.type] && (tileData2.FlattenAnchors || tileSafely1.blockType() == 0))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely1.type);
                                }
                                if (!flag2 && (anchorRight.type & AnchorType.SolidSide) == AnchorType.SolidSide && (Main.tileSolid[(int)tileSafely1.type] && !Main.tileSolidTop[(int)tileSafely1.type]))
                                {
                                    switch (tileSafely1.blockType())
                                    {
                                    case 2:
                                    case 4:
                                        flag2 = tileData2.isValidTileAnchor((int)tileSafely1.type);
                                        break;
                                    }
                                }
                                if (!flag2 && (anchorRight.type & AnchorType.Tree) == AnchorType.Tree && (int)tileSafely1.type == 5)
                                {
                                    flag2 = true;
                                    if (index == 0)
                                    {
                                        ++num16;
                                        Tile tileSafely2 = Framing.GetTileSafely(num8 + width, num9 + num10 - 1);
                                        if (tileSafely2.nactive() && (int)tileSafely2.type == 5)
                                        {
                                            ++num15;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[width + X, num10 + Y - 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[width + X, num10 + Y - 1] = 2;
                                        }
                                    }
                                    if (index == anchorRight.tileCount - 1)
                                    {
                                        ++num16;
                                        Tile tileSafely2 = Framing.GetTileSafely(num8 + width, num9 + num10 + 1);
                                        if (tileSafely2.nactive() && (int)tileSafely2.type == 5)
                                        {
                                            ++num15;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[width + X, num10 + Y + 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[width + X, num10 + Y + 1] = 2;
                                        }
                                    }
                                }
                                if (!flag2 && (anchorRight.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely1.type))
                                {
                                    flag2 = true;
                                }
                            }
                            else if (!flag2 && (anchorRight.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag2 = true;
                            }
                            if (!flag2)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[width + X, num10 + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[width + X, num10 + Y] = 1;
                                }
                                ++num15;
                            }
                        }
                    }
                    AnchorData anchorLeft = tileData2.AnchorLeft;
                    if (anchorLeft.tileCount != 0)
                    {
                        num16 += (float)anchorLeft.tileCount;
                        int num10 = -1;
                        for (int index = 0; index < anchorLeft.tileCount; ++index)
                        {
                            int  num11       = anchorLeft.checkStart + index;
                            Tile tileSafely1 = Framing.GetTileSafely(num8 + num10, num9 + num11);
                            bool flag2       = false;
                            if (tileSafely1.nactive())
                            {
                                if (Main.tileSolid[(int)tileSafely1.type] && !Main.tileSolidTop[(int)tileSafely1.type] && !Main.tileNoAttach[(int)tileSafely1.type] && (tileData2.FlattenAnchors || tileSafely1.blockType() == 0))
                                {
                                    flag2 = tileData2.isValidTileAnchor((int)tileSafely1.type);
                                }
                                if (!flag2 && (anchorLeft.type & AnchorType.SolidSide) == AnchorType.SolidSide && (Main.tileSolid[(int)tileSafely1.type] && !Main.tileSolidTop[(int)tileSafely1.type]))
                                {
                                    switch (tileSafely1.blockType())
                                    {
                                    case 3:
                                    case 5:
                                        flag2 = tileData2.isValidTileAnchor((int)tileSafely1.type);
                                        break;
                                    }
                                }
                                if (!flag2 && (anchorLeft.type & AnchorType.Tree) == AnchorType.Tree && (int)tileSafely1.type == 5)
                                {
                                    flag2 = true;
                                    if (index == 0)
                                    {
                                        ++num16;
                                        Tile tileSafely2 = Framing.GetTileSafely(num8 + num10, num9 + num11 - 1);
                                        if (tileSafely2.nactive() && (int)tileSafely2.type == 5)
                                        {
                                            ++num15;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[num10 + X, num11 + Y - 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[num10 + X, num11 + Y - 1] = 2;
                                        }
                                    }
                                    if (index == anchorLeft.tileCount - 1)
                                    {
                                        ++num16;
                                        Tile tileSafely2 = Framing.GetTileSafely(num8 + num10, num9 + num11 + 1);
                                        if (tileSafely2.nactive() && (int)tileSafely2.type == 5)
                                        {
                                            ++num15;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[num10 + X, num11 + Y + 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[num10 + X, num11 + Y + 1] = 2;
                                        }
                                    }
                                }
                                if (!flag2 && (anchorLeft.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely1.type))
                                {
                                    flag2 = true;
                                }
                            }
                            else if (!flag2 && (anchorLeft.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag2 = true;
                            }
                            if (!flag2)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num10 + X, num11 + Y] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num10 + X, num11 + Y] = 1;
                                }
                                ++num15;
                            }
                        }
                    }
                    if (tileData2.HookCheck.hook != null)
                    {
                        if (tileData2.HookCheck.processedCoordinates)
                        {
                            int x1 = (int)tileData2.Origin.X;
                            int y1 = (int)tileData2.Origin.Y;
                        }
                        if (tileData2.HookCheck.hook.Invoke(x, y, type, style, dir) == tileData2.HookCheck.badReturn && tileData2.HookCheck.badResponse == 0)
                        {
                            num15 = 0.0f;
                            num13 = 0.0f;
                            TileObject.objectPreview.AllInvalid();
                        }
                    }
                    float num17 = num15 / num16;
                    float num18 = num13 / num14;
                    if ((double)num18 == 1.0 && (double)num16 == 0.0)
                    {
                        num17 = 1f;
                        num18 = 1f;
                    }
                    if ((double)num17 == 1.0 && (double)num18 == 1.0)
                    {
                        num5           = 1f;
                        num6           = 1f;
                        num7           = alternate;
                        tileObjectData = tileData2;
                        break;
                    }
                    if ((double)num17 > (double)num5 || (double)num17 == (double)num5 && (double)num18 > (double)num6)
                    {
                        TileObjectPreviewData.placementCache.CopyFrom(TileObject.objectPreview);
                        num5           = num17;
                        num6           = num18;
                        tileObjectData = tileData2;
                        num7           = alternate;
                    }
                }
            }
            int num19 = -1;

            if (flag1)
            {
                if (TileObjectPreviewData.randomCache == null)
                {
                    TileObjectPreviewData.randomCache = new TileObjectPreviewData();
                }
                bool flag2 = false;
                if ((int)TileObjectPreviewData.randomCache.Type == type)
                {
                    Point16 coordinates = TileObjectPreviewData.randomCache.Coordinates;
                    Point16 objectStart = TileObjectPreviewData.randomCache.ObjectStart;
                    int     num8        = (int)coordinates.X + (int)objectStart.X;
                    int     num9        = (int)coordinates.Y + (int)objectStart.Y;
                    int     num10       = x - (int)tileData1.Origin.X;
                    int     num11       = y - (int)tileData1.Origin.Y;
                    if (num8 != num10 || num9 != num11)
                    {
                        flag2 = true;
                    }
                }
                else
                {
                    flag2 = true;
                }
                num19 = !flag2 ? TileObjectPreviewData.randomCache.Random : Main.rand.Next(tileData1.RandomStyleRange);
            }
            if (onlyCheck)
            {
                if ((double)num5 != 1.0 || (double)num6 != 1.0)
                {
                    TileObject.objectPreview.CopyFrom(TileObjectPreviewData.placementCache);
                    alternate = num7;
                }
                TileObject.objectPreview.Random = num19;
                if (tileData1.RandomStyleRange > 0)
                {
                    TileObjectPreviewData.randomCache.CopyFrom(TileObject.objectPreview);
                }
            }
            if (!onlyCheck)
            {
                objectData.xCoord    = x - (int)tileObjectData.Origin.X;
                objectData.yCoord    = y - (int)tileObjectData.Origin.Y;
                objectData.type      = type;
                objectData.style     = style;
                objectData.alternate = alternate;
                objectData.random    = num19;
            }
            if ((double)num5 == 1.0)
            {
                return((double)num6 == 1.0);
            }
            return(false);
        }
Esempio n. 9
0
        public static bool Place(TileObject toBePlaced)
        {
            TileObjectData tileData = TileObjectData.GetTileData(toBePlaced.type, toBePlaced.style, toBePlaced.alternate);

            if (tileData == null)
            {
                return(false);
            }
            if (tileData.HookPlaceOverride.hook != null)
            {
                int num1;
                int num2;
                if (tileData.HookPlaceOverride.processedCoordinates)
                {
                    num1 = toBePlaced.xCoord;
                    num2 = toBePlaced.yCoord;
                }
                else
                {
                    num1 = toBePlaced.xCoord + (int)tileData.Origin.X;
                    num2 = toBePlaced.yCoord + (int)tileData.Origin.Y;
                }
                if (tileData.HookPlaceOverride.hook(num1, num2, toBePlaced.type, toBePlaced.style, 1) == tileData.HookPlaceOverride.badReturn)
                {
                    return(false);
                }
            }
            else
            {
                ushort num1 = (ushort)toBePlaced.type;
                int    num2 = tileData.CalculatePlacementStyle(toBePlaced.style, toBePlaced.alternate, toBePlaced.random);
                int    num3 = 0;
                if (tileData.StyleWrapLimit > 0)
                {
                    num3  = num2 / tileData.StyleWrapLimit;
                    num2 %= tileData.StyleWrapLimit;
                }
                int num4;
                int num5;
                if (tileData.StyleHorizontal)
                {
                    num4 = tileData.CoordinateFullWidth * num2;
                    num5 = tileData.CoordinateFullHeight * num3;
                }
                else
                {
                    num4 = tileData.CoordinateFullWidth * num3;
                    num5 = tileData.CoordinateFullHeight * num2;
                }
                int num6 = toBePlaced.xCoord;
                int num7 = toBePlaced.yCoord;
                for (int index1 = 0; index1 < tileData.Width; ++index1)
                {
                    for (int index2 = 0; index2 < tileData.Height; ++index2)
                    {
                        Tile tileSafely = Framing.GetTileSafely(num6 + index1, num7 + index2);
                        if (tileSafely.active() && Main.tileCut[(int)tileSafely.type])
                        {
                            WorldGen.KillTile(num6 + index1, num7 + index2, false, false, false);
                        }
                    }
                }
                for (int index1 = 0; index1 < tileData.Width; ++index1)
                {
                    int num8 = num4 + index1 * (tileData.CoordinateWidth + tileData.CoordinatePadding);
                    int num9 = num5;
                    for (int index2 = 0; index2 < tileData.Height; ++index2)
                    {
                        Tile tileSafely = Framing.GetTileSafely(num6 + index1, num7 + index2);
                        if (!tileSafely.active())
                        {
                            tileSafely.active(true);
                            tileSafely.frameX = (short)num8;
                            tileSafely.frameY = (short)num9;
                            tileSafely.type   = num1;
                        }
                        num9 += tileData.CoordinateHeights[index2] + tileData.CoordinatePadding;
                    }
                }
            }
            if (tileData.FlattenAnchors)
            {
                AnchorData anchorData = tileData.AnchorBottom;
                if (anchorData.tileCount != 0 && (anchorData.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int num = toBePlaced.xCoord + anchorData.checkStart;
                    int j   = toBePlaced.yCoord + tileData.Height;
                    for (int index = 0; index < anchorData.tileCount; ++index)
                    {
                        Tile tileSafely = Framing.GetTileSafely(num + index, j);
                        if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && tileSafely.blockType() != 0)
                        {
                            WorldGen.SlopeTile(num + index, j, 0);
                        }
                    }
                }
                anchorData = tileData.AnchorTop;
                if (anchorData.tileCount != 0 && (anchorData.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int num = toBePlaced.xCoord + anchorData.checkStart;
                    int j   = toBePlaced.yCoord - 1;
                    for (int index = 0; index < anchorData.tileCount; ++index)
                    {
                        Tile tileSafely = Framing.GetTileSafely(num + index, j);
                        if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && tileSafely.blockType() != 0)
                        {
                            WorldGen.SlopeTile(num + index, j, 0);
                        }
                    }
                }
                anchorData = tileData.AnchorRight;
                if (anchorData.tileCount != 0 && (anchorData.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int i   = toBePlaced.xCoord + tileData.Width;
                    int num = toBePlaced.yCoord + anchorData.checkStart;
                    for (int index = 0; index < anchorData.tileCount; ++index)
                    {
                        Tile tileSafely = Framing.GetTileSafely(i, num + index);
                        if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && tileSafely.blockType() != 0)
                        {
                            WorldGen.SlopeTile(i, num + index, 0);
                        }
                    }
                }
                anchorData = tileData.AnchorLeft;
                if (anchorData.tileCount != 0 && (anchorData.type & AnchorType.SolidTile) == AnchorType.SolidTile)
                {
                    int i   = toBePlaced.xCoord - 1;
                    int num = toBePlaced.yCoord + anchorData.checkStart;
                    for (int index = 0; index < anchorData.tileCount; ++index)
                    {
                        Tile tileSafely = Framing.GetTileSafely(i, num + index);
                        if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && tileSafely.blockType() != 0)
                        {
                            WorldGen.SlopeTile(i, num + index, 0);
                        }
                    }
                }
            }
            return(true);
        }
Esempio n. 10
0
 public static bool AnchorValid(Tile tileCache, AnchorType anchor)
 {
     bool flag = false;
     if (tileCache.nactive())
     {
         if ((anchor & AnchorType.SolidTile) == AnchorType.SolidTile && Main.tileSolid[(int)tileCache.type] && !Main.tileSolidTop[(int)tileCache.type] && !Main.tileNoAttach[(int)tileCache.type] && tileCache.blockType() == 0)
         {
             flag = true;
         }
         if ((anchor & AnchorType.SolidBottom) == AnchorType.SolidBottom && !Main.tileNoAttach[(int)tileCache.type] && ((Main.tileSolid[(int)tileCache.type] && (!Main.tileSolidTop[(int)tileCache.type] || (tileCache.type == 19 && (tileCache.halfBrick() || tileCache.topSlope())))) || tileCache.topSlope() || tileCache.halfBrick()) && !TileID.Sets.NotReallySolid[(int)tileCache.type] && !tileCache.bottomSlope())
         {
             flag = true;
         }
         if (!flag && ((anchor & AnchorType.SolidWithTop) == AnchorType.SolidWithTop || (anchor & AnchorType.Table) == AnchorType.Table))
         {
             if (tileCache.type == 19)
             {
                 int num = (int)tileCache.frameX / TileObjectData.PlatformFrameWidth();
                 if ((!tileCache.halfBrick() && num >= 0 && num <= 7) || (num >= 12 && num <= 16) || (num >= 25 && num <= 26))
                 {
                     flag = true;
                 }
             }
             else if (Main.tileSolid[(int)tileCache.type] && Main.tileSolidTop[(int)tileCache.type])
             {
                 flag = true;
             }
         }
         if (!flag && (anchor & AnchorType.Table) == AnchorType.Table && tileCache.type != 19 && Main.tileTable[(int)tileCache.type] && tileCache.blockType() == 0)
         {
             flag = true;
         }
         if (!flag && (anchor & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[(int)tileCache.type] && !Main.tileSolidTop[(int)tileCache.type])
         {
             switch (tileCache.blockType())
             {
                 case 4:
                 case 5:
                     flag = true;
                     break;
             }
         }
     }
     else if (!flag && (anchor & AnchorType.EmptyTile) == AnchorType.EmptyTile)
     {
         flag = true;
     }
     return flag;
 }
Esempio n. 11
0
        public static bool CanPlace(int x, int y, int type, int style, int dir, out TileObject objectData, bool onlyCheck = false)
        {
            TileObjectData tileData = TileObjectData.GetTileData(type, style);

            objectData = Empty;
            if (tileData == null)
            {
                return(false);
            }
            int num  = x - tileData.Origin.X;
            int num2 = y - tileData.Origin.Y;

            if (num < 0 || num + tileData.Width >= Main.maxTilesX || num2 < 0 || num2 + tileData.Height >= Main.maxTilesY)
            {
                return(false);
            }
            bool flag = tileData.RandomStyleRange > 0;

            if (TileObjectPreviewData.placementCache == null)
            {
                TileObjectPreviewData.placementCache = new TileObjectPreviewData();
            }
            TileObjectPreviewData.placementCache.Reset();
            int num3 = 0;
            int num4 = 0;

            if (tileData.AlternatesCount != 0)
            {
                num4 = tileData.AlternatesCount;
            }
            float          num5           = -1f;
            float          num6           = -1f;
            int            num7           = 0;
            TileObjectData tileObjectData = null;
            int            num8           = num3 - 1;

            while (num8 < num4)
            {
                num8++;
                TileObjectData tileData2 = TileObjectData.GetTileData(type, style, num8);
                if (tileData2.Direction != 0 && ((tileData2.Direction == TileObjectDirection.PlaceLeft && dir == 1) || (tileData2.Direction == TileObjectDirection.PlaceRight && dir == -1)))
                {
                    continue;
                }
                int num9  = x - tileData2.Origin.X;
                int num10 = y - tileData2.Origin.Y;
                if (num9 < 5 || num9 + tileData2.Width > Main.maxTilesX - 5 || num10 < 5 || num10 + tileData2.Height > Main.maxTilesY - 5)
                {
                    return(false);
                }
                Rectangle rectangle = new Rectangle(0, 0, tileData2.Width, tileData2.Height);
                int       num11     = 0;
                int       num12     = 0;
                if (tileData2.AnchorTop.tileCount != 0)
                {
                    if (rectangle.Y == 0)
                    {
                        rectangle.Y = -1;
                        rectangle.Height++;
                        num12++;
                    }
                    int checkStart = tileData2.AnchorTop.checkStart;
                    if (checkStart < rectangle.X)
                    {
                        rectangle.Width += rectangle.X - checkStart;
                        num11           += rectangle.X - checkStart;
                        rectangle.X      = checkStart;
                    }
                    int num13 = checkStart + tileData2.AnchorTop.tileCount - 1;
                    int num14 = rectangle.X + rectangle.Width - 1;
                    if (num13 > num14)
                    {
                        rectangle.Width += num13 - num14;
                    }
                }
                if (tileData2.AnchorBottom.tileCount != 0)
                {
                    if (rectangle.Y + rectangle.Height == tileData2.Height)
                    {
                        rectangle.Height++;
                    }
                    int checkStart2 = tileData2.AnchorBottom.checkStart;
                    if (checkStart2 < rectangle.X)
                    {
                        rectangle.Width += rectangle.X - checkStart2;
                        num11           += rectangle.X - checkStart2;
                        rectangle.X      = checkStart2;
                    }
                    int num15 = checkStart2 + tileData2.AnchorBottom.tileCount - 1;
                    int num16 = rectangle.X + rectangle.Width - 1;
                    if (num15 > num16)
                    {
                        rectangle.Width += num15 - num16;
                    }
                }
                if (tileData2.AnchorLeft.tileCount != 0)
                {
                    if (rectangle.X == 0)
                    {
                        rectangle.X = -1;
                        rectangle.Width++;
                        num11++;
                    }
                    int num17 = tileData2.AnchorLeft.checkStart;
                    if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                    {
                        num17--;
                    }
                    if (num17 < rectangle.Y)
                    {
                        rectangle.Width += rectangle.Y - num17;
                        num12           += rectangle.Y - num17;
                        rectangle.Y      = num17;
                    }
                    int num18 = num17 + tileData2.AnchorLeft.tileCount - 1;
                    if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                    {
                        num18 += 2;
                    }
                    int num19 = rectangle.Y + rectangle.Height - 1;
                    if (num18 > num19)
                    {
                        rectangle.Height += num18 - num19;
                    }
                }
                if (tileData2.AnchorRight.tileCount != 0)
                {
                    if (rectangle.X + rectangle.Width == tileData2.Width)
                    {
                        rectangle.Width++;
                    }
                    int num20 = tileData2.AnchorLeft.checkStart;
                    if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                    {
                        num20--;
                    }
                    if (num20 < rectangle.Y)
                    {
                        rectangle.Width += rectangle.Y - num20;
                        num12           += rectangle.Y - num20;
                        rectangle.Y      = num20;
                    }
                    int num21 = num20 + tileData2.AnchorRight.tileCount - 1;
                    if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                    {
                        num21 += 2;
                    }
                    int num22 = rectangle.Y + rectangle.Height - 1;
                    if (num21 > num22)
                    {
                        rectangle.Height += num21 - num22;
                    }
                }
                if (onlyCheck)
                {
                    objectPreview.Reset();
                    objectPreview.Active      = true;
                    objectPreview.Type        = (ushort)type;
                    objectPreview.Style       = (short)style;
                    objectPreview.Alternate   = num8;
                    objectPreview.Size        = new Point16(rectangle.Width, rectangle.Height);
                    objectPreview.ObjectStart = new Point16(num11, num12);
                    objectPreview.Coordinates = new Point16(num9 - num11, num10 - num12);
                }
                float num23 = 0f;
                float num24 = tileData2.Width * tileData2.Height;
                float num25 = 0f;
                float num26 = 0f;
                for (int i = 0; i < tileData2.Width; i++)
                {
                    for (int j = 0; j < tileData2.Height; j++)
                    {
                        Tile tileSafely = Framing.GetTileSafely(num9 + i, num10 + j);
                        bool flag2      = !tileData2.LiquidPlace(tileSafely);
                        bool flag3      = false;
                        if (tileData2.AnchorWall)
                        {
                            num26 += 1f;
                            if (!tileData2.isValidWallAnchor(tileSafely.wall))
                            {
                                flag3 = true;
                            }
                            else
                            {
                                num25 += 1f;
                            }
                        }
                        bool flag4 = false;
                        if (tileSafely.active() && !Main.tileCut[tileSafely.type])
                        {
                            flag4 = true;
                        }
                        if (flag4 || flag2 || flag3)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[i + num11, j + num12] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[i + num11, j + num12] = 1;
                        }
                        num23 += 1f;
                    }
                }
                AnchorData anchorBottom = tileData2.AnchorBottom;
                if (anchorBottom.tileCount != 0)
                {
                    num26 += (float)anchorBottom.tileCount;
                    int height = tileData2.Height;
                    for (int k = 0; k < anchorBottom.tileCount; k++)
                    {
                        int  num27      = anchorBottom.checkStart + k;
                        Tile tileSafely = Framing.GetTileSafely(num9 + num27, num10 + height);
                        bool flag5      = false;
                        if (tileSafely.nactive())
                        {
                            if ((anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type] && !Main.tileNoAttach[tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                            {
                                flag5 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag5 && ((anchorBottom.type & AnchorType.SolidWithTop) == AnchorType.SolidWithTop || (anchorBottom.type & AnchorType.Table) == AnchorType.Table))
                            {
                                if (tileSafely.type == 19)
                                {
                                    int num28 = tileSafely.frameX / TileObjectData.PlatformFrameWidth();
                                    if ((!tileSafely.halfBrick() && num28 >= 0 && num28 <= 7) || (num28 >= 12 && num28 <= 16) || (num28 >= 25 && num28 <= 26))
                                    {
                                        flag5 = true;
                                    }
                                }
                                else if (Main.tileSolid[tileSafely.type] && Main.tileSolidTop[tileSafely.type])
                                {
                                    flag5 = true;
                                }
                            }
                            if (!flag5 && (anchorBottom.type & AnchorType.Table) == AnchorType.Table && tileSafely.type != 19 && Main.tileTable[tileSafely.type] && tileSafely.blockType() == 0)
                            {
                                flag5 = true;
                            }
                            if (!flag5 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type])
                            {
                                switch (tileSafely.blockType())
                                {
                                case 4:
                                case 5:
                                    flag5 = tileData2.isValidTileAnchor(tileSafely.type);
                                    break;
                                }
                            }
                            if (!flag5 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor(tileSafely.type))
                            {
                                flag5 = true;
                            }
                        }
                        else if (!flag5 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                        {
                            flag5 = true;
                        }
                        if (!flag5)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[num27 + num11, height + num12] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[num27 + num11, height + num12] = 1;
                        }
                        num25 += 1f;
                    }
                }
                anchorBottom = tileData2.AnchorTop;
                if (anchorBottom.tileCount != 0)
                {
                    num26 += (float)anchorBottom.tileCount;
                    int num29 = -1;
                    for (int l = 0; l < anchorBottom.tileCount; l++)
                    {
                        int  num30      = anchorBottom.checkStart + l;
                        Tile tileSafely = Framing.GetTileSafely(num9 + num30, num10 + num29);
                        bool flag6      = false;
                        if (tileSafely.nactive())
                        {
                            if (Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type] && !Main.tileNoAttach[tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                            {
                                flag6 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag6 && (anchorBottom.type & AnchorType.SolidBottom) == AnchorType.SolidBottom && ((Main.tileSolid[tileSafely.type] && (!Main.tileSolidTop[tileSafely.type] || (tileSafely.type == 19 && (tileSafely.halfBrick() || tileSafely.topSlope())))) || tileSafely.halfBrick() || tileSafely.topSlope()) && !TileID.Sets.NotReallySolid[tileSafely.type] && !tileSafely.bottomSlope())
                            {
                                flag6 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag6 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type])
                            {
                                switch (tileSafely.blockType())
                                {
                                case 2:
                                case 3:
                                    flag6 = tileData2.isValidTileAnchor(tileSafely.type);
                                    break;
                                }
                            }
                            if (!flag6 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor(tileSafely.type))
                            {
                                flag6 = true;
                            }
                        }
                        else if (!flag6 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                        {
                            flag6 = true;
                        }
                        if (!flag6)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[num30 + num11, num29 + num12] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[num30 + num11, num29 + num12] = 1;
                        }
                        num25 += 1f;
                    }
                }
                anchorBottom = tileData2.AnchorRight;
                if (anchorBottom.tileCount != 0)
                {
                    num26 += (float)anchorBottom.tileCount;
                    int width = tileData2.Width;
                    for (int m = 0; m < anchorBottom.tileCount; m++)
                    {
                        int  num31      = anchorBottom.checkStart + m;
                        Tile tileSafely = Framing.GetTileSafely(num9 + width, num10 + num31);
                        bool flag7      = false;
                        if (tileSafely.nactive())
                        {
                            if (Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type] && !Main.tileNoAttach[tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                            {
                                flag7 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag7 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type])
                            {
                                switch (tileSafely.blockType())
                                {
                                case 2:
                                case 4:
                                    flag7 = tileData2.isValidTileAnchor(tileSafely.type);
                                    break;
                                }
                            }
                            if (!flag7 && (anchorBottom.type & AnchorType.Tree) == AnchorType.Tree && tileSafely.type == 5)
                            {
                                flag7 = true;
                                if (m == 0)
                                {
                                    num26 += 1f;
                                    Tile tileSafely2 = Framing.GetTileSafely(num9 + width, num10 + num31 - 1);
                                    if (tileSafely2.nactive() && tileSafely2.type == 5)
                                    {
                                        num25 += 1f;
                                        if (onlyCheck)
                                        {
                                            objectPreview[width + num11, num31 + num12 - 1] = 1;
                                        }
                                    }
                                    else if (onlyCheck)
                                    {
                                        objectPreview[width + num11, num31 + num12 - 1] = 2;
                                    }
                                }
                                if (m == anchorBottom.tileCount - 1)
                                {
                                    num26 += 1f;
                                    Tile tileSafely3 = Framing.GetTileSafely(num9 + width, num10 + num31 + 1);
                                    if (tileSafely3.nactive() && tileSafely3.type == 5)
                                    {
                                        num25 += 1f;
                                        if (onlyCheck)
                                        {
                                            objectPreview[width + num11, num31 + num12 + 1] = 1;
                                        }
                                    }
                                    else if (onlyCheck)
                                    {
                                        objectPreview[width + num11, num31 + num12 + 1] = 2;
                                    }
                                }
                            }
                            if (!flag7 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor(tileSafely.type))
                            {
                                flag7 = true;
                            }
                        }
                        else if (!flag7 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                        {
                            flag7 = true;
                        }
                        if (!flag7)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[width + num11, num31 + num12] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[width + num11, num31 + num12] = 1;
                        }
                        num25 += 1f;
                    }
                }
                anchorBottom = tileData2.AnchorLeft;
                if (anchorBottom.tileCount != 0)
                {
                    num26 += (float)anchorBottom.tileCount;
                    int num32 = -1;
                    for (int n = 0; n < anchorBottom.tileCount; n++)
                    {
                        int  num33      = anchorBottom.checkStart + n;
                        Tile tileSafely = Framing.GetTileSafely(num9 + num32, num10 + num33);
                        bool flag8      = false;
                        if (tileSafely.nactive())
                        {
                            if (Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type] && !Main.tileNoAttach[tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                            {
                                flag8 = tileData2.isValidTileAnchor(tileSafely.type);
                            }
                            if (!flag8 && (anchorBottom.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[tileSafely.type] && !Main.tileSolidTop[tileSafely.type])
                            {
                                switch (tileSafely.blockType())
                                {
                                case 3:
                                case 5:
                                    flag8 = tileData2.isValidTileAnchor(tileSafely.type);
                                    break;
                                }
                            }
                            if (!flag8 && (anchorBottom.type & AnchorType.Tree) == AnchorType.Tree && tileSafely.type == 5)
                            {
                                flag8 = true;
                                if (n == 0)
                                {
                                    num26 += 1f;
                                    Tile tileSafely4 = Framing.GetTileSafely(num9 + num32, num10 + num33 - 1);
                                    if (tileSafely4.nactive() && tileSafely4.type == 5)
                                    {
                                        num25 += 1f;
                                        if (onlyCheck)
                                        {
                                            objectPreview[num32 + num11, num33 + num12 - 1] = 1;
                                        }
                                    }
                                    else if (onlyCheck)
                                    {
                                        objectPreview[num32 + num11, num33 + num12 - 1] = 2;
                                    }
                                }
                                if (n == anchorBottom.tileCount - 1)
                                {
                                    num26 += 1f;
                                    Tile tileSafely5 = Framing.GetTileSafely(num9 + num32, num10 + num33 + 1);
                                    if (tileSafely5.nactive() && tileSafely5.type == 5)
                                    {
                                        num25 += 1f;
                                        if (onlyCheck)
                                        {
                                            objectPreview[num32 + num11, num33 + num12 + 1] = 1;
                                        }
                                    }
                                    else if (onlyCheck)
                                    {
                                        objectPreview[num32 + num11, num33 + num12 + 1] = 2;
                                    }
                                }
                            }
                            if (!flag8 && (anchorBottom.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor(tileSafely.type))
                            {
                                flag8 = true;
                            }
                        }
                        else if (!flag8 && (anchorBottom.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                        {
                            flag8 = true;
                        }
                        if (!flag8)
                        {
                            if (onlyCheck)
                            {
                                objectPreview[num32 + num11, num33 + num12] = 2;
                            }
                            continue;
                        }
                        if (onlyCheck)
                        {
                            objectPreview[num32 + num11, num33 + num12] = 1;
                        }
                        num25 += 1f;
                    }
                }
                if (tileData2.HookCheck.hook != null)
                {
                    if (tileData2.HookCheck.processedCoordinates)
                    {
                        short x2 = tileData2.Origin.X;
                        short y2 = tileData2.Origin.Y;
                    }
                    if (tileData2.HookCheck.hook(x, y, type, style, dir) == tileData2.HookCheck.badReturn && tileData2.HookCheck.badResponse == 0)
                    {
                        num25 = 0f;
                        num23 = 0f;
                        objectPreview.AllInvalid();
                    }
                }
                float num34 = num25 / num26;
                float num35 = num23 / num24;
                if (num34 == 1f && num35 == 1f)
                {
                    num5           = 1f;
                    num6           = 1f;
                    num7           = num8;
                    tileObjectData = tileData2;
                    break;
                }
                if (num34 > num5 || (num34 == num5 && num35 > num6))
                {
                    TileObjectPreviewData.placementCache.CopyFrom(objectPreview);
                    num5           = num34;
                    num6           = num35;
                    tileObjectData = tileData2;
                    num7           = num8;
                }
            }
            int num36 = -1;

            if (flag)
            {
                if (TileObjectPreviewData.randomCache == null)
                {
                    TileObjectPreviewData.randomCache = new TileObjectPreviewData();
                }
                bool flag9 = false;
                if (TileObjectPreviewData.randomCache.Type == type)
                {
                    Point16 coordinates = TileObjectPreviewData.randomCache.Coordinates;
                    Point16 objectStart = TileObjectPreviewData.randomCache.ObjectStart;
                    int     num37       = coordinates.X + objectStart.X;
                    int     num38       = coordinates.Y + objectStart.Y;
                    int     num39       = x - tileData.Origin.X;
                    int     num40       = y - tileData.Origin.Y;
                    if (num37 != num39 || num38 != num40)
                    {
                        flag9 = true;
                    }
                }
                else
                {
                    flag9 = true;
                }
                num36 = ((!flag9) ? TileObjectPreviewData.randomCache.Random : Main.rand.Next(tileData.RandomStyleRange));
            }
            if (onlyCheck)
            {
                if (num5 != 1f || num6 != 1f)
                {
                    objectPreview.CopyFrom(TileObjectPreviewData.placementCache);
                    num8 = num7;
                }
                objectPreview.Random = num36;
                if (tileData.RandomStyleRange > 0)
                {
                    TileObjectPreviewData.randomCache.CopyFrom(objectPreview);
                }
            }
            if (!onlyCheck)
            {
                objectData.xCoord    = x - tileObjectData.Origin.X;
                objectData.yCoord    = y - tileObjectData.Origin.Y;
                objectData.type      = type;
                objectData.style     = style;
                objectData.alternate = num8;
                objectData.random    = num36;
            }
            if (num5 == 1f)
            {
                return(num6 == 1f);
            }
            return(false);
        }
Esempio n. 12
0
		public static bool Place(TileObject toBePlaced)
		{
			int num;
			int num1;
			TileObjectData tileData = TileObjectData.GetTileData(toBePlaced.type, toBePlaced.style, toBePlaced.alternate);
			if (tileData == null)
			{
				return false;
			}
			if (tileData.HookPlaceOverride.hook == null)
			{
				ushort num2 = (ushort)toBePlaced.type;
				int coordinateFullWidth = 0;
				int coordinateFullHeight = 0;
				int styleWrapLimit = tileData.CalculatePlacementStyle(toBePlaced.style, toBePlaced.alternate, toBePlaced.random);
				int styleWrapLimit1 = 0;
				if (tileData.StyleWrapLimit > 0)
				{
					styleWrapLimit1 = styleWrapLimit / tileData.StyleWrapLimit;
					styleWrapLimit = styleWrapLimit % tileData.StyleWrapLimit;
				}
				if (!tileData.StyleHorizontal)
				{
					coordinateFullWidth = tileData.CoordinateFullWidth * styleWrapLimit1;
					coordinateFullHeight = tileData.CoordinateFullHeight * styleWrapLimit;
				}
				else
				{
					coordinateFullWidth = tileData.CoordinateFullWidth * styleWrapLimit;
					coordinateFullHeight = tileData.CoordinateFullHeight * styleWrapLimit1;
				}
				int num3 = toBePlaced.xCoord;
				int num4 = toBePlaced.yCoord;
				for (int i = 0; i < tileData.Width; i++)
				{
					for (int j = 0; j < tileData.Height; j++)
					{
						Tile tileSafely = Framing.GetTileSafely(num3 + i, num4 + j);
						if (tileSafely.active() && Main.tileCut[tileSafely.type])
						{
							WorldGen.KillTile(num3 + i, num4 + j, false, false, false);
						}
					}
				}
				for (int k = 0; k < tileData.Width; k++)
				{
					int coordinateWidth = coordinateFullWidth + k * (tileData.CoordinateWidth + tileData.CoordinatePadding);
					int coordinateHeights = coordinateFullHeight;
					for (int l = 0; l < tileData.Height; l++)
					{
						Tile tile = Framing.GetTileSafely(num3 + k, num4 + l);
						if (!tile.active())
						{
							tile.active(true);
							tile.frameX = (short)coordinateWidth;
							tile.frameY = (short)coordinateHeights;
							tile.type = num2;
						}
						coordinateHeights = coordinateHeights + tileData.CoordinateHeights[l] + tileData.CoordinatePadding;
					}
				}
			}
			else
			{
				if (!tileData.HookPlaceOverride.processedCoordinates)
				{
					num = toBePlaced.xCoord + tileData.Origin.X;
					num1 = toBePlaced.yCoord + tileData.Origin.Y;
				}
				else
				{
					num = toBePlaced.xCoord;
					num1 = toBePlaced.yCoord;
				}
				if (tileData.HookPlaceOverride.hook(num, num1, toBePlaced.type, toBePlaced.style, 1) == tileData.HookPlaceOverride.badReturn)
				{
					return false;
				}
			}
			if (tileData.FlattenAnchors)
			{
				AnchorData anchorBottom = tileData.AnchorBottom;
				if (anchorBottom.tileCount != 0 && (anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile)
				{
					int num5 = toBePlaced.xCoord + anchorBottom.checkStart;
					int num6 = toBePlaced.yCoord + tileData.Height;
					for (int m = 0; m < anchorBottom.tileCount; m++)
					{
						Tile tileSafely1 = Framing.GetTileSafely(num5 + m, num6);
						if (Main.tileSolid[tileSafely1.type] && !Main.tileSolidTop[tileSafely1.type] && tileSafely1.blockType() != 0)
						{
							WorldGen.SlopeTile(num5 + m, num6, 0);
						}
					}
				}
				anchorBottom = tileData.AnchorTop;
				if (anchorBottom.tileCount != 0 && (anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile)
				{
					int num7 = toBePlaced.xCoord + anchorBottom.checkStart;
					int num8 = toBePlaced.yCoord - 1;
					for (int n = 0; n < anchorBottom.tileCount; n++)
					{
						Tile tile1 = Framing.GetTileSafely(num7 + n, num8);
						if (Main.tileSolid[tile1.type] && !Main.tileSolidTop[tile1.type] && tile1.blockType() != 0)
						{
							WorldGen.SlopeTile(num7 + n, num8, 0);
						}
					}
				}
				anchorBottom = tileData.AnchorRight;
				if (anchorBottom.tileCount != 0 && (anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile)
				{
					int num9 = toBePlaced.xCoord + tileData.Width;
					int num10 = toBePlaced.yCoord + anchorBottom.checkStart;
					for (int o = 0; o < anchorBottom.tileCount; o++)
					{
						Tile tileSafely2 = Framing.GetTileSafely(num9, num10 + o);
						if (Main.tileSolid[tileSafely2.type] && !Main.tileSolidTop[tileSafely2.type] && tileSafely2.blockType() != 0)
						{
							WorldGen.SlopeTile(num9, num10 + o, 0);
						}
					}
				}
				anchorBottom = tileData.AnchorLeft;
				if (anchorBottom.tileCount != 0 && (anchorBottom.type & AnchorType.SolidTile) == AnchorType.SolidTile)
				{
					int num11 = toBePlaced.xCoord - 1;
					int num12 = toBePlaced.yCoord + anchorBottom.checkStart;
					for (int p = 0; p < anchorBottom.tileCount; p++)
					{
						Tile tile2 = Framing.GetTileSafely(num11, num12 + p);
						if (Main.tileSolid[tile2.type] && !Main.tileSolidTop[tile2.type] && tile2.blockType() != 0)
						{
							WorldGen.SlopeTile(num11, num12 + p, 0);
						}
					}
				}
			}
			return true;
		}
Esempio n. 13
0
        // Token: 0x060001A6 RID: 422 RVA: 0x0002ECC8 File Offset: 0x0002CEC8
        public static bool CanPlace(int x, int y, int type, int style, int dir, out TileObject objectData, bool onlyCheck = false)
        {
            TileObjectData tileData = TileObjectData.GetTileData(type, style, 0);

            objectData = TileObject.Empty;
            if (tileData == null)
            {
                return(false);
            }
            int num  = x - (int)tileData.Origin.X;
            int num2 = y - (int)tileData.Origin.Y;

            if (num < 0 || num + tileData.Width >= Main.maxTilesX || num2 < 0 || num2 + tileData.Height >= Main.maxTilesY)
            {
                return(false);
            }
            bool flag = tileData.RandomStyleRange > 0;

            if (TileObjectPreviewData.placementCache == null)
            {
                TileObjectPreviewData.placementCache = new TileObjectPreviewData();
            }
            TileObjectPreviewData.placementCache.Reset();
            int arg_AF_0 = 0;
            int num3     = 0;

            if (tileData.AlternatesCount != 0)
            {
                num3 = tileData.AlternatesCount;
            }
            float          num4           = -1f;
            float          num5           = -1f;
            int            num6           = 0;
            TileObjectData tileObjectData = null;
            int            i = arg_AF_0 - 1;

            while (i < num3)
            {
                i++;
                TileObjectData tileData2 = TileObjectData.GetTileData(type, style, i);
                if (tileData2.Direction == TileObjectDirection.None || ((tileData2.Direction != TileObjectDirection.PlaceLeft || dir != 1) && (tileData2.Direction != TileObjectDirection.PlaceRight || dir != -1)))
                {
                    int num7 = x - (int)tileData2.Origin.X;
                    int num8 = y - (int)tileData2.Origin.Y;
                    if (num7 < 5 || num7 + tileData2.Width > Main.maxTilesX - 5 || num8 < 5 || num8 + tileData2.Height > Main.maxTilesY - 5)
                    {
                        return(false);
                    }
                    Rectangle rectangle = new Rectangle(0, 0, tileData2.Width, tileData2.Height);
                    int       num9      = 0;
                    int       num10     = 0;
                    if (tileData2.AnchorTop.tileCount != 0)
                    {
                        if (rectangle.Y == 0)
                        {
                            rectangle.Y = -1;
                            rectangle.Height++;
                            num10++;
                        }
                        int checkStart = tileData2.AnchorTop.checkStart;
                        if (checkStart < rectangle.X)
                        {
                            rectangle.Width += rectangle.X - checkStart;
                            num9            += rectangle.X - checkStart;
                            rectangle.X      = checkStart;
                        }
                        int num11 = checkStart + tileData2.AnchorTop.tileCount - 1;
                        int num12 = rectangle.X + rectangle.Width - 1;
                        if (num11 > num12)
                        {
                            rectangle.Width += num11 - num12;
                        }
                    }
                    if (tileData2.AnchorBottom.tileCount != 0)
                    {
                        if (rectangle.Y + rectangle.Height == tileData2.Height)
                        {
                            rectangle.Height++;
                        }
                        int checkStart2 = tileData2.AnchorBottom.checkStart;
                        if (checkStart2 < rectangle.X)
                        {
                            rectangle.Width += rectangle.X - checkStart2;
                            num9            += rectangle.X - checkStart2;
                            rectangle.X      = checkStart2;
                        }
                        int num13 = checkStart2 + tileData2.AnchorBottom.tileCount - 1;
                        int num14 = rectangle.X + rectangle.Width - 1;
                        if (num13 > num14)
                        {
                            rectangle.Width += num13 - num14;
                        }
                    }
                    if (tileData2.AnchorLeft.tileCount != 0)
                    {
                        if (rectangle.X == 0)
                        {
                            rectangle.X = -1;
                            rectangle.Width++;
                            num9++;
                        }
                        int num15 = tileData2.AnchorLeft.checkStart;
                        if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            num15--;
                        }
                        if (num15 < rectangle.Y)
                        {
                            rectangle.Width += rectangle.Y - num15;
                            num10           += rectangle.Y - num15;
                            rectangle.Y      = num15;
                        }
                        int num16 = num15 + tileData2.AnchorLeft.tileCount - 1;
                        if ((tileData2.AnchorLeft.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            num16 += 2;
                        }
                        int num17 = rectangle.Y + rectangle.Height - 1;
                        if (num16 > num17)
                        {
                            rectangle.Height += num16 - num17;
                        }
                    }
                    if (tileData2.AnchorRight.tileCount != 0)
                    {
                        if (rectangle.X + rectangle.Width == tileData2.Width)
                        {
                            rectangle.Width++;
                        }
                        int num18 = tileData2.AnchorLeft.checkStart;
                        if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            num18--;
                        }
                        if (num18 < rectangle.Y)
                        {
                            rectangle.Width += rectangle.Y - num18;
                            num10           += rectangle.Y - num18;
                            rectangle.Y      = num18;
                        }
                        int num19 = num18 + tileData2.AnchorRight.tileCount - 1;
                        if ((tileData2.AnchorRight.type & AnchorType.Tree) == AnchorType.Tree)
                        {
                            num19 += 2;
                        }
                        int num20 = rectangle.Y + rectangle.Height - 1;
                        if (num19 > num20)
                        {
                            rectangle.Height += num19 - num20;
                        }
                    }
                    if (onlyCheck)
                    {
                        TileObject.objectPreview.Reset();
                        TileObject.objectPreview.Active      = true;
                        TileObject.objectPreview.Type        = (ushort)type;
                        TileObject.objectPreview.Style       = (short)style;
                        TileObject.objectPreview.Alternate   = i;
                        TileObject.objectPreview.Size        = new Point16(rectangle.Width, rectangle.Height);
                        TileObject.objectPreview.ObjectStart = new Point16(num9, num10);
                        TileObject.objectPreview.Coordinates = new Point16(num7 - num9, num8 - num10);
                    }
                    float num21 = 0f;
                    float num22 = (float)(tileData2.Width * tileData2.Height);
                    float num23 = 0f;
                    float num24 = 0f;
                    for (int j = 0; j < tileData2.Width; j++)
                    {
                        for (int k = 0; k < tileData2.Height; k++)
                        {
                            Tile tileSafely = Framing.GetTileSafely(num7 + j, num8 + k);
                            bool flag2      = !tileData2.LiquidPlace(tileSafely);
                            bool flag3      = false;
                            if (tileData2.AnchorWall)
                            {
                                num24 += 1f;
                                if (!tileData2.isValidWallAnchor((int)tileSafely.wall))
                                {
                                    flag3 = true;
                                }
                                else
                                {
                                    num23 += 1f;
                                }
                            }
                            bool flag4 = false;
                            if (tileSafely.active() && !Main.tileCut[(int)tileSafely.type])
                            {
                                flag4 = true;
                            }
                            if (flag4 | flag2 | flag3)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[j + num9, k + num10] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[j + num9, k + num10] = 1;
                                }
                                num21 += 1f;
                            }
                        }
                    }
                    AnchorData anchorData = tileData2.AnchorBottom;
                    if (anchorData.tileCount != 0)
                    {
                        num24 += (float)anchorData.tileCount;
                        int height = tileData2.Height;
                        for (int l = 0; l < anchorData.tileCount; l++)
                        {
                            int  num25      = anchorData.checkStart + l;
                            Tile tileSafely = Framing.GetTileSafely(num7 + num25, num8 + height);
                            bool flag5      = false;
                            if (tileSafely.nactive())
                            {
                                if ((anchorData.type & AnchorType.SolidTile) == AnchorType.SolidTile && Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && !Main.tileNoAttach[(int)tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                                {
                                    flag5 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag5 && ((anchorData.type & AnchorType.SolidWithTop) == AnchorType.SolidWithTop || (anchorData.type & AnchorType.Table) == AnchorType.Table))
                                {
                                    if (TileID.Sets.Platforms[(int)tileSafely.type])
                                    {
                                        int num26 = (int)tileSafely.frameX / TileObjectData.PlatformFrameWidth();
                                        if ((!tileSafely.halfBrick() && num26 >= 0 && num26 <= 7) || (num26 >= 12 && num26 <= 16) || (num26 >= 25 && num26 <= 26))
                                        {
                                            flag5 = true;
                                        }
                                    }
                                    else if (Main.tileSolid[(int)tileSafely.type] && Main.tileSolidTop[(int)tileSafely.type])
                                    {
                                        flag5 = true;
                                    }
                                }
                                if (!flag5 && (anchorData.type & AnchorType.Table) == AnchorType.Table && !TileID.Sets.Platforms[(int)tileSafely.type] && Main.tileTable[(int)tileSafely.type] && tileSafely.blockType() == 0)
                                {
                                    flag5 = true;
                                }
                                if (!flag5 && (anchorData.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type])
                                {
                                    int num27 = tileSafely.blockType();
                                    if (num27 - 4 <= 1)
                                    {
                                        flag5 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                    }
                                }
                                if (!flag5 && (anchorData.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely.type))
                                {
                                    flag5 = true;
                                }
                            }
                            else if (!flag5 && (anchorData.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag5 = true;
                            }
                            if (!flag5)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num25 + num9, height + num10] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num25 + num9, height + num10] = 1;
                                }
                                num23 += 1f;
                            }
                        }
                    }
                    anchorData = tileData2.AnchorTop;
                    if (anchorData.tileCount != 0)
                    {
                        num24 += (float)anchorData.tileCount;
                        int num28 = -1;
                        for (int m = 0; m < anchorData.tileCount; m++)
                        {
                            int  num29      = anchorData.checkStart + m;
                            Tile tileSafely = Framing.GetTileSafely(num7 + num29, num8 + num28);
                            bool flag6      = false;
                            if (tileSafely.nactive())
                            {
                                if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && !Main.tileNoAttach[(int)tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                                {
                                    flag6 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag6 && (anchorData.type & AnchorType.SolidBottom) == AnchorType.SolidBottom && ((Main.tileSolid[(int)tileSafely.type] && (!Main.tileSolidTop[(int)tileSafely.type] || (TileID.Sets.Platforms[(int)tileSafely.type] && (tileSafely.halfBrick() || tileSafely.topSlope())))) || tileSafely.halfBrick() || tileSafely.topSlope()) && !TileID.Sets.NotReallySolid[(int)tileSafely.type] && !tileSafely.bottomSlope())
                                {
                                    flag6 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag6 && (anchorData.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type])
                                {
                                    int num27 = tileSafely.blockType();
                                    if (num27 - 2 <= 1)
                                    {
                                        flag6 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                    }
                                }
                                if (!flag6 && (anchorData.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely.type))
                                {
                                    flag6 = true;
                                }
                            }
                            else if (!flag6 && (anchorData.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag6 = true;
                            }
                            if (!flag6)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num29 + num9, num28 + num10] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num29 + num9, num28 + num10] = 1;
                                }
                                num23 += 1f;
                            }
                        }
                    }
                    anchorData = tileData2.AnchorRight;
                    if (anchorData.tileCount != 0)
                    {
                        num24 += (float)anchorData.tileCount;
                        int width = tileData2.Width;
                        for (int n = 0; n < anchorData.tileCount; n++)
                        {
                            int  num30      = anchorData.checkStart + n;
                            Tile tileSafely = Framing.GetTileSafely(num7 + width, num8 + num30);
                            bool flag7      = false;
                            if (tileSafely.nactive())
                            {
                                if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && !Main.tileNoAttach[(int)tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                                {
                                    flag7 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag7 && (anchorData.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type])
                                {
                                    int num27 = tileSafely.blockType();
                                    if (num27 == 2 || num27 == 4)
                                    {
                                        flag7 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                    }
                                }
                                if (!flag7 && (anchorData.type & AnchorType.Tree) == AnchorType.Tree && tileSafely.type == 5)
                                {
                                    flag7 = true;
                                    if (n == 0)
                                    {
                                        num24 += 1f;
                                        Tile tileSafely2 = Framing.GetTileSafely(num7 + width, num8 + num30 - 1);
                                        if (tileSafely2.nactive() && tileSafely2.type == 5)
                                        {
                                            num23 += 1f;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[width + num9, num30 + num10 - 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[width + num9, num30 + num10 - 1] = 2;
                                        }
                                    }
                                    if (n == anchorData.tileCount - 1)
                                    {
                                        num24 += 1f;
                                        Tile tileSafely3 = Framing.GetTileSafely(num7 + width, num8 + num30 + 1);
                                        if (tileSafely3.nactive() && tileSafely3.type == 5)
                                        {
                                            num23 += 1f;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[width + num9, num30 + num10 + 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[width + num9, num30 + num10 + 1] = 2;
                                        }
                                    }
                                }
                                if (!flag7 && (anchorData.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely.type))
                                {
                                    flag7 = true;
                                }
                            }
                            else if (!flag7 && (anchorData.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag7 = true;
                            }
                            if (!flag7)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[width + num9, num30 + num10] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[width + num9, num30 + num10] = 1;
                                }
                                num23 += 1f;
                            }
                        }
                    }
                    anchorData = tileData2.AnchorLeft;
                    if (anchorData.tileCount != 0)
                    {
                        num24 += (float)anchorData.tileCount;
                        int num31 = -1;
                        for (int num32 = 0; num32 < anchorData.tileCount; num32++)
                        {
                            int  num33      = anchorData.checkStart + num32;
                            Tile tileSafely = Framing.GetTileSafely(num7 + num31, num8 + num33);
                            bool flag8      = false;
                            if (tileSafely.nactive())
                            {
                                if (Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type] && !Main.tileNoAttach[(int)tileSafely.type] && (tileData2.FlattenAnchors || tileSafely.blockType() == 0))
                                {
                                    flag8 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                }
                                if (!flag8 && (anchorData.type & AnchorType.SolidSide) == AnchorType.SolidSide && Main.tileSolid[(int)tileSafely.type] && !Main.tileSolidTop[(int)tileSafely.type])
                                {
                                    int num27 = tileSafely.blockType();
                                    if (num27 == 3 || num27 == 5)
                                    {
                                        flag8 = tileData2.isValidTileAnchor((int)tileSafely.type);
                                    }
                                }
                                if (!flag8 && (anchorData.type & AnchorType.Tree) == AnchorType.Tree && tileSafely.type == 5)
                                {
                                    flag8 = true;
                                    if (num32 == 0)
                                    {
                                        num24 += 1f;
                                        Tile tileSafely4 = Framing.GetTileSafely(num7 + num31, num8 + num33 - 1);
                                        if (tileSafely4.nactive() && tileSafely4.type == 5)
                                        {
                                            num23 += 1f;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[num31 + num9, num33 + num10 - 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[num31 + num9, num33 + num10 - 1] = 2;
                                        }
                                    }
                                    if (num32 == anchorData.tileCount - 1)
                                    {
                                        num24 += 1f;
                                        Tile tileSafely5 = Framing.GetTileSafely(num7 + num31, num8 + num33 + 1);
                                        if (tileSafely5.nactive() && tileSafely5.type == 5)
                                        {
                                            num23 += 1f;
                                            if (onlyCheck)
                                            {
                                                TileObject.objectPreview[num31 + num9, num33 + num10 + 1] = 1;
                                            }
                                        }
                                        else if (onlyCheck)
                                        {
                                            TileObject.objectPreview[num31 + num9, num33 + num10 + 1] = 2;
                                        }
                                    }
                                }
                                if (!flag8 && (anchorData.type & AnchorType.AlternateTile) == AnchorType.AlternateTile && tileData2.isValidAlternateAnchor((int)tileSafely.type))
                                {
                                    flag8 = true;
                                }
                            }
                            else if (!flag8 && (anchorData.type & AnchorType.EmptyTile) == AnchorType.EmptyTile)
                            {
                                flag8 = true;
                            }
                            if (!flag8)
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num31 + num9, num33 + num10] = 2;
                                }
                            }
                            else
                            {
                                if (onlyCheck)
                                {
                                    TileObject.objectPreview[num31 + num9, num33 + num10] = 1;
                                }
                                num23 += 1f;
                            }
                        }
                    }
                    if (tileData2.HookCheck.hook != null)
                    {
                        if (tileData2.HookCheck.processedCoordinates)
                        {
                            Point16 arg_103B_0 = tileData2.Origin;
                            Point16 arg_1043_0 = tileData2.Origin;
                        }
                        if (tileData2.HookCheck.hook(x, y, type, style, dir) == tileData2.HookCheck.badReturn && tileData2.HookCheck.badResponse == 0)
                        {
                            num23 = 0f;
                            num21 = 0f;
                            TileObject.objectPreview.AllInvalid();
                        }
                    }
                    float num34 = num23 / num24;
                    float num35 = num21 / num22;
                    if (num35 == 1f && num24 == 0f)
                    {
                        num34 = 1f;
                        num35 = 1f;
                    }
                    if (num34 == 1f && num35 == 1f)
                    {
                        num4           = 1f;
                        num5           = 1f;
                        num6           = i;
                        tileObjectData = tileData2;
                        break;
                    }
                    if (num34 > num4 || (num34 == num4 && num35 > num5))
                    {
                        TileObjectPreviewData.placementCache.CopyFrom(TileObject.objectPreview);
                        num4           = num34;
                        num5           = num35;
                        tileObjectData = tileData2;
                        num6           = i;
                    }
                }
            }
            int num36 = -1;

            if (flag)
            {
                if (TileObjectPreviewData.randomCache == null)
                {
                    TileObjectPreviewData.randomCache = new TileObjectPreviewData();
                }
                bool flag9 = false;
                if ((int)TileObjectPreviewData.randomCache.Type == type)
                {
                    Point16 arg_116E_0  = TileObjectPreviewData.randomCache.Coordinates;
                    Point16 objectStart = TileObjectPreviewData.randomCache.ObjectStart;
                    int     num37       = (int)(arg_116E_0.X + objectStart.X);
                    int     num38       = (int)(arg_116E_0.Y + objectStart.Y);
                    int     num39       = x - (int)tileData.Origin.X;
                    int     num40       = y - (int)tileData.Origin.Y;
                    if (num37 != num39 || num38 != num40)
                    {
                        flag9 = true;
                    }
                }
                else
                {
                    flag9 = true;
                }
                if (flag9)
                {
                    num36 = Main.rand.Next(tileData.RandomStyleRange);
                }
                else
                {
                    num36 = TileObjectPreviewData.randomCache.Random;
                }
            }
            if (onlyCheck)
            {
                if (num4 != 1f || num5 != 1f)
                {
                    TileObject.objectPreview.CopyFrom(TileObjectPreviewData.placementCache);
                    i = num6;
                }
                TileObject.objectPreview.Random = num36;
                if (tileData.RandomStyleRange > 0)
                {
                    TileObjectPreviewData.randomCache.CopyFrom(TileObject.objectPreview);
                }
            }
            if (!onlyCheck)
            {
                objectData.xCoord    = x - (int)tileObjectData.Origin.X;
                objectData.yCoord    = y - (int)tileObjectData.Origin.Y;
                objectData.type      = type;
                objectData.style     = style;
                objectData.alternate = i;
                objectData.random    = num36;
            }
            return(num4 == 1f && num5 == 1f);
        }