public static void ChangeToDoor(Wall a, Wall b)
 {
     //right and left mode to modify
     if (a.X == b.X)
     {
         if (a.Y < b.Y)
         {
             a.sides.Right = MultiWallScript.Mode.Half;
             b.sides.Left = MultiWallScript.Mode.Half;
         }
         else
         {
             a.sides.Left = MultiWallScript.Mode.Half;
             b.sides.Right = MultiWallScript.Mode.Half;
         }
     }
     //top and bottom mode to modify
     else if (a.Y == b.Y)
     {
         if (a.X < b.X)
         {
             a.sides.Bottom = MultiWallScript.Mode.Half;
             b.sides.Top = MultiWallScript.Mode.Half;
         }
         else
         {
             a.sides.Top = MultiWallScript.Mode.Half;
             b.sides.Bottom = MultiWallScript.Mode.Half;
         }
     }
     else
         throw new System.ArgumentException("Inproper coordinates of the walls");
 }

 public MazyPrototypeFactory(Maze maze, Wall wall, Room room, Door door)
 {
     _maze = maze;
     _wall = wall;
     _room = room;
     _door = door;
 }

 public Labirynth(uint x, uint y, GenerationAlghorithm _algorithm)
 {
     chambersCountHorizontal = x;
     chambersCountVertical = y;
     walls = new Wall[chambersCountHorizontal, chambersCountVertical];
     algorithm = _algorithm;
 }

 public MazePrototypeFactory(Maze maze, Room room, Door door, Wall wall)
 {
     this.prototypeMaze = maze;
     this.prototypeRoom = room;
     this.prototypeDoor = door;
     this.prototypeWall = wall;
 }

 public void AttackInitialWallTwice()
 {
     Wall wall = new Wall();
     wall.NewDay();
     Assert.IsTrue(wall.Attack(10, 12, 6));
     Assert.IsTrue(wall.Attack(10, 12, 6));
 }

        /// <summary>
        /// Obtains the outward direction of the exterior wall.
        /// </summary>
        /// <param name="wall">The wall.</param>
        /// <returns>A normalized XYZ direction vector.</returns>
        protected XYZ GetExteriorWallDirection(Wall wall)
        {
            LocationCurve locationCurve = wall.Location as LocationCurve;
            XYZ exteriorDirection = XYZ.BasisZ;

            if (locationCurve != null)
            {
                Curve curve = locationCurve.Curve;

                //Write("Wall line endpoints: ", curve);

                XYZ direction = XYZ.BasisX;
                if (curve is Line)
                {
                    // Obtains the tangent vector of the wall.
                    direction = curve.ComputeDerivatives(0, true).BasisX.Normalize();
                }
                else
                {
                    // An assumption, for non-linear walls, that the "tangent vector" is the direction
                    // from the start of the wall to the end.
                    direction = (curve.get_EndPoint(1) - curve.get_EndPoint(0)).Normalize();
                }
                // Calculate the normal vector via cross product.
                exteriorDirection = XYZ.BasisZ.CrossProduct(direction);

                // Flipped walls need to reverse the calculated direction
                if (wall.Flipped) exteriorDirection = -exteriorDirection;
            }

            return exteriorDirection;
        }

    public static void Main(string[] args)
    {
        System.Console.WriteLine("Starting Tester.");

        System.Console.WriteLine("Writing Hello on wall.");
        Wall wall = new Wall();
        wall.writeBSTROnWall("Hello");
        System.Console.WriteLine("Writing Brrrrr! on wall.");
        wall.writeBSTROnWall("Brrrrr!");
        System.Console.WriteLine("Reading wall:");
        string wallContents = "overwrite me";
        wallContents = wall.readWallBSTR();
        System.Console.WriteLine("Wall says: " + wallContents);
        System.Console.WriteLine("Again, Wall says: '" + wall.readWallBSTR() + "'.");

        System.Console.WriteLine("\n\nDoing Bag-Ball test");
        //TODO What if I create it something like: IBag bag = (IBall) Factory.BagClass();  Eberhard might have said I was supposed to be doing this sort of thing that way.
        Bag bag = new Bag();
        Ball ball = (Ball) bag.ProvideBall(); // TODO what if I cast it as an IBall rather than Ball

        long distance_rolled;
        distance_rolled = ball.roll(2);
        System.Console.WriteLine("Rolling ball by 2. Accumulated distance: {0} (should say 2)", distance_rolled);
        if (distance_rolled != 2) {
            System.Console.WriteLine("Tester.exe: Error, distance wasn't correct. Exiting.");
            Environment.Exit(-1);
        }
        bag.InspectBall(ball);
        distance_rolled = ball.roll(9);
        System.Console.WriteLine("Rolling ball by 9. Accumulated distance: {0} (should say 14)", distance_rolled);
        if (distance_rolled != 14) {
            System.Console.WriteLine("Tester.exe: Error, distance wasn't correct. Exiting.");
            Environment.Exit(-1);
        }
    }

    void Awake()
    {
        justTraveled = 0;
        gameObject.isStatic = true;
        gameObject.transform.localPosition = Vector3.zero;

        GetComponent<BoxCollider>().isTrigger = true;

        wall = transform.parent.GetComponent<Wall>();
        floor = transform.parent.transform.parent.gameObject;
        CBS = Camera.main.GetComponent<PlayerMovement>().CBS;
        playerInteraction = Camera.main.GetComponent<PlayerMovement>();
        
        if (tag == "down" || tag == "back")
        {
            wallSize = wall.xSize;
        }
        else
        {
            wallSize = wall.zSize;
        }

        xSize = 1;
        ySize = 3;
        gridX = wall.xSize;

        Generate();
    }

 public WallCatalogResource(int APIversion,
     uint version,
     uint unknown2,
     Common common,
     Wall wallType,
     Partition partitionType,
     PartitionFlagsType partitionFlags,
     VerticalSpan verticalSpanType,
     PartitionsBlockedFlagsType partitionsBlockedFlags,
     PartitionsBlockedFlagsType adjacentPartitionsBlockedFlags,
     PartitionTool partitionToolMode,
     ToolUsageFlagsType toolUsageFlags,
     uint defaultPatternIndex,
     WallThickness wallThicknessType,
     TGIBlockList ltgib)
     : base(APIversion, version, common, ltgib)
 {
     this.unknown2 = unknown2;
     this.wallType = wallType;
     this.partitionType = partitionType;
     this.partitionFlags = partitionFlags;
     this.verticalSpanType = verticalSpanType;
     this.partitionsBlockedFlags = partitionsBlockedFlags;
     this.adjacentPartitionsBlockedFlags = adjacentPartitionsBlockedFlags;
     this.partitionToolMode = partitionToolMode;
     this.toolUsageFlags = toolUsageFlags;
     this.defaultPatternIndex = defaultPatternIndex;
     this.wallThicknessType = wallThicknessType;
 }

        public void read_from_file(string name, int count_walls)
        {
            StreamReader myStream = null;
            try
            {
                myStream = new StreamReader(name);
                using (myStream)
                {
                    Walls = null;
                    Walls = new List<Wall>();

                    Wall arg;
                    int i = 0;
                    while (i < count_walls)
                    {
                        myStream.BaseStream.ReadByte();
                        arg = new Wall(new Point(myStream.BaseStream.ReadByte(), myStream.BaseStream.ReadByte()), new Point(myStream.BaseStream.ReadByte(), myStream.BaseStream.ReadByte()));
                        if ((arg.Dot_1.X != 0 && arg.Dot_1.Y != 0) || (arg.Dot_2.X != 0 && arg.Dot_2.Y != 0))
                        {
                            Walls.Add(arg);
                            ++i;
                        }
                    }
                }
                myStream.Close();
            }
            catch (Exception)
            {
            }
        }

    public void FadeOut(Wall notifier = null)
    {
        targetAlpha = fadeAlpha;
        waitFrames = 1;

        if (notifier)
            shouldFadeCompletely = canFadeCompletely && notifier.transform.position.z == transform.position.z;
        else if (canFadeCompletely)
            shouldFadeCompletely = true;

        if (shouldFadeCompletely)
        {
            foreach (Wall neighbour in neighbours)
            {
                if (notifier != neighbour)
                    neighbour.FadeOut(this);
            }
        }
        else if (notifier && (!lastNotifier || notifier.transform.position.x == transform.position.x))
        {
            m.SetVector("_FadePoint", notifier.transform.position + (transform.position - notifier.transform.position) / 2);
            Vector3 axis = (notifier.transform.position - transform.position);
            axis.x = Mathf.Abs(axis.x);
            axis.y = Mathf.Abs(axis.y);
            axis.z = Mathf.Abs(axis.z);
            m.SetVector("_FadeAxis", axis);
            lastNotifier = notifier;
        }
    }

 public void AttackInitialWallTwoDaysDifferentPlaces()
 {
     Wall wall = new Wall();
     wall.NewDay();
     Assert.IsTrue(wall.Attack(10, 12, 6));
     wall.NewDay();
     Assert.IsTrue(wall.Attack(11, 13, 6));
 }

 /// <summary>
 /// constructor
 /// </summary>
 /// <param name="wall">wall to create reinforcement on</param>
 /// <param name="commandData">object which contains reference to Revit Application</param>
 public ProfileWall(Wall wall, ExternalCommandData commandData)
     : base(commandData)
 {
     m_data = wall;
     List<List<Edge>> faces = GetFaces(m_data);
     m_points = GetNeedPoints(faces);
     m_to2DMatrix = GetTo2DMatrix();
 }

 public bool IsNextTo(Wall otherWall)
 {
     int diffX = this.X - otherWall.X;
     int diffY = this.Y - otherWall.Y;
     if (diffX == 0 || diffY == 0)
         return (System.Math.Abs(diffX + diffY) == 1);
     return false;
 }

 //丟入牆壁起末點
 public void Add_New_Wall(PointF p1, PointF p2)
 {
     Wall new_wall = new Wall();
     new_wall.start.X = p1.X;
     new_wall.start.Y = p1.Y;
     new_wall.end.X = p2.X;
     new_wall.end.Y = p2.Y;
     Mywall.Add(new_wall);
 }

 public static bool IsThereAWallAt(int x, int y, Wall[] walls = null)
 {
     if (walls == null)
     {
         // this is dangerous...
         walls = GameObject.FindObjectsOfType<Wall>();
     }
     var match = walls.FirstOrDefault(w => Mathf.RoundToInt(w.transform.position.x) == x && Mathf.RoundToInt(w.transform.position.y) == y);
     return match != null;
 }

        public void AttackInitialThousandDays()
        {
            Wall wall = new Wall();

            for (int k = 0; k < 1000; k++)
            {
                wall.NewDay();
                Assert.IsTrue(wall.Attack(k, k + 100, 6));
            }
        }

 protected override void Initialize()
 {
     Map = new Map();
     Camera = new Camera2D(Vector2.Zero, Map.Width - 800, Map.Height - 600);
     Car = new Car(new Vector2(XNAGame.I.Width / 2 + 50, XNAGame.I.Height / 2 + 50));
     Wall = new Wall(new Vector2(XNAGame.I.Width / 2 + 50, XNAGame.I.Height / 2 + 500), 100, 16);
     info = new Text("", "Speed: 0 - Angle: 0", new Vector2(0, 20));
     Music = new Music("track");
     Music.Play(true);
 }

        /**
         * This method returns a copy of the blueprint.
         * This is a Deep Copy, meaning that all the Rooms, Corners in those rooms and Walls connected to those corners will be copied.
         * The purpose of this is to make a new copy to work in when editing a blueprint, while preserving the original.
         */
        public Blueprint Clone()
        {
            Blueprint newBp = new Blueprint(this.Name);

            List<Wall> newWalls = new List<Wall>();
            List<Corner> newCorners = new List<Corner>();

            foreach(Room room in this.Rooms) {
                Room newRoom = new Room(room.Name, room.GetID(), room.GetFloorID(), room.FunctionID);
                newBp.Rooms.Add(newRoom);

                foreach(Corner corner in room.GetCorners()) {
                    Corner newCorner = newCorners.Find( (c) => (c.GetID() == corner.GetID()) );
                    if(newCorner != null) {
                        newRoom.AddCorner(newCorner);
                        continue;
                    }

                    newCorner = new Corner(corner.GetID(), corner.GetPoint());
                    newRoom.AddCorner(newCorner);
                    newCorners.Add(newCorner);

                    foreach(Wall wall in corner.GetWalls()) {
                        Wall newWall = newWalls.Find( (w) => (w.GetID() == wall.GetID()) );
                        if(newWall != null) {
                            if(newWall.Left.GetID() == corner.GetID()) {
                                newWall.Left = newCorner;
                            } else if(newWall.Right.GetID() == corner.GetID()) {
                                newWall.Right = newCorner;
                            }
                            if(newWall.GetType() == typeof(Door)) {
                                ((Door)newWall).Hinge = (((Door)newWall).Hinge.Equals(newWall.Left) ? newWall.Left : newWall.Right);
                            }
                            newCorner.AddWall(newWall);
                            continue;
                        }

                        Corner left = (wall.Left.Equals(newCorner) ? newCorner : wall.Left);
                        Corner right = (wall.Right.Equals(newCorner) ? newCorner : wall.Right);

                        if(wall.GetType() == typeof(Door)) {
                            newWall = new Door(wall.GetID(), left, right, (((Door)wall).Hinge.GetID() == left.GetID() ? left : right), ((Door)wall).Direction);
                        } else {
                            newWall = new Wall(wall.GetID(), left, right);
                        }

                        newWalls.Add(newWall);
                        newCorner.AddWall(newWall);
                    }
                }
                newRoom.IsChanged = room.IsChanged;
            }

            return newBp;
        }

    public Map(int size)
    {
        // make map size odd so that we can have a center square
        if(size % 2 != 0)
            size = size + 1;

        Width = size;
        Height = size;

        Wall = new Wall(5);
    }