Ejemplo n.º 1
0
        public static void Solve()
        {
            AppData.AppState = AppData.AppStates.LongTask;

            //MazePoint[,] precMatrix;
            //int[,] distMatrix;
            var solvePath = new List <MazePoint>();

            var heatMatrix   = HeatMap.Generate(MazeData.EntrancePoint.X, MazeData.EntrancePoint.Y, false, MazeData.ExitPoint.X, MazeData.ExitPoint.Y);
            var currentPoint = new MazePoint(MazeData.ExitPoint.X, MazeData.ExitPoint.Y);

            while (currentPoint != null)
            {
                var lastPoint = currentPoint;
                if (AppData.AppState == AppData.AppStates.Idle)
                {
                    break;
                }
                if (heatMatrix[currentPoint.X, currentPoint.Y].Preceding != null &&
                    (Math.Abs(currentPoint.X - heatMatrix[currentPoint.X, currentPoint.Y].Preceding.X) > 1 ||
                     Math.Abs(currentPoint.Y - heatMatrix[currentPoint.X, currentPoint.Y].Preceding.Y) > 1))
                {
                    var extraWeavePoint = new MazePoint((currentPoint.X + heatMatrix[currentPoint.X, currentPoint.Y].Preceding.X) / 2, (currentPoint.Y + heatMatrix[currentPoint.X, currentPoint.Y].Preceding.Y) / 2);
                    solvePath.Add(extraWeavePoint);
                }
                solvePath.Add(currentPoint);
                currentPoint = heatMatrix[currentPoint.X, currentPoint.Y].Preceding;
                //if (AnimateCheckBox.Checked && Convert.ToInt32(DelayTextBox.Text) > 0)
                //    Thread.Sleep(Convert.ToInt32(DelayTextBox.Text));
            }

            //foreach (var solvePoint in solvePath)
            for (var i = 1; i < solvePath.Count - 1; i++)
            {
                MazeData.MazeMatrix[solvePath[i].X, solvePath[i].Y].Display = MazeData.MazeColors[CellState.AutoPath];
            }

            /*if (!AnimateCheckBox.Checked)
             * {
             *  foreach (var solvePoint in solvePath)
             *      DrawCell(solvePoint.X, solvePoint.Y, MazeColors.AutoPath.Brush);
             *  RefreshPictureBox();
             * }*/
            /*BeginInvoke(new MethodInvoker(() =>
             * {
             *  EnableButtons();
             *  GameStepsLabel.Visible = true;
             *  GameStepsLabel.Text = @"Shortest path - " + solvePath.Count;
             * }));*/
        }
Ejemplo n.º 2
0
        public static void Solve()
        {
            AppData.AppState = AppData.AppStates.LongTask;

            //MazePoint[,] precMatrix;
            //int[,] distMatrix;
            var solvePath = new List<MazePoint>();

            var heatMatrix = HeatMap.Generate(MazeData.EntrancePoint.X, MazeData.EntrancePoint.Y, false, MazeData.ExitPoint.X, MazeData.ExitPoint.Y);
            var currentPoint = new MazePoint(MazeData.ExitPoint.X, MazeData.ExitPoint.Y);
            while (currentPoint != null)
            {
                var lastPoint = currentPoint;
                if (AppData.AppState == AppData.AppStates.Idle)
                    break;
                if (heatMatrix[currentPoint.X, currentPoint.Y].Preceding != null &&
                    (Math.Abs(currentPoint.X - heatMatrix[currentPoint.X, currentPoint.Y].Preceding.X) > 1 ||
                    Math.Abs(currentPoint.Y - heatMatrix[currentPoint.X, currentPoint.Y].Preceding.Y) > 1))
                {
                    var extraWeavePoint = new MazePoint((currentPoint.X + heatMatrix[currentPoint.X, currentPoint.Y].Preceding.X) / 2, (currentPoint.Y + heatMatrix[currentPoint.X, currentPoint.Y].Preceding.Y) / 2);
                    solvePath.Add(extraWeavePoint);
                }
                solvePath.Add(currentPoint);
                currentPoint = heatMatrix[currentPoint.X, currentPoint.Y].Preceding;
                //if (AnimateCheckBox.Checked && Convert.ToInt32(DelayTextBox.Text) > 0)
                //    Thread.Sleep(Convert.ToInt32(DelayTextBox.Text));
            }

            //foreach (var solvePoint in solvePath)
            for(var i = 1; i < solvePath.Count - 1; i++)
                MazeData.MazeMatrix[solvePath[i].X, solvePath[i].Y].Display = MazeData.MazeColors[CellState.AutoPath];

            /*if (!AnimateCheckBox.Checked)
            {
                foreach (var solvePoint in solvePath)
                    DrawCell(solvePoint.X, solvePoint.Y, MazeColors.AutoPath.Brush);
                RefreshPictureBox();
            }*/
            /*BeginInvoke(new MethodInvoker(() =>
            {
                EnableButtons();
                GameStepsLabel.Visible = true;
                GameStepsLabel.Text = @"Shortest path - " + solvePath.Count;
            }));*/
        }
