/// <summary> /// Used to add an effect to a character. /// </summary> /// <param name="callerId">The user identifier of the caller.</param> /// <param name="effectName">The name of the effect to add to the character.</param> public async Task <IResult> AddEffectAsync(ulong callerId, string effectName) { var character = await _charProvider.GetActiveCharacterAsync(callerId); if (character == null) { return(CharacterResult.CharacterNotFound()); } var effect = await _effectProvider.GetEffectAsync(effectName); if (effect == null) { return(EffectResult.EffectNotFound()); } if (character.Effects == null) { character.Effects = new List <Effect>(); } if (character.Effects.Count(x => x.Id == effect.Id) > 0) { return(EffectResult.EffectAlreadyAdded()); } character.Effects.Add(effect); await _charProvider.UpdateCharacterAsync(character); return(EffectResult.EffectAdded()); }
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> 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}")); } }
/// <summary> /// Performs a duel between two characters rolling a statistic and returns the result. /// </summary> /// <param name="callerId">Discord ID of the caller.</param> /// <param name="targetId">Discord ID of the target.</param> /// <param name="statName">The statistic name.</param> /// <returns>The result of the roll.</returns> public async Task <IResult> RollStatisticAgainstAsync(ulong callerId, ulong targetId, string statName, bool useEffects = false) { var caller = await _provider.GetActiveCharacterAsync(callerId); if (caller == null) { return(CharacterResult.CharacterNotFound()); } var target = await _provider.GetActiveCharacterAsync(targetId); if (target == null) { return(CharacterResult.CharacterNotFound()); } var stat = await _statProvider.GetStatisticAsync(statName); if (stat == null) { return(StatisticResult.StatisticNotFound()); } double?callerRoll = _strategy.RollStatistic(stat, caller, useEffects); double?targetRoll = _strategy.RollStatistic(stat, target, useEffects); if (callerRoll.HasValue && targetRoll.HasValue) { return(RollResult.RollAgainst(caller.Name, target.Name, callerRoll.Value, targetRoll.Value)); } return(RollResult.RollFailed()); }
public List <Character> GetCharactersByJson(int?offset = 0) { List <Character> heroes = new List <Character>(); Dictionary <string, string> arguments = new Dictionary <string, string>(); /* * Api.AddArgument(arguments, "apikey", privatekey); * Api.AddArgument(arguments, "offset", "10"); * Api.AddArgument(arguments, "limit", "50"); */ String resultJson = Api.SendPostRequest("http://gateway.marvel.com:80/v1/public/characters?limit=10&offset=" + offset + "&apikey=" + publickey, arguments, "application/json"); CharacterResult resultCall = new CharacterResult(); if (resultJson != "") { resultCall = (CharacterResult)JsonConvert.DeserializeObject(resultJson, typeof(CharacterResult)); } int i = 1; foreach (Character c in resultCall.Data.Results) { if (c.Name == "" || c.Description == "" || c.Thumbnail == null && i > 10) { continue; } heroes.Add(c); i++; } return(heroes); }
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> ShowCharacterStoryAsync(IUser targetUser = null) { var userInfo = Context.User; var character = targetUser == null ? await _charService.GetCharacterAsync(userInfo.Id) : await _charService.GetCharacterAsync(targetUser.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } if (character.Story == null || character.Story.Equals("")) { return(GenericResult.FromError(Messages.ERR_STORY_NOT_FOUND)); } var embed = EmbedHelper.BuildBasicEmbed("Command: $character story", $"**Name:** {character.Name}\n" + $"**Story:** {character.Story}"); await ReplyAsync(userInfo.Mention, embed : embed); return(GenericResult.FromSilentSuccess()); }
/// <summary> /// Gets the character associated with the id and checks /// if their specified statistic is higher than the given value. /// </summary> /// <param name="id">The id of the character to get.</param> /// <param name="statName">The name of the statistic to get.</param> /// <param name="minimum">Checks if the character's StatisticValue is greater than or equal to this value.</param> /// <returns> /// A result detailing if the operation was successful or why it failed. /// </returns> public async Task <IResult> CheckStatisticAsync(ulong id, string statName) { var character = await _charProvider.GetActiveCharacterAsync(id); if (character == null) { return(CharacterResult.CharacterNotFound()); } var stat = await _statProvider.GetStatisticAsync(statName); if (stat == null) { return(StatisticResult.StatisticNotFound()); } var statValue = character.GetStatistic(stat); if (statValue == null) { return(StatisticResult.StatisticNotFound()); } return(StatisticResult.StatisticCheck(character.Name, stat.Name, statValue.Value)); }
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))); }
void SetSavedTeamData() { if (PF_PlayerData.MyTeamsCharacterId == null || PF_PlayerData.MyTeamsCharacterId.Count == 0) { return; } PF_PlayerData.SavedTeam = new List <FG_SavedCharacter>(); PF_GamePlay.AllSavedCharacterUnitData = new Dictionary <string, FG_SavedCharacter>(); int count = 1; foreach (var id in PF_PlayerData.MyTeamsCharacterId["CurrentTeam"]) { CharacterResult cha = PF_PlayerData.playerCharacters.Find(x => x.CharacterId.Contains(id)); FG_SavedCharacter saved = new FG_SavedCharacter() { characterDetails = cha, baseClass = PF_GameData.Classes[cha.CharacterType], characterData = PF_PlayerData.playerCharacterData[id] }; PF_PlayerData.SavedTeam.Add(saved); PF_GamePlay.AllSavedCharacterUnitData.Add(saved.baseClass.CatalogCode + "_" + count, saved); count++; } }
public async Task <CharacterResult> GetSimilarCharacters(Character character) { var obj = new CharacterResult(); // Select ID of Planet and Film form chracter resposne var planetId = Convert.ToInt32(character.homeworld.Substring((character.homeworld.Length - 2), 1)); var filmId = Convert.ToInt32(character.films[0].Substring((character.films[0].Length - 2), 1)); // GET Planet based on ID var planet = await _planetClient.GetPlanetByIdAsync(planetId); if (planet != null) { // Get residents of the planet - limiting to 3 residents var tasks = planet.residents.Take(3).Select(r => _characterClient.GetCharacterByIdAsync(Convert.ToInt32(r.Substring((r.Length - 2), 1)))); var characterList = (await Task.WhenAll(tasks)).Where(c => c != null); obj.MainCharacter = character; obj.SuggestedCharacter = characterList.Where(cl => cl.name != character.name).Take(3).ToList(); } else { // Get characters film - limiting to 3 characters var film = await _filmClient.GetFilmByIdAsync(filmId); var tasks = film.characters.Take(3).Select(c => _characterClient.GetCharacterByIdAsync(Convert.ToInt32(c.Substring((c.Length - 2), 1)))); var characterList = (await Task.WhenAll(tasks)).Where(c => c != null); obj.MainCharacter = character; obj.SuggestedCharacter = characterList.Where(cl => cl.name != character.name).Take(3).ToList(); } return(obj); }
public async Task <RuntimeResult> ShowCharacterAsync(IUser targetUser = null) { var userInfo = Context.User; var character = targetUser == null ? await _charService.GetCharacterAsync(userInfo.Id) : await _charService.GetCharacterAsync(targetUser.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } var level = _expService.CalculateLevelForExperience(character.Experience); var expToNextLevel = _expService.CalculateRemainingExperienceToNextLevel(character.Experience); if (!ExperienceService.UseOldProgression) { expToNextLevel = (level + 1) * 1000 - character.Experience; } var description = string.IsNullOrEmpty(character.Description) ? "No description." : character.Description; var story = string.IsNullOrEmpty(character.Story) ? "No story." : character.Story; var embed = EmbedHelper.BuildBasicEmbed($"{character.Name}", $"**Description:** {description}\n" + $"**Story:** ($char story)\n" + $"**Level:** {level}\n" + $"**Experience:** {character.Experience}\n" + $"**To Next Level:** {expToNextLevel}\n" + $"**Caps:** {character.Money}"); await ReplyAsync(userInfo.Mention, embed : embed); return(GenericResult.FromSilentSuccess()); }
public async Task <IResult> GiveMoneyToOtherAsync(ulong callerId, ulong targetId, int moneyToGive) { var caller = await _provider.GetActiveCharacterAsync(callerId); if (caller == null) { return(CharacterResult.CharacterNotFound()); } var target = await _provider.GetActiveCharacterAsync(targetId); if (target == null) { return(CharacterResult.CharacterNotFound()); } if (caller.Money - moneyToGive >= 0) { caller.Money -= moneyToGive; target.Money += moneyToGive; await _provider.UpdateCharacterAsync(caller); await _provider.UpdateCharacterAsync(target); return(CharacterResult.MoneyGiven(moneyToGive, target.Name)); } else { return(GenericResult.ValueTooHigh()); } }
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> 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)); }
/// <summary> /// Performs a roll on a character's statistic and returns the result. /// </summary> /// <param name="callerId">Discord ID of the caller.</param> /// <param name="statName">The statistic name.</param> /// <returns>The result of the roll.</returns> public async Task <IResult> RollStatisticAsync(ulong callerId, string statName, bool useEffects = false) { var character = await _provider.GetActiveCharacterAsync(callerId); if (character == null) { return(CharacterResult.CharacterNotFound()); } var stat = await _statProvider.GetStatisticAsync(statName); if (stat == null) { return(StatisticResult.StatisticNotFound()); } string result = _strategy.GetRollMessage(stat, character, useEffects); if (!string.IsNullOrEmpty(result)) { return(RollResult.Roll(result)); } return(RollResult.RollFailed()); }
/// <summary> /// Used to remove an effect from a character. /// </summary> /// <param name="callerId">The user identifier of the caller.</param> /// <param name="effectName">The name of the effect to remove from the character.</param> public async Task <IResult> RemoveEffectAsync(ulong callerId, string effectName) { var character = await _charProvider.GetActiveCharacterAsync(callerId); if (character == null) { return(CharacterResult.CharacterNotFound()); } var effect = await _effectProvider.GetEffectAsync(effectName); if (effect == null) { return(EffectResult.EffectNotFound()); } var match = character.Effects.FirstOrDefault(x => x.Id == effect.Id); if (match == null) { return(EffectResult.EffectNotFound()); } character.Effects.Remove(match); await _charProvider.UpdateCharacterAsync(character); return(EffectResult.EffectRemoved()); }
void Start() { answers = FindObjectOfType <Answers>(); characterManager = FindObjectOfType <CharacterManager>(); characterResult = FindObjectOfType <CharacterResult>(); charArray = characterManager.charArray; storyImageSlideController = FindObjectOfType <StoryImageSlideController>(); }
public static string AsAByteString(this CharacterResult characterResult /*this byte[] buffer*/) { if (characterResult == null) { return(""); } // Ansi as default Encoding encoding = Encoding.UTF8; #if FRAMEWORK return(encoding.GetString(buffer)); #else if (characterResult == null /* || characterResult.Length == 0*/) { return(""); } /* * EF BB BF UTF-8 * FF FE UTF-16 little endian * FE FF UTF-16 big endian * FF FE 00 00 UTF-32, little endian * 00 00 FE FF UTF-32, big-endian */ //if (characterResult[0] == 0xef && characterResult[1] == 0xbb && characterResult[2] == 0xbf) //{ // encoding = Encoding.UTF8; //} //else if (characterResult[0] == 0xfe && characterResult[1] == 0xff) //{ // encoding = Encoding.Unicode; //} //else if (characterResult[0] == 0xfe && characterResult[1] == 0xff) //{ // encoding = Encoding.BigEndianUnicode; // utf-16be //} using (MemoryStream stream = new MemoryStream()) { string characterResultString = characterResult.ToString(); // Convert a C# string to a byte array byte[] characterResultByteArray = Encoding.ASCII.GetBytes(characterResultString); //foreach (byte b in characterResultByteArray) //{ // Console.WriteLine(b); //} stream.Write(characterResultByteArray /*.Code.*//*.AsAByteString()*/, 0, characterResult.Data.Count.Length /*, characterResult.Length*/); stream.Seek(0, SeekOrigin.Begin); using (StreamReader reader = new StreamReader(stream, encoding)) { return(reader.ReadToEnd()); } } #endif }
/// <summary> /// Gets the caller's active character and returns the result. /// </summary> /// <param name="callerId">Discord ID of the caller.</param> /// <returns>A new CharacterResult object.</returns> public async Task <IResult> ShowCharacterAsync(ulong callerId) { var character = await _provider.GetActiveCharacterAsync(callerId); if (character == null) { return(CharacterResult.CharacterNotFound()); } return(CharacterResult.Show(character, _progStrategy.GetCharacterLevel(character), await _progStrategy.GetCharacterInfo(character))); }
private async Task <RuntimeResult> RollPlayerAsync(Statistic statToRoll, IUser user, bool useEffects = false) { var character = await _charService.GetCharacterAsync(user.Id); if (character == null) { return(CharacterResult.CharacterNotFound()); } return(_rollService.RollStatistic(character, statToRoll, useEffects)); }
private void GetCharsCallback(ListUsersCharactersResult result) { lastReceivedMessage = "Get Chars Successful"; foreach (var eachCharacter in result.Characters) { if (eachCharacter.CharacterName == CHAR_NAME) { targetCharacter = eachCharacter; } } }
public async Task SetStory_InvalidCharacter_ReturnCharacterNotFound() { // Arrange var provider = new MockCharacterProvider(); var controller = new CharacterController(provider, new MockProgressionStrategy(), new GeneralOptions()); // Act var result = await controller.SetCharacterStoryAsync(1000, "description"); // Assert Assert.True(CharacterResult.CharacterNotFound().Equals(result)); }
public async Task ShowCharacter_InvalidId_ReturnCharacterNotFound() { // Arrange var provider = new MockCharacterProvider(); var controller = new CharacterController(provider, null, new GeneralOptions()); // Act var result = await controller.ShowCharacterAsync(0); // Assert Assert.Equal(CharacterResult.CharacterNotFound(), result); }
public async Task CreateCharacter_ValidValues_ReturnSuccess() { // Arrange var provider = new MockCharacterProvider(); var controller = new CharacterController(provider, null, new GeneralOptions()); // Act var result = await controller.CreateCharacterAsync(1, "c"); // Assert Assert.Equal(CharacterResult.CharacterCreatedSuccessfully(), result); }
public async Task CreateCharacter_PlayerHasExistingName_ReturnNameAlreadyExists() { // Arrange var provider = new MockCharacterProvider(); var controller = new CharacterController(provider, null, new GeneralOptions()); // Act var result = await controller.CreateCharacterAsync(1, "c1"); // Existing // Assert Assert.Equal(CharacterResult.NameAlreadyExists(), result); }
public async Task CreateCharacter_ExistingNameButNotBelongingToPlayer_ReturnSuccess() { // Arrange var provider = new MockCharacterProvider(); var controller = new CharacterController(provider, null, new GeneralOptions()); // Act var result = await controller.CreateCharacterAsync(1, "c2"); // Existing // Assert Assert.Equal(CharacterResult.CharacterCreatedSuccessfully(), result); }
//[SerializeField] List<int> statement = new List<int>(); //[SerializeField] List<int> character = new List<int>(); //[SerializeField] List<int> answers = new List<int>(); void Start() { answers = FindObjectOfType <Answers>(); testingArrayOrList = FindObjectOfType <TestingArrayOrList>(); characterResult = FindObjectOfType <CharacterResult>(); charArray = testingArrayOrList.charArray; //acceptChoice = FindObjectOfType<AcceptChoice>(); //charArray = acceptChoice.charArray; // int indexChar = character.IndexOf(120); // List.IndexOf(character); // statement.Add(1); // statement.Add(2); // statement.Add(3); // statement.Add(4); // statement.Add(5); // statement.Add(6); // statement.Add(7); // statement.Add(8); // statement.Add(9); // statement.Add(10); // statement.Add(11); // statement.Add(12); // statement.Add(13); // statement.Add(14); // statement.Add(15); // statement.Add(16); // statement.Add(17); // statement.Add(18); // statement.Add(19); // statement.Add(20); // foreach (int o in statement) // { // for (int i = 0; i< 6; i++) // { // character.Add(i); // } // } // foreach (int p in character) // { // for (int i = 0; i< 4; i++) // { // answers.Add(i); // } // } // currentStatement = 1; // lastStatement = 1; }
public async Task Roll_InvalidId_ReturnCharacterNotFound() { // Arrange var provider = new MockCharacterProvider(); var statProvider = new MockStatisticProvider(); var controller = new RollController(provider, statProvider, new MockRollStrategy()); // Act var result = await controller.RollStatisticAsync(0, "strength"); // Assert Assert.Equal(CharacterResult.CharacterNotFound(), result); }
private async Task <RuntimeResult> RollVsPlayers(IUser user1, IUser user2, Statistic stat1, Statistic stat2, bool useEffects = false) { var char1 = await _charService.GetCharacterAsync(user1.Id); var char2 = await _charService.GetCharacterAsync(user2.Id); if (char1 == null || char2 == null) { return(CharacterResult.CharacterNotFound()); } return(_rollService.RollVsStatistic(char1, char2, stat1, stat2, useEffects)); }