Gruppe22.Client.Mainmap.GetWallStyle C# (CSharp) Method

GetWallStyle() public method

Determine wall style to use depending on surrounding squares
public GetWallStyle ( int x, int y, bool CheckWall = true, int FloorStyle = -1 ) : WallDir
x int horizontal coordinate of square to check
y int vertical coordinate of square to check
CheckWall bool
FloorStyle int
return WallDir
        public WallDir GetWallStyle(int x = 0, int y = 0, bool CheckWall = true, int FloorStyle = -1)
        {
            if ((CheckWall && (!_map[x, y].hasWall)) || (!CheckWall && _map[x, y].floorStyle != FloorStyle)) return WallDir.None;

            if ((CheckWall && (!_map[x - 1, y].hasWall)) || (!CheckWall && _map[x - 1, y].floorStyle != FloorStyle)) // No wall left
            {

                // No wall blocks way to left

                if ((CheckWall && (!_map[x + 1, y].hasWall)) || (!CheckWall && _map[x + 1, y].floorStyle != FloorStyle)) // No wall right
                {

                    // No wall blocks way to left or right

                    if ((CheckWall && (!_map[x, y - 1].hasWall)) || (!CheckWall && _map[x, y - 1].floorStyle != FloorStyle))  // No wall up
                    {
                        // No wall blocks way up, left or right

                        if ((CheckWall && (!_map[x, y + 1].hasWall)) || (!CheckWall && _map[x, y + 1].floorStyle != FloorStyle)) // No wall down
                        {
                            // No wall blocks way up, down, left or right => this is a freestanding wall surrounded by walkable space OR only connected by diagonals
                            if ((CheckWall && (_map[x + 1, y + 1].hasWall)) || (!CheckWall && _map[x + 1, y + 1].floorStyle == FloorStyle))   // Down Right diagonal
                            {
                                if ((CheckWall && (_map[x + 1, y - 1].hasWall)) || (!CheckWall && _map[x + 1, y - 1].floorStyle == FloorStyle)) // Down Right + Up Right diagonal
                                {
                                    if ((CheckWall && (_map[x - 1, y + 1].hasWall)) || (!CheckWall && _map[x - 1, y + 1].floorStyle == FloorStyle)) // Down Right + Up Right + Down Left diagonal
                                    {
                                        if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle)) // Down Right +Up Right + Down Left + Up Left diagonal
                                        {
                                            return WallDir.FourDiag;
                                        }
                                        else // (not down left) Down Right +Up Right + Down Left
                                        {
                                            return WallDir.LeftRightDownDiag;
                                        }
                                    }
                                    else // (not down left)
                                    {
                                        if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle)) // Down Right  + Up right + Up Left diagonal (not up right)
                                        {
                                            return WallDir.LeftRightUpDiag;
                                        }
                                        else // Down Right  + Up right diagonal (not up right, up left)
                                        {
                                            return WallDir.LeftRightDiag;
                                        }
                                    }
                                }
                                else // Not up right
                                {
                                    if ((CheckWall && (_map[x - 1, y + 1].hasWall)) || (!CheckWall && _map[x - 1, y + 1].floorStyle == FloorStyle)) // Down Right  + Down Left diagonal
                                    {
                                        if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))  // Down Right + Down Left + Up Left diagonal
                                        {
                                            return WallDir.UpDownLeftDiag;
                                        }
                                        else // Down Right + Down Left diagonal
                                        {
                                            return WallDir.UpDownDiag;

                                        }
                                    }
                                    else // Not down left
                                    {
                                        if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))  // Down Right + Up Left diagonal
                                        {
                                            return WallDir.UpLeftDiag;
                                        }
                                        else // Not up left: Down right only
                                        {
                                            return WallDir.UpCloseDiag;
                                        }
                                    }
                                }
                            }

                            else // not down right
                            {
                                if ((CheckWall && (_map[x + 1, y - 1].hasWall)) || (!CheckWall && _map[x + 1, y - 1].floorStyle == FloorStyle))  //  Up Right diagonal
                                {
                                    if ((CheckWall && (_map[x - 1, y + 1].hasWall)) || (!CheckWall && _map[x - 1, y + 1].floorStyle == FloorStyle))  // Up Right + Down Left diagonal
                                    {
                                        if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))  // Up Right + Down Left + Up Left diagonal
                                        {
                                            return WallDir.UpDownRightDiag;
                                        }
                                        else // Up Right + Down Left
                                        {
                                            return WallDir.UpRightDiag;
                                        }
                                    }
                                    else
                                    {
                                        if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))  // Up Right + Up Left diagonal
                                        {
                                            return WallDir.DownLeftDiag;
                                        }
                                        else
                                        {
                                            return WallDir.DownCloseDiag;
                                        }
                                    }
                                }
                                else // not up right
                                {

                                    if ((CheckWall && (_map[x - 1, y + 1].hasWall)) || (!CheckWall && _map[x - 1, y + 1].floorStyle == FloorStyle))  //  Down Left diagonal
                                    {
                                        if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))  // Down Left + Up Left diagonal
                                        {
                                            return WallDir.DownRightDiag;
                                        }
                                        else
                                        {
                                            return WallDir.RightCloseDiag;
                                        }
                                    }
                                    else
                                    {
                                        if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))  //  Up Left diagonal
                                        {
                                            return WallDir.LeftCloseDiag;
                                        }
                                        else
                                        {
                                            return WallDir.Free; // Keine Mauer weit und breit?
                                        }
                                    }
                                }
                            }

                        }
                        else // Wall Down (only)
                        {
                            // Wall only on current square and square above

                            // auf Diagonalen testen

                            if ((CheckWall && (_map[x + 1, y - 1].hasWall)) || (!CheckWall && _map[x + 1, y - 1].floorStyle == FloorStyle))
                            {
                                if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))
                                {
                                    return WallDir.DiagUpDownClose2;
                                }
                                else
                                {
                                    return WallDir.DiagUpClose2;
                                }
                            }
                            else
                            {
                                if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))
                                {
                                    return WallDir.DiagDownClose2;
                                }
                                else
                                {
                                    return WallDir.DownClose;
                                }
                            }

                        }
                    }
                    else // Wall up
                    {
                        if ((CheckWall && (!_map[x, y + 1].hasWall)) || (!CheckWall && _map[x, y + 1].floorStyle == FloorStyle))  // No wall down
                        {
                            // Wall ony on current square and square below

                            // auf Diagonalen testen

                            if ((CheckWall && (_map[x + 1, y + 1].hasWall)) || (!CheckWall && _map[x + 1, y + 1].floorStyle == FloorStyle))
                            {
                                if ((CheckWall && (_map[x - 1, y + 1].hasWall)) || (!CheckWall && _map[x - 1, y + 1].floorStyle == FloorStyle))
                                {
                                    return WallDir.DiagUpDownClose;
                                }
                                else
                                {
                                    return WallDir.DiagUpClose;
                                }
                            }
                            else
                            {
                                if ((CheckWall && (_map[x - 1, y + 1].hasWall)) || (!CheckWall && _map[x - 1, y + 1].floorStyle == FloorStyle))
                                {
                                    return WallDir.DiagDownClose;
                                }
                                else
                                {
                                    return WallDir.UpClose;
                                }
                            }

                        }
                        else // Wall up and down
                        {
                            // Wall on current square and squares above and below
                            return WallDir.UpDown;
                        }
                    }
                }
                else // Wall right
                {
                    if ((CheckWall && (!_map[x, y - 1].hasWall)) || (!CheckWall && _map[x, y - 1].floorStyle == FloorStyle)) // No wall up
                    {
                        if ((CheckWall && (!_map[x, y + 1].hasWall)) || (!CheckWall && _map[x, y + 1].floorStyle == FloorStyle))  // No wall down
                        {
                            // Wall on current tile and right only, but not up or down

                            // auf Diagonalen testen

                            if ((CheckWall && (_map[x - 1, y + 1].hasWall)) || (!CheckWall && _map[x - 1, y + 1].floorStyle == FloorStyle))
                            {
                                if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))
                                {
                                    return WallDir.DiagLeftRightClose2;
                                }
                                else
                                {
                                    return WallDir.DiagLeftClose2;
                                }
                            }
                            else
                            {
                                if ((CheckWall && (_map[x - 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))
                                {
                                    return WallDir.DiagRightClose2;
                                }
                                else
                                {
                                    return WallDir.RightClose;
                                }
                            }
                        }
                        else // Wall down
                        {
                            // Wall right and down, but not left and up
                            return WallDir.DownRight;
                        }
                    }
                    else // Wall up
                    {
                        // Wall up and right, but not left
                        if ((CheckWall && (!_map[x, y + 1].hasWall)) || (!CheckWall && _map[x, y + 1].floorStyle == FloorStyle))  // No wall down
                        {
                            // Wall up, right, but not left and down
                            return WallDir.UpRight;
                        }
                        else // Wall down
                        {
                            // Wall up, right and down, but not left
                            return WallDir.UpDownRight;
                        }
                    }
                }
            }
            else
            {
                if ((CheckWall && (!_map[x + 1, y].hasWall)) || (!CheckWall && _map[x + 1, y].floorStyle == FloorStyle))  // No Wall right
                {
                    if ((CheckWall && (!_map[x, y - 1].hasWall)) || (!CheckWall && _map[x, y - 1].floorStyle == FloorStyle))  // No wall up
                    {
                        if ((CheckWall && (!_map[x, y + 1].hasWall)) || (!CheckWall && _map[x, y + 1].floorStyle == FloorStyle))  // No wall down
                        {
                            // Left and Right closed

                            // auf Diagonalen testen

                            if ((CheckWall && (_map[x + 1, y + 1].hasWall)) || (!CheckWall && _map[x + 1, y + 1].floorStyle == FloorStyle))
                            {
                                if ((CheckWall && (_map[x + 1, y - 1].hasWall)) || (!CheckWall && _map[x + 1, y - 1].floorStyle == FloorStyle))
                                {
                                    return WallDir.DiagLeftRightClose;
                                }
                                else
                                {
                                    return WallDir.DiagLeftClose;
                                }
                            }
                            else
                            {
                                if ((CheckWall && (_map[x + 1, y - 1].hasWall)) || (!CheckWall && _map[x - 1, y - 1].floorStyle == FloorStyle))
                                {
                                    return WallDir.DiagRightClose;
                                }
                                else
                                {
                                    return WallDir.LeftClose;
                                }
                            }
                        }
                        else  // Wall down
                        {
                            // Left and bottom closed
                            return WallDir.DownLeft;
                        }
                    }
                    else // Wall up
                    {
                        if ((CheckWall && (!_map[x, y + 1].hasWall)) || (!CheckWall && _map[x, y + 1].floorStyle == FloorStyle))  // No wall down
                        {
                            // Left and Up closed
                            return WallDir.UpLeft;
                        }
                        else // Wall down
                        {
                            // Left, Up and Down closed
                            return WallDir.UpDownLeft;
                        }
                    }
                }
                else // Wall Left and Right
                {
                    if ((CheckWall && (!_map[x, y - 1].hasWall)) || (!CheckWall && _map[x, y - 1].floorStyle == FloorStyle))  // No wall up
                    {
                        if ((CheckWall && (!_map[x, y + 1].hasWall)) || (!CheckWall && _map[x, y + 1].floorStyle == FloorStyle))  // No wall down
                        {
                            // Walls left and right only
                            return WallDir.LeftRight;
                        }
                        else // wall up
                        {
                            // All walls but not up
                            return WallDir.LeftRightDown;

                        }
                    }
                    else
                    {
                        if ((CheckWall && (!_map[x, y + 1].hasWall)) || (!CheckWall && _map[x, y + 1].floorStyle == FloorStyle))  // No wall down
                        {
                            // All walls but not down
                            return WallDir.LeftRightUp;
                        }
                        else // wall down
                        {
                            // Surrounded by walls
                            return WallDir.FourWay;
                        }
                    }
                }
            }
        }