// Use this for initialization
 void Start()
 {
     dungeon        = generate();
     dungeonObjects = new GameObject[dungeon.getMaze_length()][];
     for (int i = 0; i < dungeon.getMaze_length(); i++)
     {
         dungeonObjects[i] = new GameObject[dungeon.getMaze_length()];
     }
     instantiate_maze(dungeon);
 }
Example #2
0
    // Use this for initialization
    void Start()
    {
        timer = 1 / step_per_second;

        maze_generator mg = this.GetComponentInParent <maze_generator>();

        dungeon = mg.Get_Dungeon;

        int mazeLength = dungeon.getMaze_length();

        tableLength = mazeLength * mazeLength;

        rewardTable = new int[tableLength, tableLength];
        qTable      = new float[tableLength, tableLength];
        usedTable   = new int[tableLength, tableLength];
        //creates reward table
        for (int i = 0; i < tableLength; i++)
        {
            for (int j = 0; j < tableLength; j++)
            {
                //first put every state to state as -1 so it is not reachable
                rewardTable[i, j] = -1;
                int curVerIndex_j    = i % mazeLength;
                int curVerIndex_i    = (i - curVerIndex_j) / mazeLength;
                int targetVerIndex_j = j % mazeLength;
                int targetVerIndex_i = (j - targetVerIndex_j) / mazeLength;
                //foreach state to state
                cell current = dungeon.getCells()[curVerIndex_i][curVerIndex_j];
                cell target  = dungeon.getCells()[targetVerIndex_i][targetVerIndex_j];
                //look for current states neighbours
                foreach (cell neighbour in current.getNeighbours())
                {
                    //if its reachable
                    if (neighbour == target)
                    {
                        //then mark it as 0 so it is reachable
                        rewardTable[i, j] = 0;
                        //if it is the end point then mark it with reward
                        if (dungeon.end_i == targetVerIndex_i && dungeon.end_j == targetVerIndex_j)
                        {
                            rewardTable[i, j] = reward;
                        }
                        break;
                    }
                }
            }
        }

        character  = Instantiate(character, new Vector3(dungeon.start_x, dungeon.start_y, 0), Quaternion.identity);
        curVertice = dungeon.start_i * dungeon.getMaze_length() + dungeon.start_j;
    }
Example #3
0
    void Awake()
    {
        height = wall.transform.localPosition.y;
        space  = wall.transform.localScale.y;
        myMaze = new maze(mazeRowSize, mazeColSize, height, space);


        for (int i = 0; i < myMaze.index; i++)
        {
            GameObject g = Instantiate(wall);
            g.transform.SetParent(walls);
            g.transform.localPosition = myMaze.points[i];
        }
    }
Example #4
0
        public void Equals_Obj_Test_Matching_Same_Solotion()
        {
            IHeuristic          AirDistance      = new MazeAirDistance();
            ASearchingAlgorithm astarAir         = new Astar(AirDistance);
            MazeGenerator       DfsMazeGenerator = new DfsMazeGenerator();
            maze        Dfs            = DfsMazeGenerator.generatMaze(20, 20);
            ISearchable SearchableMaze = new SearchableMaze(Dfs, false);
            Solution    target         = astarAir.Solve(SearchableMaze);

            Solution inObject = astarAir.Solve(SearchableMaze);
            bool     expected = true;
            bool     actual   = target.GetSolutionPath().Capacity.Equals(inObject.GetSolutionPath().Capacity);

            Assert.AreEqual(expected, actual);
        }
Example #5
0
        public void Equals_Sol_Test_null()
        {
            IHeuristic          AirDistance      = new MazeAirDistance();
            ASearchingAlgorithm astarAir         = new Astar(AirDistance);
            MazeGenerator       DfsMazeGenerator = new DfsMazeGenerator();
            maze        Dfs             = DfsMazeGenerator.generatMaze(20, 20);
            ISearchable SearchableMazeA = new SearchableMaze(Dfs, false);
            ISearchable SearchableMazeB = new SearchableMaze(Dfs, true);

            Solution target   = astarAir.Solve(SearchableMazeA);
            Solution inObject = astarAir.Solve(SearchableMazeB);
            bool     expected = false;
            bool     actual   = target.Equals(inObject);

            Assert.AreEqual(expected, actual);
        }
