Example #1
0
        public bool StartStage(Player player, List <Monster> monsters, MonsterRepository instanceofmonster, List <Item> items, List <Dialogue> allDialogue)
        {
            var dialogue  = allDialogue;
            var Dialogues = new DialogueRepository();

            allDialogue = Dialogues.ShowDialogue("Transition", allDialogue, Utils.random);


            var monster = instanceofmonster.MonsterChoosen(monsters, Utils.random);
            var battle  = new Battle();
            var win     = battle.BattleResult(player, monster);

            Utils.SlowConsoleWriter(win ? "vous avez gagné !!" : "Vous avez perdu ... ");

            if (win)
            {
                var lootphase     = new Lootphase();
                var itemlootphase = lootphase.DroppedItems(items, Utils.random);
                player.Item = itemlootphase;
                return(true);
            }
            else
            {
                return(false);
            }
        }
        public async Task GetMonster_WhenRepositoryHasMonsters_ShouldReturnMonsterAsModelObject()
        {
            // Setup
            var id1      = Guid.NewGuid();
            var id2      = Guid.NewGuid();
            var expected = new Monster("awake 2", "name 2", 3, Element.Wind, "awakenedimg2", "img2", null, null, null, null, null)
            {
                Id = id2
            };
            var monsters = new Monster[]
            {
                new Monster("awake 1", "name 1", 3, Element.Light, "awakenedimg", "img", null, null, null, null, null)
                {
                    Id = id1
                },
                expected
            };

            fixture = new MonsterRepository(monsters);

            // Execute
            var actual = await fixture.GetMonster(id2);

            // Verify
            actual.Should().BeEquivalentTo(expected);
        }
        public void ProcessContent(IContentPersister persister)
        {
            using (var db = new GameDatabaseContext())
            {
                var repo = new MonsterRepository(db);
                var monsters = repo.GetAll();

                foreach (var monster in monsters)
                {

                    // Save out properties we want to a new object and then persist
                    dynamic persistable = new ExpandoObject();

                    Console.WriteLine("Processing monster with ID {0}", monster.Id);

                    persistable.id = monster.Id;
                    persistable.name = monster.Name;
                    persistable.maxHp = monster.Hitpoints;
                    persistable.category = monster.VirtualCategory;
                    persistable.sprite = monster.Sprite;

                    persister.Persist(persistable, "\\monsters\\{0}.json".FormatWith(monster.Id));

                }

            }
        }
Example #4
0
        public BusinessLayerTests()
        {
            var options = SqliteInMemory.CreateOptions <ApplicationContext>();

            context = new ApplicationContext(options);
            context.Database.EnsureCreated();

            // Seed Inventory content
            context.SeedItemTypes();
            context.SeedItemImages();


            // Seed Monster content
            context.SeedMonsterModels();
            context.SeedMonsterNames();
            context.SeedMonsterTitles();


            inventoryRepository = new InventoryRepository(context);
            inventoryService    = new InventoryService(inventoryRepository);

            playerRepository = new PlayerRepository(context);
            playerService    = new PlayerService(playerRepository);

            monsterRepository = new MonsterRepository(context);
            monsterService    = new MonsterService(monsterRepository);

            knightRepository   = new KnightRepository(context);
            landmarkRepository = new LandmarkRepository(context);
            landmarkService    = new LandmarkService(landmarkRepository, knightRepository);
        }
Example #5
0
        public Game()
        {
            if (_monsterRepository == null)
            {
                _monsterRepository = new MonsterRepository();
            }

            _channelId = Settings.GetDiscordChannelId();
        }
Example #6
0
 public UnitOfWork()
 {
     Items     = new ItemRepository();
     Merchants = new MerchantRepository();
     Monsters  = new MonsterRepository();
     Routes    = new RouteRepository();
     Towns     = new TownRepository();
     Elements  = new ElementRepository();
 }
 public SbuDataInitializer(SbuDbContext dbContext,
                           MonsterRepository monsterRepository,
                           UserRepository userRepository,
                           MonsterMapper monsterMapper)
 {
     _dbContext         = dbContext;
     _monsterRepository = monsterRepository;
     _userRepository    = userRepository;
     _monsterMapper     = monsterMapper;
 }
 public CollectionController(
     UserRepository userRepository,
     UserMapper userMapper,
     MonsterRepository monsterRepository
     )
 {
     _userRepository    = userRepository;
     _userMapper        = userMapper;
     _monsterRepository = monsterRepository;
 }
        protected override void Save()
        {
            using (var db = new GameDatabaseContext())
            {
                var ContentTemplate = this.ContentTemplate as MonsterTemplate;
                var repository = new MonsterRepository(db);
                repository.Update(ContentTemplate, ContentTemplate.Id);
            }

            base.Save();
        }