Ejemplo n.º 3
0
        public static HeatPoint[,] Generate(int fromX, int fromY, bool draw, int breakOnX, int breakOnY)
        {
            var _mazeWidth  = MazeData.MazeSize;
            var _mazeHeight = MazeData.MazeSize;

            //distMatrix = new int[_mazeWidth, _mazeHeight];
            //precMatrix = new MazePoint[_mazeWidth, _mazeHeight];

            var heatMatrix = new HeatPoint[_mazeWidth, _mazeHeight];

            for (int i = 0; i < _mazeWidth; i++)
            {
                for (int j = 0; j < _mazeHeight; j++)
                {
                    heatMatrix[i, j] = new HeatPoint();
                }
            }

            var point = new MazePoint(fromX, fromY);
            var row   = new LinkedList <MazePoint>();

            row.AddFirst(point);

            var endPointFound = false;
            var count         = 1;
            var newCount      = -1;
            var index         = -1;

            for (var curr = row.First; curr != null; curr = curr.Next)
            {
                index++;
                if (AppData.AppState == AppData.AppStates.Idle)
                {
                    break;
                }

                if (index == count)
                {
                    newCount = row.Count;
                }

                if (index == newCount)
                {
                    for (var i = 0; i < count; i++)
                    {
                        row.RemoveFirst();
                    }
                    index   -= count;
                    count    = newCount - count;
                    newCount = row.Count;
                }

                var adjPoints = MazeData.GetAdjPoints(curr.Value);
                foreach (var adjPoint in adjPoints)
                {
                    MazePoint goToPoint;

                    /*if (MazeData.MazeMatrix[adjPoint.X, adjPoint.Y] == CellState.HorWeave ||
                     *  MazeData.MazeMatrix[adjPoint.X, adjPoint.Y] == CellState.VertWeave)
                     * {
                     *  goToPoint = new MazePoint(adjPoint.X + (adjPoint.X - curr.Value.X),
                     *      adjPoint.Y + (adjPoint.Y - curr.Value.Y));
                     * }
                     * else*/
                    goToPoint = adjPoint;

                    if (row.Contains(goToPoint))
                    {
                        continue;
                    }
                    row.AddLast(goToPoint);
                    heatMatrix[goToPoint.X, goToPoint.Y].Preceding = curr.Value;
                    heatMatrix[goToPoint.X, goToPoint.Y].Distance  = heatMatrix[curr.Value.X, curr.Value.Y].Distance + 1;

                    if (breakOnX > 0 && breakOnY > 0 && goToPoint.X == breakOnX && goToPoint.Y == breakOnY)
                    {
                        endPointFound = true;
                        break;
                    }
                }
                //if (AnimateCheckBox.Checked && Convert.ToInt32(DelayTextBox.Text) > 0)
                //    Thread.Sleep(Convert.ToInt32(DelayTextBox.Text));
                if (endPointFound)
                {
                    break;
                }
            }

            /*for (var i = 0; i < _mazeWidth; i++)
             * {
             *  for (var j = 0; j < _mazeHeight; j++)
             *  {
             *      switch (_mazeMatrix[i, j])
             *      {
             *          case CellState.VertWeave:
             *              distMatrix[i, j] = (distMatrix[i + 1, j] + distMatrix[i - 1, j]) / 2;
             *              break;
             *          case CellState.HorWeave:
             *              distMatrix[i, j] = (distMatrix[i, j + 1] + distMatrix[i, j - 1]) / 2;
             *              break;
             *      }
             *  }
             * }*/

            if (!draw)
            {
                return(heatMatrix);
            }

            var maxDist = 1;

            for (var i = 0; i < _mazeWidth; i++)
            {
                for (var j = 0; j < _mazeHeight; j++)
                {
                    if (heatMatrix[i, j].Distance > maxDist)
                    {
                        maxDist = heatMatrix[i, j].Distance;
                    }
                }
            }

            for (var i = 0; i < _mazeWidth; i++)
            {
                for (var j = 0; j < _mazeHeight; j++)
                {
                    if (MazeData.MazeMatrix[i, j] == null || MazeData.MazeMatrix[i, j].State == CellState.Wall)
                    {
                        continue;
                    }

                    var   red = heatMatrix[i, j].Distance * 255 / maxDist;
                    Color c;
                    if (heatMatrix[i, j].Distance < 1)
                    {
                        c = MazeData.MazeColors[CellState.Entrance];
                    }
                    else if (heatMatrix[i, j].Distance > maxDist - 1)
                    {
                        c = MazeData.MazeColors[CellState.Furthest];
                    }
                    else
                    {
                        c = Color.FromRgba(50 * 256 * 256 + 50 * 256 + red);
                    }
                    MazeData.MazeMatrix[i, j].Display = c;
                }
            }

            return(heatMatrix);
        }
