public void RollMonsterSpawn() { var random = new Random(); if (random.NextDouble() >= SpawnChance) { return; } var channel = PvpChannel; if (random.Next(2) == 0) { channel = PickRandomChannel(random, _channelRepository).Id; } var monster = _monsterFactory.CreateRandomMonster(random); var monstersInChannel = _monsterRepository.GetMonsters(channel); if (monstersInChannel.Count(monsta => monsta.MonsterId == monster.Id) >= MaximumMonsterTypeInChannel) { return; } _monsterRepository.SpawnMonster(monster, channel); _slack.BroadcastMessage(string.Format(DougMessages.MonsterSpawned, monster.Name), channel).Wait(); }
public DougResponse Give(Command command) { var amount = int.Parse(command.GetArgumentAt(1)); if (amount <= 0) { return(new DougResponse(DougMessages.InvalidAmount)); } if (!command.IsUserArgument()) { return(new DougResponse(DougMessages.InvalidUserArgument)); } var user = _userRepository.GetUser(command.UserId); var target = _userRepository.GetUser(command.GetTargetUserId()); if (!user.HasEnoughCreditsForAmount(amount)) { return(new DougResponse(user.NotEnoughCreditsForAmountResponse(amount))); } _userRepository.RemoveCredits(user.Id, amount); _userRepository.AddCredits(target.Id, amount); var message = string.Format(DougMessages.UserGaveCredits, _userService.Mention(user), amount, _userService.Mention(target)); _slack.BroadcastMessage(message, command.ChannelId); return(NoResponse); }
public async Task <DougResponse> Steal(User user, User target, string channel) { if (user.IsStealOnCooldown()) { return(new DougResponse(string.Format(DougMessages.CommandOnCooldown, user.CalculateStealCooldownRemaining()))); } var channelType = _channelRepository.GetChannelType(channel); if (channelType != ChannelType.Common && channelType != ChannelType.Pvp) { return(new DougResponse(DougMessages.NotInRightChannel)); } var usersInChannel = await _slack.GetUsersInChannel(channel); if (usersInChannel.All(usr => usr != target.Id)) { return(new DougResponse(DougMessages.UserIsNotInPvp)); } var energy = user.Energy - StealEnergyCost; if (energy < 0) { return(new DougResponse(DougMessages.NotEnoughEnergy)); } _statsRepository.UpdateEnergy(user.Id, energy); _userRepository.SetStealCooldown(user.Id, user.GetStealCooldown()); var userChance = _eventDispatcher.OnStealingChance(user, user.BaseStealSuccessRate()); var targetChance = _eventDispatcher.OnGettingStolenChance(target, target.BaseOpponentStealSuccessRate()); var rollSuccessful = _randomService.RollAgainstOpponent(userChance, targetChance); var amount = _eventDispatcher.OnStealingAmount(user, user.BaseStealAmount()); if (target.Credits - amount < 0) { amount = target.Credits; } if (rollSuccessful) { _userRepository.RemoveCredits(target.Id, amount); _userRepository.AddCredits(user.Id, amount); var message = string.Format(DougMessages.StealCredits, _userService.Mention(user), amount, _userService.Mention(target)); await _slack.BroadcastMessage(message, channel); } else { var message = string.Format(DougMessages.StealFail, _userService.Mention(user), _userService.Mention(target)); await _slack.BroadcastMessage(message, channel); } return(new DougResponse()); }
private void JoinUser(string userId, string channelId) { _coffeeRepository.AddToRoster(userId); _userRepository.AddUser(userId); string text = string.Format(DougMessages.JoinedCoffee, Utils.UserMention(userId)); _slack.BroadcastMessage(text, channelId); }
public async Task RemoveHealth(User user, int health, string channel) { user.Health -= health; if (user.Health <= 0) { await _slack.BroadcastMessage(string.Format(DougMessages.UserDied, Utils.UserMention(user.Id)), channel); } _statsRepository.UpdateHealth(user.Id, user.Health); }
private async Task DealDamageToUser(User user, Attack attack, User target, string channel) { var message = attack.Status.ToMessage(_userService.Mention(user), _userService.Mention(target), attack.Damage); await _slack.BroadcastMessage(message, channel); if (target.IsDead() && await _userService.HandleDeath(target, channel)) { _eventDispatcher.OnDeathByUser(target, user); await _userService.AddExperience(user, KillExperienceGain, channel); } _statsRepository.UpdateHealth(target.Id, target.Health); }
public DougResponse Give(Command command) { var target = _userRepository.GetUser(command.GetTargetUserId()); var user = _userRepository.GetUser(command.UserId); var position = int.Parse(command.GetArgumentAt(1)); var inventoryItem = user.InventoryItems.SingleOrDefault(itm => itm.InventoryPosition == position); if (inventoryItem == null) { return(new DougResponse(string.Format(DougMessages.NoItemInSlot, position))); } if (!inventoryItem.Item.IsTradable) { return(new DougResponse(DougMessages.ItemNotTradable)); } _inventoryRepository.RemoveItem(user, position); _inventoryRepository.AddItem(target, inventoryItem.Item); var message = string.Format(DougMessages.UserGaveItem, _userService.Mention(user), inventoryItem.Item.Name, _userService.Mention(target)); _slack.BroadcastMessage(message, command.ChannelId); return(new DougResponse()); }
public async Task <bool> HandleDeath(User user, string channel) { if (!_eventDispatcher.OnDeath(user)) { return(false); } _statsRepository.KillUser(user.Id); _effectRepository.AddEffect(user, MortuaryGrace.EffectId, 15); await _slack.BroadcastMessage(string.Format(DougMessages.UserDied, Mention(user)), channel); await _slack.KickUser(user.Id, channel); return(true); }
public override DougResponse Activate(User user, ICombatable target, string channel) { if (!CanActivateSkill(user, out var response)) { return(response); } var userToBeHealed = user; if (target != null && target is User targetUser) { userToBeHealed = targetUser; } var healAmount = 30; // TODO : add scaling userToBeHealed.Health += healAmount; StatsRepository.UpdateHealth(userToBeHealed.Id, userToBeHealed.Health); var message = string.Format(DougMessages.UserHealed, _userService.Mention(user), _userService.Mention(userToBeHealed), healAmount); _slack.BroadcastMessage(message, channel); return(new DougResponse()); }
public void RollMonsterSpawn() { var channel = PickRandomRegion(_channelRepository); var monsterIds = channel.Monsters.Select(mons => mons.MonsterId).ToList().OrderBy(mons => Guid.NewGuid()); var monstersInChannel = _spawnedMonsterRepository.GetMonsters(channel.Id).ToList(); foreach (var monsterId in monsterIds) { if (monstersInChannel.Count(monsta => monsta.MonsterId == monsterId) < MaximumMonsterTypeInChannel) { var monster = _monsterRepository.GetMonster(monsterId); _spawnedMonsterRepository.SpawnMonster(monster, channel.Id); _slack.BroadcastMessage(string.Format(DougMessages.MonsterSpawned, monster.Name), channel.Id).Wait(); return; } } }
public override string OnGettingFlamed(Command command, string slur) { _slack.BroadcastMessage(string.Format(DougMessages.Surrendered, _userService.Mention(new User { Id = command.GetTargetUserId() })), command.ChannelId); return(base.OnGettingFlamed(command, slur)); }
public async Task <DougResponse> StartRevolutionVote(User leader, string channel) { var government = _governmentRepository.GetGovernment(); if (government.IsInRevolutionCooldown()) { return(new DougResponse(string.Format(DougMessages.RevolutionCooldown, government.CalculateRevolutionCooldown()))); } var timestamp = await _slack.BroadcastMessage(string.Format(DougMessages.RevolutionVote, _userService.Mention(leader)), channel); await _slack.AddReaction(DougMessages.UpVote, timestamp, channel); await _slack.AddReaction(DougMessages.Downvote, timestamp, channel); _governmentRepository.StartRevolutionVote(leader.Id, timestamp); return(new DougResponse()); }
public DougResponse Steal(Command command) { var user = _userRepository.GetUser(command.UserId); var target = _userRepository.GetUser(command.GetTargetUserId()); var energy = user.Energy - StealEnergyCost; if (energy < 0) { return(new DougResponse(DougMessages.NotEnoughEnergy)); } _statsRepository.UpdateEnergy(command.UserId, energy); var userChance = _itemEventDispatcher.OnStealingChance(user, user.BaseStealSuccessRate()); var targetChance = _itemEventDispatcher.OnGettingStolenChance(target, target.BaseOpponentStealSuccessRate()); var rollSuccessful = _randomService.RollAgainstOpponent(userChance, targetChance); var amount = _itemEventDispatcher.OnStealingAmount(user, user.BaseStealAmount()); if (target.Credits - amount < 0) { return(new DougResponse(DougMessages.TargetNoMoney)); } if (rollSuccessful) { _userRepository.RemoveCredits(target.Id, amount); _userRepository.AddCredits(command.UserId, amount); var message = string.Format(DougMessages.StealCredits, Utils.UserMention(command.UserId), amount, Utils.UserMention(target.Id)); _slack.BroadcastMessage(message, command.ChannelId); } else { var message = string.Format(DougMessages.StealFail, Utils.UserMention(command.UserId), Utils.UserMention(target.Id)); _slack.BroadcastMessage(message, command.ChannelId); } return(NoResponse); }
public void CoffeeRemind(string channelId) { var readyParticipants = _coffeeRepository.GetReadyParticipants(); var missingParticipants = _coffeeRepository.GetMissingParticipants(); var total = missingParticipants.Count + readyParticipants.Count; var userMentionList = missingParticipants .Select(_userService.Mention) .Aggregate(string.Empty, (userId, acc) => acc + " " + userId); var message = DougMessages.Remind; if (readyParticipants.Count == 6 && total == 9) { message = DougMessages.Remind69; } _slack.BroadcastMessage(string.Format(message, readyParticipants.Count, total, userMentionList), channelId); }
public string OpenLootBox(int itemPos, User user, DropTable dropTable, string channel, string lootboxName) { _inventoryRepository.RemoveItem(user, itemPos); var loot = _randomService.RandomFromWeightedTable(dropTable); var item = _itemRepository.GetItem(loot.Id); _inventoryRepository.AddItems(user, Enumerable.Repeat(item, loot.Quantity)); user.InventoryItems.Sort((item1, item2) => item1.InventoryPosition.CompareTo(item2.InventoryPosition)); _slack.BroadcastMessage(string.Format(DougMessages.LootboxAnnouncement, _userService.Mention(user), lootboxName, $"{loot.Quantity}x {item.GetDisplayName()}"), channel).Wait(); return(string.Empty); }
public void EndLottery() { var users = _userRepository.GetUsers(); var winner = _randomService.DrawLotteryWinner(users); _userRepository.ClearTickets(); _inventoryRepository.AddItem(winner, new Item { Id = "lottery_box" }); _slack.BroadcastMessage(string.Format(DougMessages.LotteryWinner, _userService.Mention(winner)), General); }
public string Give(User user, User target, int itemPosition, string channel) { var inventoryItem = user.InventoryItems.SingleOrDefault(itm => itm.InventoryPosition == itemPosition); if (inventoryItem == null) { return(string.Format(DougMessages.NoItemInSlot, itemPosition)); } if (!inventoryItem.Item.IsTradable) { return(DougMessages.ItemNotTradable); } _inventoryRepository.RemoveItem(user, itemPosition); _inventoryRepository.AddItem(target, inventoryItem.Item); var message = string.Format(DougMessages.UserGaveItem, _userService.Mention(user), inventoryItem.Item.GetDisplayName(), _userService.Mention(target)); _slack.BroadcastMessage(message, channel); return(string.Empty); }
public override string Target(int itemPos, User user, User target, string channel) { base.Use(itemPos, user, channel); if (!_eventDispatcher.OnKick(target, user, channel)) { return(string.Empty); } _slack.KickUser(target.Id, channel).Wait(); _slack.BroadcastMessage(string.Format(DougMessages.UsedItemOnTarget, _userService.Mention(user), Name, _userService.Mention(target)), channel); return(string.Empty); }
public override string Use(int itemPos, User user, string channel) { base.Use(itemPos, user, channel); var loot = _randomService.RandomFromWeightedTable(_dropTable); var item = _itemFactory.CreateItem(loot.Id); _inventoryRepository.AddItems(user, Enumerable.Repeat(item, loot.Quantity)); user.LoadItems(_itemFactory); user.InventoryItems.Sort((item1, item2) => item1.InventoryPosition.CompareTo(item2.InventoryPosition)); _slack.BroadcastMessage(string.Format(DougMessages.LootboxAnnouncement, _userService.Mention(user), Name, $"{loot.Quantity}x *{item.Name}*"), channel).Wait(); return(string.Empty); }
public override async Task <DougResponse> Activate(User user, ICombatable target, string channel) { if (!CanActivateSkill(user, out var response)) { return(response); } var message = string.Format(DougMessages.UserActivatedSkill, _userService.Mention(user), Name); await _slack.BroadcastMessage(message, channel); var attack = new MagicAttack(user, user.TotalIntelligence()); target.ReceiveAttack(attack, _eventDispatcher); await _combatService.DealDamage(user, attack, target, channel); return(new DougResponse()); }
public override async Task <DougResponse> Activate(User user, ICombatable target, string channel) { if (!CanActivateSkill(user, target, channel, out var response)) { return(response); } var message = string.Format(DougMessages.UserActivatedSkill, _userService.Mention(user), Name); await _slack.BroadcastMessage(message, channel); var damage = 5 * user.TotalAgility() + user.Level * 8; var attack = new PhysicalAttack(user, damage, int.MaxValue); target.ReceiveAttack(attack, _eventDispatcher); await _combatService.DealDamage(user, attack, target, channel); return(new DougResponse()); }
private async Task SendSlurToChannel(Command command, Slur slur) { var users = _userRepository.GetUsers(); var rnd = new Random(); var randomUser = users.ElementAt(rnd.Next(users.Count)).Id; var message = BuildSlurMessage(slur.Text, randomUser, command.GetTargetUserId()); message = _itemEventDispatcher.OnFlaming(command, message); var timestamp = await _slack.BroadcastMessage(message, command.ChannelId); _slurRepository.LogRecentSlur(slur.Id, timestamp); await _slack.AddReaction(DougMessages.UpVote, timestamp, command.ChannelId); await _slack.AddReaction(DougMessages.Downvote, timestamp, command.ChannelId); }
private async Task <DougResponse> StealFromUser(User user, User target, string channel) { _statsRepository.SetSkillCooldown(user.Id, TimeSpan.FromSeconds(Cooldown)); var userChance = _eventDispatcher.OnStealingChance(user, user.BaseStealSuccessRate()); var targetChance = _eventDispatcher.OnGettingStolenChance(target, target.BaseOpponentStealSuccessRate()); var rollSuccessful = _randomService.RollAgainstOpponent(userChance, targetChance); var detected = !_randomService.RollAgainstOpponent(user.BaseDetectionAvoidance(), target.BaseDetectionChance()); var amount = _eventDispatcher.OnStealingAmount(user, user.BaseStealAmount()); if (target.Credits - amount < 0) { amount = target.Credits; } string message; DougResponse sneakResponse; if (rollSuccessful) { _creditsRepository.RemoveCredits(target.Id, amount); _creditsRepository.AddCredits(user.Id, amount); message = string.Format(DougMessages.StealCreditsCaught, _userService.Mention(user), amount, _userService.Mention(target)); sneakResponse = new DougResponse(string.Format(DougMessages.StealCredits, amount, _userService.Mention(target))); } else { message = string.Format(DougMessages.StealFailCaught, _userService.Mention(user), _userService.Mention(target)); sneakResponse = new DougResponse(string.Format(DougMessages.StealFail, _userService.Mention(target))); } if (detected) { await _slack.BroadcastMessage(message, channel); } return(sneakResponse); }
public override async Task <DougResponse> Activate(User user, ICombatable target, string channel) { if (!CanActivateSkill(user, target, channel, out var response)) { return(response); } var userToBeBuffed = user; if (target != null && target is User targetUser) { userToBeBuffed = targetUser; } _effectRepository.AddEffect(userToBeBuffed, BuffId, Duration); var message = string.Format(DougMessages.UserBuffed, _userService.Mention(user), BuffName, _userService.Mention(userToBeBuffed), Duration); await _slack.BroadcastMessage(message, channel); return(new DougResponse()); }
public DougResponse Gamble(Command command) { var user = _userRepository.GetUser(command.UserId); var amount = int.Parse(command.GetArgumentAt(0)); if (amount < 0) { return(new DougResponse(DougMessages.InvalidAmount)); } if (!user.HasEnoughCreditsForAmount(amount)) { return(new DougResponse(user.NotEnoughCreditsForAmountResponse(amount))); } var cost = (int)Math.Ceiling(amount / 10.0); var energy = user.Energy - cost; if (energy < 0) { return(new DougResponse(DougMessages.NotEnoughEnergy)); } _statsRepository.UpdateEnergy(command.UserId, energy); string baseMessage; if (UserCoinFlipWin(user)) { baseMessage = DougMessages.WonGamble; _userRepository.AddCredits(command.UserId, amount); } else { baseMessage = DougMessages.LostGamble; _userRepository.RemoveCredits(command.UserId, amount); } var message = string.Format(baseMessage, _userService.Mention(user), amount); _slack.BroadcastMessage(message, command.ChannelId); return(NoResponse); }
public override async Task <DougResponse> Activate(User user, ICombatable target, string channel) { if (!CanActivateSkill(user, target, channel, out var response)) { return(response); } var userToBeHealed = user; if (target != null && target is User targetUser) { userToBeHealed = targetUser; } var healAmount = user.Level * 5 + 2 * user.TotalIntelligence(); userToBeHealed.Health += healAmount; StatsRepository.UpdateHealth(userToBeHealed.Id, userToBeHealed.Health); var message = string.Format(DougMessages.UserHealed, _userService.Mention(user), _userService.Mention(userToBeHealed), healAmount); await _slack.BroadcastMessage(message, channel); return(new DougResponse()); }