void OnControllerColliderHit(ControllerColliderHit hit)
    {
        Rigidbody body = hit.collider.attachedRigidbody;

        MazeCell cell = hit.gameObject.GetComponentInParent<MazeCell>();
        if (cell == null)
            return;

        if(cell != currentCell)
        {
            if(currentCell != null)
                currentCell.OnPlayerExit();

            cell.OnPlayerEnter();
        }

        currentCell = cell;
        Vector3 transformDirection = new Vector3(Mathf.Round(transform.forward.x), 0f, Mathf.Round(transform.forward.z));
        IntVector2 direction = new IntVector2((int) transformDirection.x, (int) transformDirection.z);

        if(direction.x != 0 && direction.z != 0)
        {
            if (Random.Range(0, 1) == 1)
                direction.x = 0;
            else
                direction.z = 0;
        }

        MazeDirection mazeDirection = MazeDirections.FromIntVector2(direction);
        faceDirection = mazeDirection;
    }

	private void Move(MazeDirection direction){
		//Debug.Log (currentCell.coordinates.x + ", " + currentCell.coordinates.z);
		MazeCellEdge edge = currentCell.GetEdge (direction);
		if (edge is MazePassage) {
			SetLocation (edge.otherCell);
		}
	}

    public override void Initialize (MazeCell primary, MazeCell other, MazeDirection direction)
    {
        float localX = hinge.localScale.x;
        float localY = hinge.localScale.y;
        float localZ = hinge.localScale.z;

        base.Initialize(primary, other, direction);
        if (OtherSideOfDoor != null)
        {
            isMirrored = true;
            hinge.localScale = new Vector3(-localX, localY, localZ);
            Vector3 p = hinge.localPosition;
            p.x *= -1;
            hinge.localPosition = p;
        }

        for (int i = 0; i < transform.childCount; i++)
        {
            Transform child = transform.GetChild(i);
            if (child != hinge)
            {
                child.GetComponent<Renderer>().material = cell.room.settings.wallMaterial;
            }
        }
    }

 // creates a passage between the specified cells
 private void CreatePassage(MazeCell cell, MazeCell otherCell, MazeDirection direction)
 {
     MazePassage passage = Instantiate(passagePrefab) as MazePassage;
     passage.Initialize(cell, otherCell, direction);
     passage = Instantiate(passagePrefab) as MazePassage;
     passage.Initialize(otherCell, cell, direction.GetOpposite());
 }

	public virtual void Initialize (MazeCell cell, MazeDirection direction = MazeDirection.North) {
		this.cell = cell;
		this.direction = direction;
		transform.parent = cell.transform;
		transform.localPosition = Vector3.zero;
		transform.localRotation = direction.ToRotation();
	}

 public override string ToString()
 {
     MazeDirection[] directions = new MazeDirection[5] { MazeDirection.None, MazeDirection.Up, MazeDirection.Right, MazeDirection.Down, MazeDirection.Left };
     StringBuilder sb = new StringBuilder();
     sb.AppendLine(string.Format("X: {0}", this.X));
     sb.AppendLine(string.Format("Y: {0}", this.Y));
     sb.AppendLine(string.Format("CanContinueBuild: {0}", this.CanContinueBuild));
     sb.AppendLine(string.Format("Built: {0}", this.HasPath));
     sb.AppendLine(string.Format("BuildDirections: "));
     foreach (MazeDirection direction in directions)
     {
         if (this.BuildDirections.Contains(direction))
         {
             sb.Append(string.Format(" {0} ", direction));
         }
     }
     sb.AppendLine(string.Format("ExploreDirections: "));
     foreach (MazeDirection direction in directions)
     {
         if (this.ExploreDirections.Contains(direction))
         {
             sb.Append(string.Format(" {0} ", direction));
         }
     }
     return sb.ToString();
 }

 private void Move(MazeDirection direction)
 {
     MazeCellEdge edge = currentCell.GetEdge(direction);
     if (edge is MazePassage) {
         SetLocation(edge.otherCell);
     }
 }

	private void CreateWall(MazeCell cell, MazeCell otherCell, MazeDirection direction){
		MazeWall wall = Instantiate (wallFab) as MazeWall;
		wall.Initialize (cell, otherCell, direction);
		if(otherCell != null){
			wall = Instantiate (wallFab) as MazeWall;
			wall.Initialize (otherCell, cell, direction.GetOpposite ());
		}
	}

	public void Initialize (MazeCell cell, MazeCell otherCell, MazeDirection direction) {
		this.cell = cell;
		this.otherCell = otherCell;
		this.direction = direction;
		cell.SetEdge(direction, this);
		transform.parent = cell.transform;
		transform.localPosition = Vector3.zero;
		transform.localRotation = direction.ToRotation();
	}

 public void CreateWall(MazeCell cell, MazeCell otherCell, MazeDirection direction)
 {
     MazeWall wall = Instantiate(wallprefabs[Random.Range(0, wallprefabs.Length)]) as MazeWall;
     wall.Initialize(cell, otherCell, direction);
     if(otherCell != null)
     {
         wall = Instantiate(wallprefabs[Random.Range(0, wallprefabs.Length)]) as MazeWall;
         wall.Initialize(otherCell, cell, direction.GetOpposite());
     }
 }

 private void CreatePassage(MazeCell cell, MazeCell otherCell, MazeDirection direction)
 {
     MazePassage prefab = Random.value < doorProbability ? doorPrefab : passagePrefab;
     MazePassage passage = Instantiate(prefab) as MazePassage;
     passage.Initialize(cell, otherCell, direction);
     passage = Instantiate(prefab) as MazePassage;
     if (passage is MazeDoor) {
         otherCell.Initialize(CreateRoom(cell.room.settingsIndex));
     }
     else {
         otherCell.Initialize(cell.room);
     }
     passage.Initialize(otherCell, cell, direction.GetOpposite());
 }

    private void CreateAllCellsAndHallwaysBasedOnGraph() {
        if (transform.localScale != new Vector3(1f, 1f, 1f)) {
            transform.localScale = new Vector3(1f, 1f, 1f);
        }

        MazeDirection[] dirs = new MazeDirection[] { MazeDirection.North, MazeDirection.South, MazeDirection.East, MazeDirection.West };

        //a cell will exist at each node
        for (int i = 0; i < MazeGrid.x; i++) {
            for (int j = 0; j < MazeGrid.y; j++) {
                CreateCell(new IntVector2(i, j));
            }
        }

        //decide whether to place walls or doors in each of the 4 directions around a cell
        for (int i = 0; i < MazeGrid.x; i++) {
            for (int j = 0; j < MazeGrid.y; j++) {
                foreach (var dir in dirs) {
                    IntVector2 move = dir.ToIntVector2();
                    IntVector2 newCoord = move + new IntVector2(i, j);
                    if (ValidCoordinate(newCoord)) {
                        GraphNode node1 = MazeGrid.grid[i, j];
                        GraphNode node2 = MazeGrid.grid[newCoord.x, newCoord.z];

                        //check if edge exists if the new coordinate was valid:
                        if (MazeGrid.GetEdge(node1, node2) == null) {
                            CreateWall(cells[i, j], GetCell(newCoord), dir);
                        }
                        else {
                            CreatePassage(cells[i, j], GetCell(newCoord), dir);
                        }
                    }
                    else {
                        CreateWall(cells[i, j], null, dir);
                    }
                }
            }
        }

        //loop through edges and create hallways
        foreach (var e in MazeGrid.edgeList) {
            CreateHallway(e);
        }

        //make the maze bigger or smaller as desired
        transform.localScale = new Vector3(MazeScale, MazeScale, MazeScale);

    }

    private void Move (MazeDirection direction)
    {
        MazeCellEdge edge = currentCell.GetEdge(direction);
        if (edge is MazePassage)
        {
            SetLocation(edge.otherCell);
            audio.Stop();
            audio.PlayOneShot(_Footsteps, 0.5f);
        }
        
        else
        {
            audio.Stop();
			audio.PlayOneShot(_cantMove[Random.Range(0, _cantMove.Length)], 1f);
        }    
        }

    public override void Initialize(MazeCell primary, MazeCell other, MazeDirection direction)
    {
        base.Initialize(primary, other, direction);
        if (OtherSideOfDoor != null) {
            hinge.localScale = new Vector3(-1f, 1f, 1f);
            Vector3 p = hinge.localPosition;
            p.x = -p.x;
            hinge.localPosition = p;
        }

        for (int i = 0; i < transform.childCount; i++) {
            Transform child = transform.GetChild(i);
            if (child != hinge) {
                child.GetComponent<Renderer>().material = cell.room.settings.wallMaterial;
            }
        }
    }

	private void Move1(MazeDirection direction,bool playsound)
    {        
          MazeCell nextcell =  Maze.instance.getLongNextMazeCell(currentCell, direction);
          directionKeyWating = MazeDirection.None;// khong 
          setRotation(direction);
          currentDirection = direction;
          if (nextcell != null)
          {              
              SetLocation(nextcell);
              targetCell = nextcell;
          }
        if(playsound)
        {
            SoundEngine.playLoop(SoundEngine.instance.move);
        }
          
    }

    //initialize a directional signpost pointing in direction dir and in a quadrant of the cell not
    //containing the player located at playerPosition.
    public void AddSignPost(MazeDirection dir, Vector3 playerPosition) {

        if (signpostInstance != null) {
            return;
        }

        signpostInstance = Instantiate(signpostPrefab) as DirectionalSignPost;
        signpostInstance.transform.parent = transform;

        Vector3 relativePos = playerPosition - transform.localPosition;

        signpostInstance.transform.localPosition = new Vector3(
            (relativePos.x <= 0 ? 0.25f : -0.25f), 
            -1.5f,
            (relativePos.z <= 0 ? 0.25f : -0.25f)
        );

        signpostInstance.transform.localRotation *= dir.ToRotation();
    }

 private void moveContinue(MazeDirection _direction)// khi dang di chuyen ma co nut nhan
 {
     if((currentDirection == MazeDirection.North && _direction == MazeDirection.South ) ||
         (currentDirection == MazeDirection.South && _direction == MazeDirection.North ) ||
         (currentDirection == MazeDirection.East && _direction == MazeDirection.West ) ||
         (currentDirection == MazeDirection.West && _direction == MazeDirection.East ) )
     {
         
         MazeCell tempCurrentcell = Maze.instance.findCell(transform.position);
         MazeCell nextcell = currentCell;//.instance.getLongNextMazeCell(currentCell, _direction);
         // directionKeyWating = MazeDirection.None;// khong 
         setRotation(_direction);
         if (nextcell != null)
         {
             currentCell = tempCurrentcell;
             SetLocation(nextcell);
             targetCell = nextcell;               
         }
         // dung la
     }
     
    
 }

        public MazeCell AdvanceBuild(MazeCell mazeCell, MazeDirection mazeDirection)
        {
            MazeCell newHead = null;

            if (mazeCell != null)
            {
                switch (mazeDirection)
                {
                    case MazeDirection.Up:
                        newHead = this.MazeCells[mazeCell.Y - 1][mazeCell.X];
                        break;
                    case MazeDirection.Right:
                        newHead = this.MazeCells[mazeCell.Y][mazeCell.X + 1];
                        break;
                    case MazeDirection.Down:
                        newHead = this.MazeCells[mazeCell.Y + 1][mazeCell.X];
                        break;
                    case MazeDirection.Left:
                        newHead = this.MazeCells[mazeCell.Y][mazeCell.X - 1];
                        break;
                }

                ((List<MazeDirection>)mazeCell.BuildDirections).Remove(mazeDirection);
                ((List<MazeDirection>)mazeCell.ExploreDirections).Add(mazeDirection);

                newHead.PreviousBuildCell = mazeCell;
                newHead.PreviousBuildDirection = this.oppositeDirection(mazeDirection);
                newHead.HasPath = true;
                ((List<MazeDirection>)newHead.BuildDirections).Remove(this.oppositeDirection(mazeDirection));
                ((List<MazeDirection>)newHead.ExploreDirections).Add(this.oppositeDirection(mazeDirection));

                if (newHead.Y > 0)
                {
                    MazeCell upCell = this.MazeCells[newHead.Y - 1][newHead.X];
                    if (upCell.HasPath)
                    {
                        ((List<MazeDirection>)newHead.BuildDirections).Remove(MazeDirection.Up);
                        ((List<MazeDirection>)upCell.BuildDirections).Remove(MazeDirection.Down);
                    }
                }

                if (newHead.X < this.Width - 1)
                {
                    MazeCell rightCell = this.MazeCells[newHead.Y][newHead.X + 1];
                    if (rightCell.HasPath)
                    {
                        ((List<MazeDirection>)newHead.BuildDirections).Remove(MazeDirection.Right);
                        ((List<MazeDirection>)rightCell.BuildDirections).Remove(MazeDirection.Left);
                    }
                }

                if (newHead.Y < this.Height - 1)
                {
                    MazeCell downCell = this.MazeCells[newHead.Y + 1][newHead.X];
                    if (downCell.HasPath)
                    {
                        ((List<MazeDirection>)newHead.BuildDirections).Remove(MazeDirection.Down);
                        ((List<MazeDirection>)downCell.BuildDirections).Remove(MazeDirection.Up);
                    }

                }

                if (newHead.X > 0)
                {
                    MazeCell leftCell = this.MazeCells[newHead.Y][newHead.X - 1];
                    if (leftCell.HasPath)
                    {
                        ((List<MazeDirection>)newHead.BuildDirections).Remove(MazeDirection.Left);
                        ((List<MazeDirection>)leftCell.BuildDirections).Remove(MazeDirection.Right);
                    }
                }
            }

            return newHead;
        }

 public MazeCellEdge GetEdge(MazeDirection dir) {
     return this.edges[(int)dir];
 }

 public void SetEdge(MazeDirection dir, MazeCellEdge edge) {
     this.edges[(int)dir] = edge;
     this.initedEdgeCount += 1;
 }