Example #6
0
        ///constractor <summary>
        ///
        /// </summary>
        /// <param name="mazeHight"></param>
        /// <param name="mazeLength"></param>
        /// <param name="mazeCellSize"></param>
        /// <param name="maze"></param>
        public MazeBoard(int mazeHight, int mazeLength, int mazeCellSize, maze maze)
        {
            InitializeComponent();
            m_mazeCellSize  = mazeCellSize;
            m_itemLocationX = 1;
            m_itemLocationY = 1;
            item            = new ItemPoint(m_mazeCellSize);
            Goal G = new Goal(mazeCellSize);

            mazeBoard.Children.Add(item);
            Canvas.SetLeft(item, m_mazeCellSize);
            Canvas.SetTop(item, m_mazeCellSize);
            mazeBoard.Children.Add(G);
            Canvas.SetLeft(G, (mazeHight - 2) * m_mazeCellSize);
            Canvas.SetTop(G, (mazeLength - 2) * m_mazeCellSize);
            CreateMaze(mazeHight, mazeLength, m_mazeCellSize, maze);
        }
Example #7
0
    private void Start()
    {
        playerColl      = this.GetComponent <CapsuleCollider>();
        boardTurnSystem = GameObject.Find("Maze").GetComponent <RandoMazeBoard>();
        maze            = GameObject.Find("Maze").GetComponent <maze>();
        move            = GetComponent <keyMove2>();
        NVM             = GetComponent <navMashMove>();

        //for each gameObject of Turnclass in the List of "Maze"
        foreach (TurnClass element in boardTurnSystem.playersGroup)
        {
            //if the gameObject Name matches the gameObject name in "Maze" /check if gameObject is registered in "Maze"
            //add reference of element instance into turnclass
            if (element.playerGameObject.name == gameObject.name)
            {
                turnClass = element;
            }
        }
    }
 public void set_neighbours(maze dungeon)
 {
     if (c_x != 0)
     {
         neighbours[directions.north] = dungeon.getCells()[c_x - 1][c_y];
     }
     if (c_y != dungeon.getMaze_length() - 1)
     {
         neighbours[directions.east] = dungeon.getCells()[c_x][c_y + 1];
     }
     if (c_x != dungeon.getMaze_length() - 1)
     {
         neighbours[directions.south] = dungeon.getCells()[c_x + 1][c_y];
     }
     if (c_y != 0)
     {
         neighbours[directions.west] = dungeon.getCells()[c_x][c_y - 1];
     }
 }
Example #9
0
        public void Run100()
        {
            IHeuristic          AirDistance      = new MazeAirDistance();
            ASearchingAlgorithm astarAir         = new Astar(AirDistance);
            MazeGenerator       DfsMazeGenerator = new DfsMazeGenerator();
            maze        Dfs            = DfsMazeGenerator.generatMaze(20, 20);
            ISearchable SearchableMaze = new SearchableMaze(Dfs, true);
            Solution    inObject       = astarAir.Solve(SearchableMaze);
            Solution    target;

            bool expected = true;

            for (int i = 0; i < 100; i++)
            {
                target = astarAir.Solve(SearchableMaze);
                bool actual = target.GetSolutionPath().Capacity.Equals(inObject.GetSolutionPath().Capacity);
                Assert.AreEqual(expected, actual);
            }
        }