Ejemplo n.º 4
0
        public override void GenerateMaze(int size, ref double animationDelay, ref int behaviorValue)
        {
            MazeData.CreateEmpty(size);

            //var loopValue = 0;
            //var weaveValue = 0;

            var useInfluences = false;
            var leftInfluence = 0;
            var rightInfluence = 0;
            var upInfluence = 0;
            var downInfluence = 0;

            var _mazeWidth = size;
            var _mazeHeight = size;

            var row = _rng.Next(0, _mazeWidth/2 - 1)*2 + 1;
            var col = _rng.Next(0, _mazeHeight/2 - 1)*2 + 1;

            var path = new List<MazePoint> {new MazePoint(row, col)};

            MazeData.MazeMatrix[row, col].State = CellState.Walkway;
            AppData.AppState = AppData.AppStates.LongTask;

            //var permitloop = false;
            var success = true;
            var moveVect = MazeData.Directions[-1];
            while (path.Count > 0 && AppData.AppState == AppData.AppStates.LongTask)
            {
                int currIndex;
                if (_rng.Next(1, 1001) < behaviorValue)
                    currIndex = _rng.Next(0, path.Count);
                else
                    currIndex = path.Count - 1;

                row = path[currIndex].X;
                col = path[currIndex].Y;

                //var origRow = row;
                //var origCol = col;

                //success = TryDig(ref row, ref col, out moveVect, _rng.Next(0, 1001) < weaveValue, false, useInfluences ? new List<int> { leftInfluence, rightInfluence, upInfluence, downInfluence } : null);
                var rand = 0;
                //var val = 0;
                var probabilities = useInfluences
                    ? new List<int> {leftInfluence, rightInfluence, upInfluence, downInfluence}
                    : null;
                if (probabilities == null)
                    probabilities = new List<int> {1, 1, 1, 1};
                var dirCopy = new List<MazePoint>(MazeData.Directions.Values);

                for (var i = 0; i < 4; i++)
                {
                    if (probabilities.All(x => x == 0))
                        rand = _rng.Next(0, probabilities.Count);
                    else
                        for (var j = 0; j < probabilities.Count; j++)
                        {
                            var leftProb = 0;
                            for (var k = j; k < probabilities.Count; k++)
                                leftProb += probabilities[k];
                            var currProb = (1000000*probabilities[j])/leftProb;
                            if (_rng.Next(1, 1000001) < currProb)
                            {
                                rand = j;
                                break;
                            }
                        }

                    var direction = dirCopy[rand];

                    if (MazeData.IsPointInMaze(row + direction.X*2, col + direction.Y*2))
                    {
                        // Looping
                        //if (allowLoop)
                        //{
                        //    if (MazeData.MazeMatrix[row + direction.X, col + direction.Y] != CellState.Wall) continue;
                        //    MazeData.MazeMatrix[row + direction.X, col + direction.Y] = CellState.Walkway;
                        //    moveVector = new MyPoint(direction.X * 2, direction.Y * 2);
                        //    row += moveVector.X;
                        //    col += moveVector.Y;
                        //    return true;
                        //}

                        // Simple generation
                        if (MazeData.MazeMatrix[row + direction.X*2, col + direction.Y*2].State == CellState.Wall)
                        {
                            MazeData.MazeMatrix[row + direction.X, col + direction.Y].State = CellState.Walkway;
                            MazeData.MazeMatrix[row + direction.X, col + direction.Y].Display = MazeData.MazeColors[CellState.Generating];
                            MazeData.MazeMatrix[row + direction.X*2, col + direction.Y*2].State = CellState.Walkway;
                            MazeData.MazeMatrix[row + direction.X * 2, col + direction.Y * 2].Display = MazeData.MazeColors[CellState.Generating];

                            moveVect = new MazePoint(direction.X*2, direction.Y*2);
                            row += moveVect.X;
                            col += moveVect.Y;
                            success = true;
                            break;
                        }

                        // Weaving
                        //if (allowWeave && _mazeRectangle.Contains(row + direction.X * 4, col + direction.Y * 4)
                        //    && _mazeMatrix[row + direction.X * 2, col + direction.Y * 2] == CellState.Walkway
                        //    && _mazeMatrix[row + direction.X * 4, col + direction.Y * 4] == CellState.Wall
                        //    && _mazeMatrix[row + direction.X, col + direction.Y] == CellState.Wall)
                        //{
                        //    _mazeMatrix[row + direction.X * 2, col + direction.Y * 2] =
                        //        direction.Y == 0 ? CellState.HorWeave : CellState.VertWeave;
                        //    _mazeMatrix[row + direction.X, col + direction.Y] = CellState.Walkway;
                        //    _mazeMatrix[row + direction.X * 3, col + direction.Y * 3] = CellState.Walkway;
                        //    _mazeMatrix[row + direction.X * 4, col + direction.Y * 4] = CellState.Walkway;
                        //    moveVector = new MyPoint(direction.X * 4, direction.Y * 4);
                        //    row += moveVector.X;
                        //    col += moveVector.Y;
                        //    return true;
                        //}
                    }
                    dirCopy.RemoveAt(rand);
                    try
                    {
                        probabilities.RemoveAt(rand);
                    }
                    catch
                    {
                    }
                    if (i == 3)
                    {
                        //moveVect = MazeData.Directions[-1];
                        success = false;
                    }
                }
                // Failed to generate
                if (success)
                {
                    //permitloop = true;
                    path.Add(new MazePoint(row, col));
                }
                else
                {
                    //if (permitloop && _rng.Next(0, 101) < loopValue)
                    //{
                    //    TryDig(ref row, ref col, out moveVect, false, true, null);
                    //    if (AnimateCheckBox.Checked)
                    //    {
                    //        var rowDiff = row - origRow;
                    //        var colDiff = col - origCol;

                    //        if (rowDiff != 0)
                    //            DrawCell(origRow + (rowDiff > 0 ? 1 : -1), origCol, MazeColors.Walkway.Brush);
                    //        else if (colDiff != 0)
                    //            DrawCell(origRow, origCol + (colDiff > 0 ? 1 : -1), MazeColors.Walkway.Brush);

                    //        RefreshPictureBox(row, col, 1);
                    //    }
                    //}

                    //permitloop = false;
                    for (var i = -1; i < 4; i++)
                        for (var j = 1; j < 2; j++)
                        {
                            var x = row + MazeData.Directions[i].X * j;
                            var y = col + MazeData.Directions[i].Y * j;
                            if (MazeData.MazeMatrix[x, y] != null && MazeData.MazeMatrix[x, y].State != CellState.Wall)
                                MazeData.MazeMatrix[x, y].Display = MazeData.MazeColors[CellState.Walkway];
                        }
                    path.RemoveAt(currIndex);
                }

                if (animationDelay > 0)
                    Utils.Sleep(animationDelay);
            }


            //GC.Collect();

            MakeEntranceExit();
            AppData.AppState = AppData.AppStates.Idle;

        }
