public async Task <RuntimeResult> EditEffectAsync(string name, Statistic stat, int value) { var effect = (await _effectsService.GetAllOwnedEffectsAsync(Context.User.Id)).Find(x => x.Name.Equals(name)); if (effect == null) { return(GenericResult.FromError(Messages.ERR_EFFECT_NOT_FOUND)); } var match = effect.StatisticEffects.FirstOrDefault(x => x.Statistic.Equals(stat)); if (match != null) { if (value == 0) { effect.StatisticEffects.Remove(match); } else { match.Value = value; } } else { effect.StatisticEffects.Add(new StatisticValue { Statistic = stat, Value = value }); } await _effectsService.SaveEffectAsync(effect); return(GenericResult.FromSuccess(Messages.EFFECT_EDIT_SUCCESS)); }
public async Task <RuntimeResult> TagSkillsAsync(Skill tag1, Skill tag2, Skill tag3) { if (!_progOptions.UseOldProgression || !_progOptions.OldProgression.UseNewVegasRules) { return(StatisticResult.NotUsingNewVegasRules()); } var userInfo = Context.User; var character = await _charService.GetCharacterAsync(userInfo.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } if (_skillsService.AreSkillsSet(character)) { return(StatisticResult.SkillsAlreadyTagged()); } try { await _skillsService.TagSkills(character, tag1, tag2, tag3); return(GenericResult.FromSuccess(Messages.SKILLS_SET_SUCCESS)); } catch (Exception e) { return(GenericResult.FromError($"{Messages.FAILURE_EMOJI} {e.Message}")); } }
public async Task <RuntimeResult> ApplyEffectAsync(string npcName, [Remainder] string name) { var character = _npcService.FindNpc(npcName); if (character == null) { return(CharacterResult.NpcNotFound()); } var effect = await _effectsService.GetEffectAsync(name); if (effect == null) { return(GenericResult.FromError(Messages.ERR_EFFECT_NOT_FOUND)); } if (character.EffectCharacters == null) { character.EffectCharacters = new List <EffectCharacter>(); } if (character.EffectCharacters.Any(x => x.Effect.Equals(effect))) { return(GenericResult.FromError(Messages.ERR_EFFECT_ALREADY_APPLIED)); } character.EffectCharacters.Add(new EffectCharacter { Character = character, Effect = effect }); return(GenericResult.FromSuccess(String.Format(Messages.EFFECT_APPLY_SUCCESS, effect.Name, character.Name))); }
public async Task <RuntimeResult> ActivateCharacterAsync([Remainder] string name) { var chars = await _charService.GetAllCharactersAsync(Context.User.Id); if (chars == null) { return(CharacterResult.CharacterNotFound()); } //var charMatch = chars.Find(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); var charMatch = chars.Find(x => x.Name.Contains(name, StringComparison.OrdinalIgnoreCase)); if (charMatch == null) { return(CharacterResult.CharacterNotFound()); } if (charMatch.Active) { return(GenericResult.FromError(String.Format(Messages.ERR_CHAR_ALREADY_ACTIVE, charMatch.Name))); } foreach (var character in chars.FindAll(x => x.Active)) { character.Active = false; await _charService.SaveCharacterAsync(character); } charMatch.Active = true; await _charService.SaveCharacterAsync(charMatch); return(GenericResult.FromSuccess(String.Format(Messages.CHAR_ACTIVATED, charMatch.Name))); }
public async Task <RuntimeResult> RollDiceAsync(int dieCount, int sides, int bonus = 0) { if (dieCount > 20) { return(GenericResult.FromError(Messages.ROLL_DICE_TOO_MANY)); } if (sides > 100) { return(GenericResult.FromError(Messages.ROLL_DICE_TOO_MANY_SIDES)); } int[] dice = new int[dieCount]; int sum = 0; for (int die = 0; die < dieCount; die++) { int dieResult = _random.Next(1, sides + 1); dice[die] = dieResult; sum += dieResult; } StringBuilder sb = new StringBuilder(); for (int die = 0; die < dice.Length; die++) { sb.Append($"[{dice[die]}] + "); } sb.Append($"{bonus} = {dice.Sum() + bonus}"); return(await Task.FromResult(GenericResult.FromSuccess(String.Format(Messages.ROLL_DICE, sb.ToString())))); }
public async Task <RuntimeResult> ChangeCharacterNameAsync([Remainder] string name) { var character = await _charService.GetCharacterAsync(Context.User.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } if (!StringHelper.IsOnlyLetters(name)) { return(GenericResult.FromError("Name contained non-alphabetic characters.")); } if (name.Length > 24 || name.Length < 2) { return(GenericResult.FromError("Name was too long or short.")); } var fixedName = StringHelper.ToTitleCase(name); if (await _charService.HasDuplicateName(Context.User.Id, fixedName)) { return(GenericResult.FromError("Name is a duplicate.")); } character.Name = fixedName; await _charService.SaveCharacterAsync(character); return(GenericResult.FromSuccess(Messages.CHAR_CHANGED_NAME)); }
public async Task <RuntimeResult> SetSkillsAsync(Skill tag, int points) { if (ExperienceService.UseOldProgression) { return(StatisticResult.UsingOldProgression()); } var userInfo = Context.User; var character = await _charService.GetCharacterAsync(userInfo.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } if (_skillsService.AreSkillsSet(character)) { return(StatisticResult.SkillsAlreadyTagged()); } try { await _skillsService.TagSkill(character, tag, points); return(GenericResult.FromSuccess(Messages.SKILLS_SET_SUCCESS)); } catch (Exception e) { return(GenericResult.FromError($"{Messages.FAILURE_EMOJI} {e.Message}")); } }
public async Task <RuntimeResult> CreateEffectAsync([Remainder] string name) { if (!StringHelper.IsOnlyLetters(name)) { return(GenericResult.FromError(Messages.ERR_EFFECT_NOT_ALPHABETICAL)); } if (name.Length > 24) { return(GenericResult.FromError(Messages.ERR_EFFECT_NAME_TOO_LONG)); } if (await _effectsService.CountEffectsAsync(Context.User.Id) >= MAX_EFFECTS) { return(GenericResult.FromError(Messages.ERR_EFFECT_TOO_MANY)); } if (await _effectsService.IsDuplicateName(name)) { return(GenericResult.FromError(Messages.ERR_EFFECT_NAME_DUPLICATE)); } await _effectsService.CreateEffectAsync(name, Context.User.Id); return(GenericResult.FromSuccess(Messages.EFFECT_CREATE_SUCCESS)); }
public async Task <RuntimeResult> RemoveEffectAsync(string npcName, [Remainder] string name) { var character = _npcService.FindNpc(npcName); if (character == null) { return(CharacterResult.NpcNotFound()); } var effect = await _effectsService.GetEffectAsync(name); if (effect == null) { return(GenericResult.FromError(Messages.ERR_EFFECT_NOT_FOUND)); } //if (character.Effects == null) character.Effects = new List<Effect>(); if (character.EffectCharacters == null) { character.EffectCharacters = new List <EffectCharacter>(); } character.EffectCharacters.Remove(character.EffectCharacters.Where(x => x.Effect.Equals(effect)).FirstOrDefault()); return(GenericResult.FromSuccess(String.Format(Messages.EFFECT_REMOVE_SUCCESS, effect.Name, character.Name))); }
public async Task <RuntimeResult> SetStatisticFlagAsync(Statistic stat, Globals.StatisticFlag flag) { stat.StatisticFlag = flag; await _statService.SaveStatisticAsync(stat); return(GenericResult.FromSuccess("Flag set successfully.")); }
public async Task <RuntimeResult> SetStatDescriptionAsync(Statistic stat, string desc) { stat.Description = desc; await _statService.SaveStatisticAsync(stat); return(GenericResult.FromSuccess("Description set successfully.")); }
public async Task <RuntimeResult> ClearAliasesAsync(Statistic stat, string alias) { stat.Aliases = stat.Name + "/"; await _statService.SaveStatisticAsync(stat); return(GenericResult.FromSuccess("Aliases cleared successfully.")); }
public async Task <RuntimeResult> SetSkillMinimumAsync(Skill skill, int min) { skill.MinimumValue = min; await _statService.SaveStatisticAsync(skill); return(GenericResult.FromSuccess("Minimum set successfully.")); }
public async Task <RuntimeResult> AddAliasAsync(Statistic stat, string alias) { if (_statService.NameOrAliasExists(alias)) { return(StatisticResult.StatisticAlreadyExists()); } stat.Aliases += alias + "/"; await _statService.SaveStatisticAsync(stat); return(GenericResult.FromSuccess("Alias added successfully.")); }
public async Task <RuntimeResult> DeleteCharacterAsync(IUser user) { var character = await _charService.GetCharacterAsync(user.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } await _charService.DeleteCharacterAsync(character); return(GenericResult.FromSuccess(Messages.ADM_DELETE)); }
public async Task <RuntimeResult> DeleteEffectAsync([Remainder] string name) { var effect = (await _effectsService.GetAllOwnedEffectsAsync(Context.User.Id)).Find(x => x.Name.Equals(name)); if (effect == null) { return(GenericResult.FromError(Messages.ERR_EFFECT_NOT_FOUND)); } await _effectsService.DeleteEffectAsync(effect); return(GenericResult.FromSuccess(Messages.EFFECT_DELETE_SUCCESS)); }
public async Task <RuntimeResult> TogglePresetAsync(string name) { var preset = await _presetService.GetNpcPreset(name); if (preset == null) { return(GenericResult.FromError(String.Format(Messages.ERR_NPC_PRESET_NOT_FOUND))); } preset.Enabled = !preset.Enabled; await _presetService.SaveNpcPreset(preset); return(GenericResult.FromSuccess(String.Format(Messages.NPC_PRESET_TOGGLE, preset.Name, preset.Enabled))); }
public async Task <RuntimeResult> EditPresetStatisticAsync(string name, Statistic stat, int newValue) { var preset = await _presetService.GetNpcPreset(name); if (preset == null) { return(GenericResult.FromError(String.Format(Messages.ERR_NPC_PRESET_NOT_FOUND))); } _statsService.SetStatistic(preset.Statistics, stat, newValue); await _presetService.SaveNpcPreset(preset); return(GenericResult.FromSuccess(String.Format(Messages.NPC_PRESET_EDIT_SPECIAL, preset.Name))); }
public async Task <RuntimeResult> RenameStatAsync(Statistic stat, string newName) { if (_statService.NameExists(newName)) { return(StatisticResult.StatisticAlreadyExists()); } stat.Name = newName; stat.Aliases = newName + "/"; await _statService.SaveStatisticAsync(stat); return(GenericResult.FromSuccess("Statistic renamed successfully.")); }
public async Task <RuntimeResult> InitializeStatisticsAsync(IUser user) { var character = await _charService.GetCharacterAsync(user.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } _statService.InitializeStatistics(character.Statistics); await _charService.SaveCharacterAsync(character); return(GenericResult.FromSuccess("Character stats initialized successfully.")); }
public async Task <RuntimeResult> CreateCharacterAsync([Remainder] string name) { var userInfo = Context.User; try { await _charService.CreateCharacterAsync(userInfo.Id, name); return(GenericResult.FromSuccess(Messages.CHAR_CREATED_SUCCESS)); } catch (Exception e) { return(GenericResult.FromError(e.Message)); } }
public async Task <RuntimeResult> CreatePresetAsync(string name) { try { await _presetService.CreateNpcPresetAsync(name); return(GenericResult.FromSuccess(String.Format(Messages.NPC_PRESET_CREATE, name))); } catch (Exception e) { return(GenericResult.FromError(e.Message)); throw; } }
public async Task <RuntimeResult> GiveSkillPointsAsync(IUser user, int points) { var character = await _charService.GetCharacterAsync(user.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } character.ExperiencePoints += points; await _charService.SaveCharacterAsync(character); return(GenericResult.FromSuccess(Messages.ADM_GAVE_SKILL_POINTS)); }
public async Task <RuntimeResult> GiveMoneyAsync(IUser user, int money) { var character = await _charService.GetCharacterAsync(user.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } character.Money += money; await _charService.SaveCharacterAsync(character); return(GenericResult.FromSuccess(Messages.ADM_GAVE_MONEY)); }
public async Task <RuntimeResult> UpdateCharacterStoryAsync([Remainder] string story) { var userInfo = Context.User; var character = await _charService.GetCharacterAsync(userInfo.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } character.Story = story; await _charService.SaveCharacterAsync(character); return(GenericResult.FromSuccess(Messages.CHAR_STORY_SUCCESS)); }
public async Task <RuntimeResult> UpdateCharacterDescriptionAsync([Remainder] string description) { var userInfo = Context.User; var character = await _charService.GetCharacterAsync(userInfo.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } character.Description = description; await _charService.SaveCharacterAsync(character); return(GenericResult.FromSuccess(Messages.CHAR_DESC_SUCCESS)); }
public async Task <RuntimeResult> AddSpecialAsync(string name) { if (_statService.NameExists(name)) { return(StatisticResult.StatisticAlreadyExists()); } var newSpecial = new Special { Name = name, Aliases = name + "/" }; await _statService.AddStatisticAsync(newSpecial); return(GenericResult.FromSuccess(Messages.SPECIAL_ADDED)); }
public async Task <RuntimeResult> SpendSkillPointsAsync(Skill skill, int points) { if (!ExperienceService.UseOldProgression) { return(StatisticResult.NotUsingOldProgression()); } var userInfo = Context.User; var character = await _charService.GetCharacterAsync(userInfo.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } if (!_skillsService.AreSkillsSet(character)) { return(StatisticResult.SkillsNotSet()); } if (points < 1) { return(GenericResult.FromError(Messages.ERR_SKILLS_POINTS_BELOW_ONE)); } if (points > character.ExperiencePoints) { return(GenericResult.FromError(Exceptions.CHAR_NOT_ENOUGH_SKILL_POINTS)); } var skillVal = _statsService.GetStatistic(character, skill); if ((skillVal + points) > _roleplayOptions.SkillMax) { return(GenericResult.FromError(Exceptions.CHAR_SKILL_POINTS_GOES_OVER_MAX)); } _statsService.SetStatistic(character, skill, skillVal + points); character.ExperiencePoints -= points; await _charService.SaveCharacterAsync(character); return(GenericResult.FromSuccess(Messages.SKILLS_SPEND_POINTS_SUCCESS)); }
public async Task <RuntimeResult> CreateNewNpcAsync(string name, string type) { try { var preset = await _presetService.GetNpcPreset(type); if (preset == null) { return(GenericResult.FromError(Messages.ERR_NPC_PRESET_NOT_FOUND)); } _npcService.CreateNpc(name, preset); return(GenericResult.FromSuccess(String.Format(Messages.NPC_CREATED_SUCCESS, type, name))); } catch (Exception e) { return(GenericResult.FromError(e.Message)); } }
public async Task <RuntimeResult> ClaimSkillPointsAsync() { if (!ExperienceService.UseOldProgression) { return(StatisticResult.NotUsingOldProgression()); } var userInfo = Context.User; var character = await _charService.GetCharacterAsync(userInfo.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } if (!character.IsReset) { return(GenericResult.FromError(Messages.ERR_SKILLS_NONE_TO_CLAIM)); } if (!_specService.IsSpecialSet(character)) { return(StatisticResult.SpecialNotSet()); } if (!_skillsService.AreSkillsSet(character)) { return(StatisticResult.SkillsNotSet()); } _statsService.InitializeStatistics(character.Statistics); character.ExperiencePoints = 0; var intelligence = _statsService.GetStatistic(character, Globals.StatisticFlag.Intelligence); for (int level = 1; level <= character.Level; level++) { character.ExperiencePoints += _expService.CalculateSkillPoints(level, intelligence); } character.IsReset = false; await _charService.SaveCharacterAsync(character); return(GenericResult.FromSuccess(string.Format(Messages.SKILLS_POINTS_CLAIMED, character.ExperiencePoints))); }