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());
}