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;
            }
        }
    }

	public void Initialize (MazeCell cell) {
		base.Initialize (cell);
		Vector3 temp = new Vector3(0,6f,0);
		this.transform.position += temp;
		var killTimer = Random.Range (3, 5);
		this.killTime = System.DateTime.Now.AddSeconds (killTimer);
	}

    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;
    }

 // 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 int FindAdjacentCellWall(MazeCell mazeCell)
 {
     if( mazeCell.row == this.row )
     {
         if( mazeCell.column < this.column)
         {
             return 0;
         }
         else
         {
             return 2;
         }
     }
     else
     {
         if( mazeCell.row < this.row )
         {
             return 1;
         }
         else
         {
             return 3;
         }
     }
 }

	protected void SetMazeCell(int row, int column, MazeCell cell){
		if (row >= 0 && column >= 0 && row < mMazeRows && column < mMazeColumns) {
			mMaze[row,column] = cell;
		}else{
			throw new System.ArgumentOutOfRangeException();
		}
	}

	public void SetLocation (MazeCell cell) {
		if (currentCell != null) {
			currentCell.OnPlayerExited();
		}
		currentCell = cell;
		transform.localPosition = cell.transform.localPosition;
		currentCell.OnPlayerEntered();
	}

	private List<MazeDoor> GetDoorsContainedAtCell(MazeCell cell) {
		var doors = new List<MazeDoor> ();
		foreach (var edge in cell.edges) {
			if (edge is MazeDoor)
				doors.Add ((MazeDoor)edge);
		}
		return doors;
	}

	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 CreateDoor(MazeCell mazeCell)
    {
        int sideToCreateDoorOn = FindAdjacentCellWall(mazeCell);
        doors[sideToCreateDoorOn] = true;

        int oppositeDoorSide = (sideToCreateDoorOn + 2) % 4;
        mazeCell.doors[oppositeDoorSide] = true;
    }

	private MazePassage GetMazePassageBasedOnMaxDoorNumber (MazeCell cell) {
		if (cell.room != null && cell.room.Size > maze.cells.Length/(maze.MaxDoorNumber+2)  && doorNumber < maze.MaxDoorNumber) {
			doorNumber++;
			return maze.doorPrefab;
		}
		else
			return maze.passagePrefab;
	}

	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());
     }
 }

	public static List<MazeCell> GetSurroundingCellsInSameRoom(MazeCell cell, MazeCell otherCell, MazeRoom room) {
		var selectedCell = cell.room.RoomId == room.RoomId ? cell : otherCell;

		List<MazeCell> cells = new List<MazeCell>();
		foreach (IntVector2 vectors in MazeDirections.vectorsAllDirections) {
			IntVector2 coordinates = selectedCell.coordinates + vectors;
			var celly = selectedCell.room.cells.Find (x => x.coordinates == coordinates);
			if (celly != null)
				cells.Add (celly);
		}
		return cells;
	}

	public static List<MazeCell> GetAllNeighborhoodCellsInSameRoom(MazeCell cell, int factor) {
		List<MazeCell> cells = new List<MazeCell>();
		foreach (IntVector2 vectors in MazeDirections.vectorsAllDirections) {
			IntVector2 tempVector = new IntVector2(0,0);
			for (int k = 0; k < factor+1; ++k)
				tempVector += vectors ;
			IntVector2 coordinates = cell.coordinates + tempVector;
			var celly = cell.room.cells.Find (x => x.coordinates == coordinates);
			if (celly != null)
				cells.Add (celly);
		}
		return cells;
	}

	private int GetCellComplexity(MazeCell cell) {
		int complexity = 0;
		int counter = 0;
		bool edgeReached = false;

		while (!edgeReached) {
			var neighborhoodCells = MazeCell.GetAllNeighborhoodCellsInSameRoom (cell, counter++);
			complexity += neighborhoodCells.Count;
			if (neighborhoodCells.Count < 8) 
				edgeReached = true;	
		}
		return complexity;
	}

 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());
 }

    public Maze(int width, int height)
    {
        this.width = width;
        this.height = height;

        cells = new MazeCell[width, height];

        //Fill the cells-array
        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                cells[x,y] = new MazeCell(x, y);
            }
        }
    }

	public BasicMazeGenerator(int rows, int columns){
		mMazeRows = Mathf.Abs(rows);
		mMazeColumns = Mathf.Abs(columns);
		if (mMazeRows == 0) {
			mMazeRows = 1;
		}
		if (mMazeColumns == 0) {
			mMazeColumns = 1;
		}
		mMaze = new MazeCell[rows,columns];
		for (int row = 0; row < rows; row++) {
			for(int column = 0; column < columns; column++){
				mMaze[row,column] = new MazeCell();
			}
		}
	}