Ejemplo n.º 5
0
 public static bool IsPointInMaze(MazePoint point)
 {
     return(IsPointInMaze(point.X, point.Y));
 }
Ejemplo n.º 6
0
 public static IEnumerable <MazePoint> GetAdjPoints(MazePoint point)
 {
     return(GetAdjPoints(point.X, point.Y));
 }
Ejemplo n.º 7
0
        public override void GenerateMaze(int size, ref double animationDelay, ref int behaviorValue)
        {
            MazeData.CreateEmpty(size);

            //var loopValue = 0;
            //var weaveValue = 0;

            var useInfluences  = false;
            var leftInfluence  = 0;
            var rightInfluence = 0;
            var upInfluence    = 0;
            var downInfluence  = 0;

            var _mazeWidth  = size;
            var _mazeHeight = size;

            var row = _rng.Next(0, _mazeWidth / 2 - 1) * 2 + 1;
            var col = _rng.Next(0, _mazeHeight / 2 - 1) * 2 + 1;

            var path = new List <MazePoint> {
                new MazePoint(row, col)
            };

            MazeData.MazeMatrix[row, col].State = CellState.Walkway;
            AppData.AppState = AppData.AppStates.LongTask;

            //var permitloop = false;
            var success  = true;
            var moveVect = MazeData.Directions[-1];

            while (path.Count > 0 && AppData.AppState == AppData.AppStates.LongTask)
            {
                int currIndex;
                if (_rng.Next(1, 1001) < behaviorValue)
                {
                    currIndex = _rng.Next(0, path.Count);
                }
                else
                {
                    currIndex = path.Count - 1;
                }

                row = path[currIndex].X;
                col = path[currIndex].Y;

                //var origRow = row;
                //var origCol = col;

                //success = TryDig(ref row, ref col, out moveVect, _rng.Next(0, 1001) < weaveValue, false, useInfluences ? new List<int> { leftInfluence, rightInfluence, upInfluence, downInfluence } : null);
                var rand = 0;
                //var val = 0;
                var probabilities = useInfluences
                    ? new List <int> {
                    leftInfluence, rightInfluence, upInfluence, downInfluence
                }
                    : null;
                if (probabilities == null)
                {
                    probabilities = new List <int> {
                        1, 1, 1, 1
                    }
                }
                ;
                var dirCopy = new List <MazePoint>(MazeData.Directions.Values);

                for (var i = 0; i < 4; i++)
                {
                    if (probabilities.All(x => x == 0))
                    {
                        rand = _rng.Next(0, probabilities.Count);
                    }
                    else
                    {
                        for (var j = 0; j < probabilities.Count; j++)
                        {
                            var leftProb = 0;
                            for (var k = j; k < probabilities.Count; k++)
                            {
                                leftProb += probabilities[k];
                            }
                            var currProb = (1000000 * probabilities[j]) / leftProb;
                            if (_rng.Next(1, 1000001) < currProb)
                            {
                                rand = j;
                                break;
                            }
                        }
                    }

                    var direction = dirCopy[rand];

                    if (MazeData.IsPointInMaze(row + direction.X * 2, col + direction.Y * 2))
                    {
                        // Looping
                        //if (allowLoop)
                        //{
                        //    if (MazeData.MazeMatrix[row + direction.X, col + direction.Y] != CellState.Wall) continue;
                        //    MazeData.MazeMatrix[row + direction.X, col + direction.Y] = CellState.Walkway;
                        //    moveVector = new MyPoint(direction.X * 2, direction.Y * 2);
                        //    row += moveVector.X;
                        //    col += moveVector.Y;
                        //    return true;
                        //}

                        // Simple generation
                        if (MazeData.MazeMatrix[row + direction.X * 2, col + direction.Y * 2].State == CellState.Wall)
                        {
                            MazeData.MazeMatrix[row + direction.X, col + direction.Y].State           = CellState.Walkway;
                            MazeData.MazeMatrix[row + direction.X, col + direction.Y].Display         = MazeData.MazeColors[CellState.Generating];
                            MazeData.MazeMatrix[row + direction.X * 2, col + direction.Y * 2].State   = CellState.Walkway;
                            MazeData.MazeMatrix[row + direction.X * 2, col + direction.Y * 2].Display = MazeData.MazeColors[CellState.Generating];

                            moveVect = new MazePoint(direction.X * 2, direction.Y * 2);
                            row     += moveVect.X;
                            col     += moveVect.Y;
                            success  = true;
                            break;
                        }

                        // Weaving
                        //if (allowWeave && _mazeRectangle.Contains(row + direction.X * 4, col + direction.Y * 4)
                        //    && _mazeMatrix[row + direction.X * 2, col + direction.Y * 2] == CellState.Walkway
                        //    && _mazeMatrix[row + direction.X * 4, col + direction.Y * 4] == CellState.Wall
                        //    && _mazeMatrix[row + direction.X, col + direction.Y] == CellState.Wall)
                        //{
                        //    _mazeMatrix[row + direction.X * 2, col + direction.Y * 2] =
                        //        direction.Y == 0 ? CellState.HorWeave : CellState.VertWeave;
                        //    _mazeMatrix[row + direction.X, col + direction.Y] = CellState.Walkway;
                        //    _mazeMatrix[row + direction.X * 3, col + direction.Y * 3] = CellState.Walkway;
                        //    _mazeMatrix[row + direction.X * 4, col + direction.Y * 4] = CellState.Walkway;
                        //    moveVector = new MyPoint(direction.X * 4, direction.Y * 4);
                        //    row += moveVector.X;
                        //    col += moveVector.Y;
                        //    return true;
                        //}
                    }
                    dirCopy.RemoveAt(rand);
                    try
                    {
                        probabilities.RemoveAt(rand);
                    }
                    catch
                    {
                    }
                    if (i == 3)
                    {
                        //moveVect = MazeData.Directions[-1];
                        success = false;
                    }
                }
                // Failed to generate
                if (success)
                {
                    //permitloop = true;
                    path.Add(new MazePoint(row, col));
                }
                else
                {
                    //if (permitloop && _rng.Next(0, 101) < loopValue)
                    //{
                    //    TryDig(ref row, ref col, out moveVect, false, true, null);
                    //    if (AnimateCheckBox.Checked)
                    //    {
                    //        var rowDiff = row - origRow;
                    //        var colDiff = col - origCol;

                    //        if (rowDiff != 0)
                    //            DrawCell(origRow + (rowDiff > 0 ? 1 : -1), origCol, MazeColors.Walkway.Brush);
                    //        else if (colDiff != 0)
                    //            DrawCell(origRow, origCol + (colDiff > 0 ? 1 : -1), MazeColors.Walkway.Brush);

                    //        RefreshPictureBox(row, col, 1);
                    //    }
                    //}

                    //permitloop = false;
                    for (var i = -1; i < 4; i++)
                    {
                        for (var j = 1; j < 2; j++)
                        {
                            var x = row + MazeData.Directions[i].X * j;
                            var y = col + MazeData.Directions[i].Y * j;
                            if (MazeData.MazeMatrix[x, y] != null && MazeData.MazeMatrix[x, y].State != CellState.Wall)
                            {
                                MazeData.MazeMatrix[x, y].Display = MazeData.MazeColors[CellState.Walkway];
                            }
                        }
                    }
                    path.RemoveAt(currIndex);
                }

                if (animationDelay > 0)
                {
                    Utils.Sleep(animationDelay);
                }
            }


            //GC.Collect();

            MakeEntranceExit();
            AppData.AppState = AppData.AppStates.Idle;
        }

        /*private bool TryDig(ref int row, ref int col, out MazePoint moveVector, bool allowWeave, bool allowLoop, List<int> probabilities)
         * {
         *  var rand = 0;
         *  //var val = 0;
         *  if (probabilities == null)
         *      probabilities = new List<int> { 1, 1, 1, 1 };
         *  var dirCopy = new List<MazePoint>(MazeData.Directions.Values);
         *
         *  for (var i = 0; i < 4; i++)
         *  {
         *      if (probabilities.All(x => x == 0))
         *          rand = _rng.Next(0, probabilities.Count);
         *      else
         *          for (var j = 0; j < probabilities.Count; j++)
         *          {
         *              var leftProb = 0;
         *              for (var k = j; k < probabilities.Count; k++)
         *                  leftProb += probabilities[k];
         *              var currProb = (1000000 * probabilities[j]) / leftProb;
         *              if (_rng.Next(1, 1000001) < currProb)
         *              {
         *                  rand = j;
         *                  break;
         *              }
         *          }
         *
         *      var direction = dirCopy[rand];
         *
         *      if (MazeData.IsPointInMaze(row + direction.X*2, col + direction.Y*2))
         *      {
         *          // Looping
         *          //if (allowLoop)
         *          //{
         *          //    if (MazeData.MazeMatrix[row + direction.X, col + direction.Y] != CellState.Wall) continue;
         *          //    MazeData.MazeMatrix[row + direction.X, col + direction.Y] = CellState.Walkway;
         *          //    moveVector = new MyPoint(direction.X * 2, direction.Y * 2);
         *          //    row += moveVector.X;
         *          //    col += moveVector.Y;
         *          //    return true;
         *          //}
         *
         *          // Simple generation
         *          if (MazeData.MazeMatrix[row + direction.X * 2, col + direction.Y * 2].State == CellState.Wall)
         *          {
         *              MazeData.MazeMatrix[row + direction.X, col + direction.Y].State = CellState.Walkway;
         *              MazeData.MazeMatrix[row + direction.X * 2, col + direction.Y * 2].State = CellState.Walkway;
         *              moveVector = new MazePoint(direction.X * 2, direction.Y * 2);
         *              row += moveVector.X;
         *              col += moveVector.Y;
         *              return true;
         *          }
         *
         *          // Weaving
         *          //if (allowWeave && _mazeRectangle.Contains(row + direction.X * 4, col + direction.Y * 4)
         *          //    && _mazeMatrix[row + direction.X * 2, col + direction.Y * 2] == CellState.Walkway
         *          //    && _mazeMatrix[row + direction.X * 4, col + direction.Y * 4] == CellState.Wall
         *          //    && _mazeMatrix[row + direction.X, col + direction.Y] == CellState.Wall)
         *          //{
         *          //    _mazeMatrix[row + direction.X * 2, col + direction.Y * 2] =
         *          //        direction.Y == 0 ? CellState.HorWeave : CellState.VertWeave;
         *          //    _mazeMatrix[row + direction.X, col + direction.Y] = CellState.Walkway;
         *          //    _mazeMatrix[row + direction.X * 3, col + direction.Y * 3] = CellState.Walkway;
         *          //    _mazeMatrix[row + direction.X * 4, col + direction.Y * 4] = CellState.Walkway;
         *          //    moveVector = new MyPoint(direction.X * 4, direction.Y * 4);
         *          //    row += moveVector.X;
         *          //    col += moveVector.Y;
         *          //    return true;
         *          //}
         *      }
         *      dirCopy.RemoveAt(rand);
         *      try { probabilities.RemoveAt(rand); }
         *      catch { }
         *      // TODO: fix random error
         *  }
         *  // Failed to generate
         *  moveVector = MazeData.Directions[-1];
         *  return false;
         * }*/
    }