Example #10
0
        public async Task <bool> CheckIfAdmin(SocketMessage message)
        {
            var monsterRepository = new MonsterRepository(Settings.GetConnectionString("database"), Settings.GetDatabaseSchemaName());
            var player            = await monsterRepository.GetPlayer(message.Author.ToString());

            if (player == null)
            {
                player = await monsterRepository.CreatePlayer(message.Author.ToString());
            }

            return(player.IsAdmin);
        }
        public async Task <ActionResult> Index([FromQuery] string discordId)
        {
            var monsterRepository = new MonsterRepository(Settings.GetConnectionString("Database"), Settings.GetDatabaseSchemaName());
            var player            = await monsterRepository.GetPlayer(discordId);

            var homeModel = new HomeModel
            {
                Player            = player,
                PlayerMonsterList = await monsterRepository.GetList(player)
            };

            return(View(homeModel));
        }
        public async Task GetMonsters_WhenRepositoryIsEmpty_ShouldReturnEmptyListOfMonsters()
        {
            // Setup
            var monsters = Enumerable.Empty <Monster>();
            var expected = Enumerable.Empty <Monster>();

            fixture = new MonsterRepository(monsters);

            // Execute
            var actual = await fixture.GetMonsters();

            // Verify
            actual.Should().BeEquivalentTo(expected);
        }
        public async Task GetMonster_WhenRepositoryIsEmpty_ShouldReturnNull()
        {
            // Setup
            var     monsters = Enumerable.Empty <Monster>();
            Monster expected = null;

            fixture = new MonsterRepository(monsters);

            // Execute
            var actual = await fixture.GetMonster(Guid.NewGuid());

            // Verify
            actual.Should().BeEquivalentTo(expected);
        }
Example #14
0
        private Location GetForest(Position position)
        {
            var loc = new Location("The Forest", position);

            var repo = new MonsterRepository();

            loc.Entities.Add(repo.Get(123, loc));

            loc.Neighbours.Add(Position.FromString("001001001001"));
            loc.Neighbours.Add(Position.FromString("001001001004"));

            loc.ImageUrl = "forest.png";

            return(loc);
        }
Example #15
0
        public async Task GetMonsterAppearTimer(SocketMessage message)
        {
            var monsterRepository = new MonsterRepository(Settings.GetConnectionString("database"), Settings.GetDatabaseSchemaName());
            var player            = await monsterRepository.GetPlayer(message.Author.ToString());

            if (player == null)
            {
                player = await monsterRepository.CreatePlayer(message.Author.ToString());
            }

            if (player.IsAdmin)
            {
                await message.Channel.SendMessageAsync($"The next Discord monster will appear in {MonsterAppearTimer} minutes.");
            }
        }
        public async Task AddMonster_WhenRepositoryIsEmptyAndNewMonsterLacksId_ShouldAddMonsterAndReturnIt()
        {
            // Setup
            var monsters   = Enumerable.Empty <Monster>();
            var expected   = new Monster("awake 1", "name 1", 3, Element.Fire, "awakenedimg", "img", null, null, null, null, null);
            var originalId = expected.Id;

            fixture = new MonsterRepository(monsters);

            // Execute
            var actual = await fixture.AddMonster(expected);

            // Verify
            actual.Should().BeEquivalentTo(expected, options => options.Excluding(monster => monster.Id));
            actual.Id.Should().NotBe(originalId);
        }
Example #17
0
        private Location GetCave(Position position)
        {
            var loc = new Location("The Cave", position);

            var repo = new MonsterRepository();

            loc.Entities.Add(repo.Get(123, loc));
            loc.Entities.Add(repo.Get(124, loc));

            loc.Neighbours.Add(Position.FromString("001001001002"));
            loc.Neighbours.Add(Position.FromString("001001001003"));

            loc.ImageUrl = "cave.png";

            return(loc);
        }
