示例#1
0
 private void LoadNewMap()
 {
     QuestGiver.ClearQuests();
     BonusLifeTile.ClearBonuses();
     MonsterController.ClearMonsters();
     MapGenerator.GenerateMap();
     NeedRefresh?.Invoke();
 }
示例#2
0
        public void Move(int x, int y)
        {
            int      xPos          = Game.PlayerRef.Position.X + x;
            int      yPos          = Game.PlayerRef.Position.Y + y;
            int      oldPlayerPosX = int.Parse(Game.PlayerRef.Position.X.ToString());
            int      oldPlayerPosY = int.Parse(Game.PlayerRef.Position.Y.ToString());
            Position pos           = new Position(xPos, yPos);
            Position previousPos   = new Position(oldPlayerPosX, oldPlayerPosY);

            if (PositionIsValid(xPos, yPos))
            {
                if (Map.MapTiles[yPos][xPos] is TreasureChestTile)
                {
                    TreasureChestTile chest = TreasureChestTile.TreasureChests.Find(item => item.ChestRight == pos || item.ChestLeft == pos);
                    if (chest != null && chest.IsOpened)
                    {
                        chest.Touch();
                        ItemTouched?.Invoke();
                    }
                    chest.Interact(pos);
                    NeedRefresh?.Invoke();
                    QuestItemInteracted?.Invoke(chest);
                }
                else if (Map.MapTiles[yPos][xPos] is NextLevelTile)
                {
                    LoadNewMap();
                }
                else if (Map.MapTiles[yPos][xPos] is QuestGiver)
                {
                    QuestGiver quest = QuestGiver.Quests.Find(q => q.Position == pos);
                    quest.Interact(pos);
                }
                else
                {
                    if (Map.MapTiles[yPos][xPos] is BonusLifeTile)
                    {
                        Position      futurePos = new Position(pos.X, pos.Y);
                        BonusLifeTile bonus     = BonusLifeTile.Bonuses.Find(b => b.Position == futurePos);
                        bonus.Interact(pos);
                        QuestItemInteracted?.Invoke(bonus);
                    }
                    Map.MapTiles[yPos][xPos] = Game.PlayerRef;
                    Map.MapTiles[Game.PlayerRef.Position.Y][Game.PlayerRef.Position.X] = new EmptySpaceTile();
                    Game.PlayerRef.Position.X += x;
                    Game.PlayerRef.Position.Y += y;
                }
            }
            else
            {
                if (Map.MapTiles[yPos][xPos] is ITouchable)
                {
                    ((ITouchable)Map.MapTiles[yPos][xPos]).Touch();
                }
            }

            MonsterAttackOnPlayerProximity(yPos, xPos);
            PlayerMoved?.Invoke(previousPos);
        }
示例#3
0
        private static void SetTile(ref int x, int y)
        {
            char currentCharacter = characters[random.Next(0, characters.Count)];

            ITile    tile     = null;
            Position position = new Position(x, y);

            switch (currentCharacter)
            {
            case Constants.TreasureLeftChar:
                if (x < Map.MapTiles[y].Length - 3 || (y == 1 && x == 1))
                {
                    tile = new TreasureChestTile(x, x + 1, y);
                    Map.MapTiles[y][x]     = tile;
                    Map.MapTiles[y][x + 1] = tile;
                    x += 1;
                    return;
                }
                else
                {
                    x -= 1;
                    return;
                }

            case Constants.MonsterChar:
                int power = new Random().Next(1, 4);
                if (power == 2)
                {
                    tile = new MonsterMediumTile(power, position);
                }
                else
                {
                    tile = new MonsterWeakTile(1, position);
                }
                break;

            case Constants.MonsterStrongChar:
                tile = new MonsterStrongTile(3, position);
                break;

            case Constants.BonusLifeChar:
                tile = new BonusLifeTile(new Random().Next(1, 6), position);
                break;

            case Constants.NextLevelChar:
                if (nextMapTileGenerated)
                {
                    x -= 1;
                    return;
                }
                else
                {
                    tile = new NextLevelTile(position);
                    nextMapTileGenerated = true;
                }
                break;

            case Constants.FreeSpaceChar:
                tile = new EmptySpaceTile();
                break;

            case Constants.WallChar:
                tile = new WallTile(position);
                break;

            case Constants.UnbreakableWallChar:
                tile = new UnbreakableWallTile(position);
                break;

            case Constants.QuestGiverChar:
                if (questGiverTileGenerated)
                {
                    x -= 1;
                    return;
                }
                tile = new QuestGiver(position);
                questGiverTileGenerated = true;
                break;
            }
            Map.MapTiles[y][x] = tile;
        }
示例#4
0
        public static void GenerateMap()
        {
            nextMapTileGenerated    = false;
            questGiverTileGenerated = false;
            Map.CreateMap();
            Map.MapTiles[1][1]      = Game.PlayerRef;
            Game.PlayerRef.Position = Constants.PlayerStartingPosition;
            for (int y = 1; y < Map.MapTiles.Length - 1; y++)
            {
                Map.MapTiles[y][0] = new UnbreakableWallTile(new Position(0, y));
                for (int x = 1; x < Map.MapTiles[y].Length - 2; x++)
                {
                    if (y == 1 && x == 1)
                    {
                        continue;
                    }
                    SetTile(ref x, y);
                }
                Map.MapTiles[y][Map.MapTiles[y].Length - 2] = new UnbreakableWallTile(new Position(y, Map.MapTiles[y].Length - 2));
                Map.MapTiles[y][Map.MapTiles[y].Length - 1] = new EmptyNewLineTile();
            }

            if (!nextMapTileGenerated)
            {
                int      y   = Map.MapTiles.Length - 2;
                int      x   = Map.MapTiles[0].Length - 3;
                Position pos = new Position(x, y);

                if (Map.MapTiles[y][x] is TreasureChestTile)
                {
                    TreasureChestTile chest = TreasureChestTile.TreasureChests.Find(treasure => treasure.ChestRight == pos);
                    if (chest != null)
                    {
                        Map.MapTiles[y][chest.ChestLeft.X]  = new EmptySpaceTile();
                        Map.MapTiles[y][chest.ChestRight.X] = new NextLevelTile(pos);
                        TreasureChestTile.TreasureChests.Remove(chest);
                    }
                }
                else if (Map.MapTiles[y][x] is AbstractMonster)
                {
                    AbstractMonster enemy = AbstractMonster.Monsters.Find(monster => monster.Position.X == x);
                    if (enemy != null)
                    {
                        Map.MapTiles[y][x] = new NextLevelTile(pos);
                        AbstractMonster.Monsters.Remove(enemy);
                    }
                }
                else if (Map.MapTiles[y][x] is BonusLifeTile)
                {
                    BonusLifeTile bonus = BonusLifeTile.Bonuses.Find(b => b.Position == pos);
                    if (bonus != null)
                    {
                        Map.MapTiles[y][x] = new NextLevelTile(pos);

                        BonusLifeTile.Bonuses.Remove(bonus);
                    }
                }
                else
                {
                    Map.MapTiles[y][x] = new NextLevelTile(pos);
                }
            }
            MonsterController.Start();
        }