Example #10
0
        /// ThreadPoolGeneratMaze<summary>
        /// thrading to genrate maze by give algorithem
        /// </summary>
        /// <param name="param">'hight' 'width' 'name'</param>
        public void ThreadPoolGeneratMaze(object param)
        {
            string[] p = (string[])param;

            IStoppable NewMazeGenerator;

            if (Curr_Genrator == "Dfs")//// Change from Configure
            {
                NewMazeGenerator = new DfsMazeGenerator();
            }
            else
            {
                NewMazeGenerator = new RandomMazeGenerator();
            }

            Workers.Add(NewMazeGenerator);
            maze m_Maze = new maze();

            m_Status = string.Format("Maze {0} started Genarate...", p[2]);
            PrintEvent();

            m_Maze = (maze)(((MazeGenerator)NewMazeGenerator).generatMaze(Convert.ToInt32(p[0]), Convert.ToInt32(p[1])));

            if (m_Maze != null)
            {
                extendedMaze ex_Maze = new extendedMaze(m_Maze);
                ex_Maze.setName(p[2]);
                if (p[3] != "0")
                {
                    ex_Maze.SaveGuiParams(p[3]);
                }
                addMaze(ex_Maze, p[2]);
                m_Status = string.Format("Maze {0} is ready...", p[2]);
                PrintEvent();
            }
        }
Example #11
0
 public extendedMaze(maze maze)
     : base(maze)
 {
 }
