예제 #1
0
        public void Clear()
        {
            Polygons = new List <GLPolygon>();

            for (var i = 0; i < LabyrinthWidth; i++)
            {
                for (var j = 0; j < LabyrinthHeight; j++)
                {
                    LabMatrix[i, j] = 0;
                }
            }

            UnLockedFinishPolygons.Clear();
            LockedFinishPolygons.Clear();

            BonusItems.Clear();
            Path.Clear();
        }
예제 #2
0
        public void Generate(Context context, int moves, int itemsCount)
        {
            Clear();

            State = AutoPilotStateEnum.Stoppped;

            StartPos = new Point(Rnd.Next(20, 80), Rnd.Next(20, 80));

            _bonusItemsCount = itemsCount;

            var actPos = new Point(StartPos.X, StartPos.Y);

            EndPos = new Point(actPos.X, actPos.Y);

            LabMatrix[actPos.X, actPos.Y] = 1;

            var direction = 1;

            for (var move = 0; move <= moves; move++)
            {
                var steps = Rnd.Next(1, 4);

                if (move == 0)
                {
                    steps = 4;            // 4 steps on beginning
                }
                for (var step = 0; step < steps; step++)
                {
                    if (CanMove(actPos.X, actPos.Y, direction))
                    {
                        switch (direction)
                        {
                        case 0: actPos.X += 1; break;

                        case 1: actPos.Y += 1; break;

                        case 2: actPos.X -= 1; break;

                        case 3: actPos.Y -= 1; break;
                        }

                        Path.Add(direction);

                        EndPos = new Point(actPos.X, actPos.Y);
                        LabMatrix[actPos.X, actPos.Y] = 1;
                    }
                }

                direction = Rnd.Next(0, 3);
            }

            var generatedPositions = new List <Point>();

            for (var j = 0; j < LabyrinthHeight; j++)
            {
                for (var i = 0; i < LabyrinthWidth; i++)
                {
                    if (LabMatrix[i, j] == 1)
                    {
                        generatedPositions.Add(new Point(i, j));
                    }

                    if ((i == StartPos.X) && (j == StartPos.Y))
                    {
                        GeneratePosition(i, j, "labWallS", "labBottomS", "labTopS");
                    }
                    else
                    if ((i == EndPos.X) && (j == EndPos.Y))
                    {
                        // locked:
                        LockedFinishPolygons.AddRange(GeneratePosition(i, j, "labWallL", "labBottomL", "labTopL"));

                        // unlocked:
                        UnLockedFinishPolygons.AddRange(GeneratePosition(i, j, "labWallF", "labBottomF", "labTopF"));
                    }
                    else
                    {
                        GeneratePosition(i, j);
                    }
                }
            }

            // bonus items

            if (generatedPositions.Count > BonusItemsCount + 4)
            {
                while (BonusItems.Count < BonusItemsCount)
                {
                    var r = Rnd.Next(2, generatedPositions.Count - 2);
                    if (BonusItems.Count == 0)
                    {
                        // first bonus item always 2 steps before observer
                        r = 2;
                    }

                    var p = new Point(generatedPositions[r].X, generatedPositions[r].Y);

                    if (BonusItems.ContainsKey(p) ||
                        ((StartPos.X == p.X && StartPos.Y == p.Y)) ||
                        ((EndPos.X == p.X && EndPos.Y == p.Y))
                        )
                    {
                        continue;
                    }

                    var item = new GLObject();
                    item.LoadFromAndroidAsset(context, "diamond.xml");
                    item.Position = new GLPoint((p.X + 0) * TileWidth, -2, (p.Y + 0) * TileWidth + TileWidth / 2);

                    BonusItems.Add(new Point(p.X, p.Y), item);
                }
            }

            // generating map
            var mapLines = new StringBuilder();

            for (var j = 0; j < LabyrinthHeight; j++)
            {
                string line = null;
                for (var i = 0; i < LabyrinthWidth; i++)
                {
                    if (LabMatrix[i, j] == 1)
                    {
                        if ((i == StartPos.X) && (j == StartPos.Y))
                        {
                            line += 'S';
                        }
                        else
                        if ((i == EndPos.X) && (j == EndPos.Y))
                        {
                            line += 'F';
                        }
                        else
                        {
                            var bonusAtThisPos = false;
                            foreach (var kvp in BonusItems)
                            {
                                if ((i == kvp.Key.X) && (j == kvp.Key.Y))
                                {
                                    bonusAtThisPos = true;
                                    break;
                                }
                            }

                            line += bonusAtThisPos ? 'o' :'#';
                        }
                    }
                    else
                    {
                        line += ' ';
                    }
                }

                if (line != null && line.Trim() != String.Empty)
                {
                    mapLines.Append(line);
                    mapLines.Append(Environment.NewLine);
                }
            }

            Logger.Info("Map:" + Environment.NewLine + mapLines.ToString());

            Locked      = true;
            FinishCount = 0;

            Move(-TileWidth / 2, 0, 0);
        }