Ejemplo n.º 8
0
 public static bool IsPointInMaze(MazePoint point)
 {
     return IsPointInMaze(point.X, point.Y);
 }
Ejemplo n.º 9
0
 public static IEnumerable<MazePoint> GetAdjPoints(MazePoint point)
 {
     return GetAdjPoints(point.X, point.Y);
 }
Ejemplo n.º 10
0
        public static HeatPoint[,] Generate(int fromX, int fromY, bool draw, int breakOnX, int breakOnY)
        {
            var _mazeWidth = MazeData.MazeSize;
            var _mazeHeight = MazeData.MazeSize;

            //distMatrix = new int[_mazeWidth, _mazeHeight];
            //precMatrix = new MazePoint[_mazeWidth, _mazeHeight];

            var heatMatrix = new HeatPoint[_mazeWidth,_mazeHeight];

            for (int i = 0; i < _mazeWidth; i++)
                for (int j = 0; j < _mazeHeight; j++)
                    heatMatrix[i, j] = new HeatPoint();

            var point = new MazePoint(fromX, fromY);
            var row = new LinkedList<MazePoint>();
            row.AddFirst(point);

            var endPointFound = false;
            var count = 1;
            var newCount = -1;
            var index = -1;
            for (var curr = row.First; curr != null; curr = curr.Next)
            {
                index++;
                if (AppData.AppState == AppData.AppStates.Idle)
                    break;

                if (index == count)
                    newCount = row.Count;

                if (index == newCount)
                {
                    for (var i = 0; i < count; i++)
                        row.RemoveFirst();
                    index -= count;
                    count = newCount - count;
                    newCount = row.Count;
                }

                var adjPoints = MazeData.GetAdjPoints(curr.Value);
                foreach (var adjPoint in adjPoints)
                {
                    MazePoint goToPoint;
                    /*if (MazeData.MazeMatrix[adjPoint.X, adjPoint.Y] == CellState.HorWeave ||
                        MazeData.MazeMatrix[adjPoint.X, adjPoint.Y] == CellState.VertWeave)
                    {
                        goToPoint = new MazePoint(adjPoint.X + (adjPoint.X - curr.Value.X),
                            adjPoint.Y + (adjPoint.Y - curr.Value.Y));
                    }
                    else*/
                        goToPoint = adjPoint;

                    if (row.Contains(goToPoint))
                        continue;
                    row.AddLast(goToPoint);
                    heatMatrix[goToPoint.X, goToPoint.Y].Preceding = curr.Value;
                    heatMatrix[goToPoint.X, goToPoint.Y].Distance = heatMatrix[curr.Value.X, curr.Value.Y].Distance + 1;

                    if (breakOnX > 0 && breakOnY > 0 && goToPoint.X == breakOnX && goToPoint.Y == breakOnY)
                    {
                        endPointFound = true;
                        break;
                    }
                }
                //if (AnimateCheckBox.Checked && Convert.ToInt32(DelayTextBox.Text) > 0)
                //    Thread.Sleep(Convert.ToInt32(DelayTextBox.Text));
                if (endPointFound)
                    break;
            }

            /*for (var i = 0; i < _mazeWidth; i++)
            {
                for (var j = 0; j < _mazeHeight; j++)
                {
                    switch (_mazeMatrix[i, j])
                    {
                        case CellState.VertWeave:
                            distMatrix[i, j] = (distMatrix[i + 1, j] + distMatrix[i - 1, j]) / 2;
                            break;
                        case CellState.HorWeave:
                            distMatrix[i, j] = (distMatrix[i, j + 1] + distMatrix[i, j - 1]) / 2;
                            break;
                    }
                }
            }*/

            if (!draw)
                return heatMatrix;

            var maxDist = 1;
            for (var i = 0; i < _mazeWidth; i++)
                for (var j = 0; j < _mazeHeight; j++)
                    if (heatMatrix[i, j].Distance > maxDist)
                        maxDist = heatMatrix[i, j].Distance;

            for (var i = 0; i < _mazeWidth; i++)
            {
                for (var j = 0; j < _mazeHeight; j++)
                {
                    if (MazeData.MazeMatrix[i, j] == null || MazeData.MazeMatrix[i, j].State == CellState.Wall)
                        continue;

                    var red = heatMatrix[i, j].Distance * 255 / maxDist;
                    Color c;
                    if (heatMatrix[i, j].Distance < 1)
                        c = MazeData.MazeColors[CellState.Entrance];
                    else if (heatMatrix[i, j].Distance > maxDist - 1)
                        c = MazeData.MazeColors[CellState.Furthest];
                    else c = Color.FromRgba(50 * 256 * 256 + 50 * 256 + red);
                    MazeData.MazeMatrix[i, j].Display = c;
                }
            }

            return heatMatrix;
        }