Example #12
0
 /// <summary>
 /// Creates a new Node from the given position, then explores it's children
 /// </summary>
 /// <param name="position">Position of the node</param>
 /// <param name="fromParent">Distance from the parent node to this node</param>
 /// <param name="maze">Maze the node is in</param>
 /// <param name="keys">Currently available keys</param>
 private Node(Vector2 <int> position, int fromParent, Maze maze, int keys) : this(position, fromParent) => Explore(maze, keys);
    //instatiation of maze and indices
    public void instantiate_maze(maze dungeon)
    {
        Transform  mazeObject = new GameObject("mazeObject").transform;
        GameObject generator  = GameObject.FindGameObjectWithTag("Mg");
        Vector3    startPoint = generator.transform.position;

        if (mazeLength % 2 == 0)
        {
            startPoint.x -= ((mazeLength / 2) - 0.5f) * 16;
            startPoint.y += ((mazeLength / 2) - 0.5f) * 16;
        }
        else
        {
            startPoint.x -= Mathf.Floor(mazeLength / 2) * 16;
            startPoint.y += Mathf.Floor(mazeLength / 2) * 16;
        }
        int startIndex_x, startIndex_y, endIndex_x, endIndex_y;

        //Select random start and end point or make them fixed to the most left-up and the most right-down
        if (select_random_start_and_end)
        {
            startIndex_x = Random.Range(0, mazeLength);
            startIndex_y = Random.Range(0, mazeLength);
            endIndex_x   = Random.Range(0, mazeLength);
            endIndex_y   = Random.Range(0, mazeLength);
            while (startIndex_x == endIndex_x && startIndex_y == endIndex_y)
            {
                endIndex_x = Random.Range(0, mazeLength);
                endIndex_y = Random.Range(0, mazeLength);
            }
        }
        else
        {
            startIndex_x = startIndex_y = 0;
            endIndex_x   = endIndex_y = mazeLength - 1;
        }
        dungeon.start_i = startIndex_y;
        dungeon.start_j = startIndex_x;
        dungeon.end_i   = endIndex_y;
        dungeon.end_j   = endIndex_x;
        dungeon.start_x = startPoint.x + dungeon.start_j * 16;
        dungeon.start_y = startPoint.y - dungeon.start_i * 16;
        for (int i = 0; i < mazeLength; i++)
        {
            for (int j = 0; j < mazeLength; j++)
            {
                Vector3 point = startPoint;
                point.x += j * 16;
                point.y -= i * 16;
                cell   room  = dungeon.getCells()[i][j];
                int    index = 0;
                bool[] doors = room.getDoors();
                if (doors[0])
                {
                    index += 8;
                }
                if (doors[1])
                {
                    index += 4;
                }
                if (doors[2])
                {
                    index += 2;
                }
                if (doors[3])
                {
                    index += 1;
                }
                GameObject newRoom;
                if (i == startIndex_y && j == startIndex_x)
                {
                    newRoom = Instantiate(roomArray_start[index], point, Quaternion.identity) as GameObject;
                }
                else if (i == endIndex_y && j == endIndex_x)
                {
                    newRoom = Instantiate(roomArray_end[index], point, Quaternion.identity) as GameObject;
                }
                else
                {
                    newRoom = Instantiate(roomArray[index], point, Quaternion.identity) as GameObject;
                }
                newRoom.transform.SetParent(mazeObject);
                GameObject marker;
                if (doors[0])
                {
                    marker = Instantiate(markers[directions.north], newRoom.transform);
                }
                if (doors[1])
                {
                    marker = Instantiate(markers[directions.east], newRoom.transform);
                }
                if (doors[2])
                {
                    marker = Instantiate(markers[directions.south], newRoom.transform);
                }
                if (doors[3])
                {
                    marker = Instantiate(markers[directions.west], newRoom.transform);
                }
                dungeonObjects[i][j] = newRoom;
            }
        }
    }
    //prims maze generation algorithm
    public maze generate()
    {
        maze dungeon = new maze(mazeLength);
        //Prim's maze generator algorithm
        List <cell>  toBeVisited = new List <cell>();
        List <short> choices     = new List <short>();

        toBeVisited.Add(dungeon.getCells()[0][0]);
        while (toBeVisited.Count != 0)
        {
            //select randomly
            cell selected = toBeVisited[Random.Range(0, toBeVisited.Count)];
            selected.visited = true;
            //find choices
            if (selected.getC_x() != 0 && selected.getNeighbours()[directions.north].visited)
            {
                choices.Add(directions.north);
            }
            if (selected.getC_y() != dungeon.getMaze_length() - 1 && selected.getNeighbours()[directions.east].visited)
            {
                choices.Add(directions.east);
            }
            if (selected.getC_x() != dungeon.getMaze_length() - 1 && selected.getNeighbours()[directions.south].visited)
            {
                choices.Add(directions.south);
            }
            if (selected.getC_y() != 0 && selected.getNeighbours()[directions.west].visited)
            {
                choices.Add(directions.west);
            }
            //choose where selected will be connected
            if (choices.Count > 0)
            {
                cell toWhere = selected.getNeighbours()[choices[Random.Range(0, choices.Count)]];
                dungeon.createPassage(selected.getC_x(), selected.getC_y(), toWhere.getC_x(), toWhere.getC_y());
            }
            //add unvisited nodes
            if (selected.getC_x() != 0 && !selected.getNeighbours()[directions.north].visited)
            {
                toBeVisited.Add(selected.getNeighbours()[directions.north]);
            }
            if (selected.getC_y() != dungeon.getMaze_length() - 1 && !selected.getNeighbours()[directions.east].visited)
            {
                toBeVisited.Add(selected.getNeighbours()[directions.east]);
            }
            if (selected.getC_x() != dungeon.getMaze_length() - 1 && !selected.getNeighbours()[directions.south].visited)
            {
                toBeVisited.Add(selected.getNeighbours()[directions.south]);
            }
            ;
            if (selected.getC_y() != 0 && !selected.getNeighbours()[directions.west].visited)
            {
                toBeVisited.Add(selected.getNeighbours()[directions.west]);
            }
            choices.Clear();
            toBeVisited.Remove(selected);
        }
        //Remove unreachable neighbours
        for (int i = 0; i < mazeLength; i++)
        {
            for (int j = 0; j < mazeLength; j++)
            {
                dungeon.getCells()[i][j].fix_neighbours();
            }
        }

        return(dungeon);
    }
 private void BeginGame()
 {
     mazeInstance = Instantiate(mazePrefab) as maze;
     StartCoroutine(mazeInstance.Generate());
 }