Example #18
0
        public async Task GetMonsterList(SocketMessage message)
        {
            var monsterRepository = new MonsterRepository(Settings.GetConnectionString("database"), Settings.GetDatabaseSchemaName());
            var player            = await monsterRepository.GetPlayer(message.Author.ToString());

            if (player == null)
            {
                player = await monsterRepository.CreatePlayer(message.Author.ToString());
            }

            var list = await monsterRepository.GetList(player);

            if (!list.Any())
            {
                await message.Channel.SendMessageAsync($"{message.Author.ToString()} does not currently have any Discord monsters");

                return;
            }

            var discordMonsterList = $"List of Monsters for {message.Author.ToString()}\n";

            foreach (var item in list)
            {
                discordMonsterList += $"{item.monster.Name} (Level: {item.playerCatch.Level})\n";
            }

            var sendString = new List <string>();

            if (discordMonsterList.Length > 2000)
            {
                if (Settings.WebInterfaceEnabled())
                {
                    return;
                }
                var url = GetPlayerWebUrl(message.Author.ToString());
                discordMonsterList = $"Monster list is to large, view at the link here \n {url}";
            }

            if (message.Content.ToLower().Contains(":public"))
            {
                await message.Channel.SendMessageAsync(discordMonsterList);
            }
            else
            {
                await message.Author.SendMessageAsync(discordMonsterList);
            }
        }
        public async Task AddMonster_WhenRepositoryIsEmptyAndNewMonsterHasExistingId_ShouldAddMonsterWithIdAndReturnIt()
        {
            // Setup
            var monsters = Enumerable.Empty <Monster>();
            var expected = new Monster("awake 1", "name 1", 3, Element.Wind, "awakenedimg", "img", null, null, null, null, null)
            {
                Id = Guid.Parse("2e846d8d-a45d-4548-9240-e2ed7fa91e3c")
            };

            fixture = new MonsterRepository(monsters);

            // Execute
            var actual = await fixture.AddMonster(expected);

            // Verify
            actual.Should().BeEquivalentTo(expected);
        }
Example #20
0
        private static Location GetGrass(Position position)
        {
            var loc = new Location("The Grass", position);

            loc.Seeds.Add(Seed.Monster(123));

            var repo = new MonsterRepository();

            loc.Entities.Add(repo.Get(123, loc));

            loc.Neighbours.Add(Position.FromString("001001001001"));
            loc.Neighbours.Add(Position.FromString("001001001004"));

            loc.ImageUrl = "grass.png";

            return(loc);
        }
Example #21
0
        public async Task SayMessage(SocketMessage message, DiscordSocketClient client)
        {
            var monsterRepository = new MonsterRepository(Settings.GetConnectionString("database"), Settings.GetDatabaseSchemaName());
            var player            = await monsterRepository.GetPlayer(message.Author.ToString());

            if (player == null)
            {
                player = await monsterRepository.CreatePlayer(message.Author.ToString());
            }

            if (player.IsAdmin)
            {
                var whatToSay = message.Content.Remove(0, 10);
                var channel   = client.GetChannel(Settings.GetDiscordChannelId()) as SocketTextChannel;
                await channel.SendMessageAsync(whatToSay);
            }
        }
        public async Task GetMonsters_WhenRepositoryHasMonsters_ShouldReturnListOfMonstersAsModelObjects()
        {
            // Setup
            var monsters = new Monster[]
            {
                new Monster("awake 1", "name 1", 3, Element.Light, "awakenedimg", "img", null, null, null, null, null),
                new Monster("awake 2", "name 2", 3, Element.Water, "awakenedimg2", "img2", null, null, null, null, null)
            };
            var expected = monsters;

            fixture = new MonsterRepository(monsters);

            // Execute
            var actual = await fixture.GetMonsters();

            // Verify
            actual.Should().BeEquivalentTo(expected);
        }
        public async Task GetMonsterNames_WhenRepositoryHasMonsters_ShouldReturnListOfMonsterNamesAsStrings()
        {
            // Setup
            var monsters = new Monster[]
            {
                new Monster("awake 1", "name 1", 3, Element.Dark, "awakenedimg", "img", null, null, null, null, null),
                new Monster("awake 2", "name 2", 3, Element.Fire, "awakenedimg2", "img2", null, null, null, null, null),
            };
            var expected = new string[] { "Dark name 1", "awake 1", "Fire name 2", "awake 2" };

            fixture = new MonsterRepository(monsters);

            // Execute
            var actual = await fixture.GetMonsterNames();

            // Verify
            actual.Should().BeEquivalentTo(expected);
        }
        public async Task AddMonster_WhenRepositoryIsEmptyAndNewMonsterHasNumberZero_ShouldAddMonsterWithNumberAndReturnIt()
        {
            // Setup
            var monsters   = Enumerable.Empty <Monster>();
            var newMonster = new Monster("awake 1", "name 1", 3, Element.Wind, "awakenedimg", "img", null, null, null, null, null);
            var expected   = new Monster("awake 1", "name 1", 3, Element.Wind, "awakenedimg", "img", null, null, null, null, null)
            {
                Number = 1
            };

            fixture = new MonsterRepository(monsters);

            // Execute
            var actual = await fixture.AddMonster(newMonster);

            // Verify
            actual.Should().BeEquivalentTo(expected, options => options.Excluding(monster => monster.Id));
        }
Example #25
0
        public void StartGame()
        {
            var item  = new ItemRepository();
            var items = item.GetItems();

            var lootphase = new Lootphase();

            Console.WriteLine("Heuh j'ai affaire à qui la ?? (Entrez votre nom) :");
            var playerName = Console.ReadLine();

            var dialogue = new DialogueRepository();

            dialogue.ShowDialogue("Intro", dialogue.GetDialogue(), Utils.random);

            var playerItem = lootphase.DroppedItems(items, Utils.random);
            var player     = new Player(0, playerName, Utils.random.Next(25, 100), playerItem.IdItem, playerItem, Utils.random.Next(5, 25));
            var monster    = new MonsterRepository();
            var monsters   = monster.GetMonsters();
            var stage      = new Stage();
            var dialogues  = dialogue.GetDialogue();

            var resultstage = stage.StartStage(player, monsters, monster, items, dialogues);

            if (resultstage == true)
            {
                int i = 0;
                do
                {
                    resultstage = stage.StartStage(player, monsters, monster, items, dialogues);
                    i++;
                }while (resultstage == true && i < 4);
                if (resultstage == true)
                {
                    var  bossbattle       = new BossBattle();
                    var  enigma           = new EnigmaRepository();
                    var  ramdomEnigma     = new Enigma();
                    bool bossbatlleresult = bossbattle.BossBattleResult(player, monster.MonsterChoosen(monsters, Utils.random), enigma.GetEnigma());
                }
            }
            else
            {
                Console.WriteLine("Vous avez perdu !");
            }
        }
Example #26
0
        public async Task GetProfileString(SocketMessage message)
        {
            var monsterRepository = new MonsterRepository(Settings.GetConnectionString("database"), Settings.GetDatabaseSchemaName());
            var player            = await monsterRepository.GetPlayer(message.Author.ToString());

            if (player == null)
            {
                player = await monsterRepository.CreatePlayer(message.Author.ToString());
            }

            var sb = new StringBuilder();

            sb.Append("```" +
                      "User - " + player.DiscordId + "\n" +
                      "Level - " + player.Level + "\n" +
                      "Exp - " + player.Experience + "\n" +
                      "```");

            await message.Author.SendMessageAsync(sb.ToString());
        }
Example #27
0
        public async Task MonsterAppears(DiscordSocketClient client)
        {
            if (ActiveMonster != null)
            {
                var monsterInactivated = await MonsterInactivate(client);

                if (!monsterInactivated)
                {
                    return;
                }
            }

            if (MonsterAppearTimer > 0)
            {
                MonsterAppearTimer -= 1;
                return;
            }

            var monsterRepository = new MonsterRepository(Settings.GetConnectionString("database"), Settings.GetDatabaseSchemaName());
            var channel           = client.GetChannel(Settings.GetDiscordChannelId()) as SocketTextChannel;

            if (channel == null)
            {
                return;
            }

            var minAppearTime = Settings.GetMinMonsterAppearTime();
            var maxAppearTime = Settings.GetMaxMonsterAppearTime();
            var rnd           = new Random();

            ActiveMonster = await monsterRepository.GetRandomMonster();

            ActiveMonster.GenerateLevel();
            MonsterAppearTimer = rnd.Next(minAppearTime, maxAppearTime);
            ActiveMonsterTimer = Settings.GetMonsterActiveMaxTime();

            await channel.SendMessageAsync($"{ActiveMonster.ImageUrl}\n A wild lvl{ActiveMonster.Level} {ActiveMonster.Name} appears!");

            Console.WriteLine($"Spawned new monster {ActiveMonster.Name}");
        }
Example #28
0
        public async Task ClearMessages(SocketMessage message)
        {
            var monsterRepository = new MonsterRepository(Settings.GetConnectionString("database"), Settings.GetDatabaseSchemaName());
            var player            = await monsterRepository.GetPlayer(message.Author.ToString());

            if (player == null)
            {
                player = await monsterRepository.CreatePlayer(message.Author.ToString());
            }

            if (player.IsAdmin)
            {
                var messages = await message.Channel.GetMessagesAsync(1000).FlattenAsync();

                await((ITextChannel)message.Channel).DeleteMessagesAsync(messages);
                const int delay = 3000;
                await Task.Delay(delay);

                await message.DeleteAsync();

                await message.Channel.SendMessageAsync($"Admin {message.Author.ToString()} has cleared the chat.");
            }
        }
        public async Task AddMonster_WhenRepositoryHasExactMonster_ShouldJustReturnExistingMonster()
        {
            // Setup
            var existingMonsterWithNewValues = new Monster("new awake 1", "new name 1", 3, Element.Wind, "new awakenedimg1", "new img1", null, null, null, null, null)
            {
                Id = Guid.Parse("6beb6507-f68d-4d3d-8abf-0e04015c1119")
            };
            var expected = new Monster("awake 1", "name 1", 4, Element.Light, "awakenedimg", "img", null, null, null, null, null)
            {
                Id = Guid.Parse("6beb6507-f68d-4d3d-8abf-0e04015c1119")
            };
            var monsters = new Monster[]
            {
                expected
            };

            fixture = new MonsterRepository(monsters);

            // Execute
            var actual = await fixture.AddMonster(existingMonsterWithNewValues);

            // Verify
            actual.Should().BeEquivalentTo(expected);
        }
Example #30
0
        public async Task CatchMonster(SocketMessage message)
        {
            if (ActiveMonster == null)
            {
                await message.Channel.SendMessageAsync($"No active monster to catch. Try later.");

                return;
            }
            var monsterRepository = new MonsterRepository(Settings.GetConnectionString("database"), Settings.GetDatabaseSchemaName());
            var player            = await monsterRepository.GetPlayer(message.Author.ToString());

            if (player == null)
            {
                player = await monsterRepository.CreatePlayer(message.Author.ToString());
            }

            var catchSuccess = GetCatchSuccess(player);

            if (catchSuccess)
            {
                var catchImageUrl = Settings.GetCatchImageUrl();

                await message.Channel.SendMessageAsync($"{catchImageUrl} \n {player.DiscordId} caught the {ActiveMonster.Name}!");

                await monsterRepository.IncreasePlayerExperience(player, ActiveMonster.BaseExperienceAward *ActiveMonster.Level);

                await monsterRepository.AddPlayerCatch(player, ActiveMonster);

                Console.WriteLine($"New monster will spawn in {MonsterAppearTimer} minutes");
                ActiveMonster = null;
            }
            else
            {
                await message.Channel.SendMessageAsync($"{player.DiscordId} failed to catch the {ActiveMonster.Name}! GET RECKT!");
            }
        }
Example #31
0
 public MonsterParser(ILogger logger, ISerialization serialization, MonsterRepository monsterRepository)
 {
     this.logger            = logger;
     this.serialization     = serialization;
     this.monsterRepository = monsterRepository;
 }
Example #32
0
 public MonsterCommands(MonsterRepository monsterRepository) =>