public List <LimitBreak> BuildLimitInfoFromCharNameAndTier(string tier, string character, int?index = null) { var limitsFromDb = soulbreakRepository.GetLimitBreaksByCharacterNameAndTier(tier, character, index); var newlimits = new List <LimitBreak>(); foreach (var limit in limitsFromDb) { var newlimit = new LimitBreak(); newlimit.LimitStatuses = statusRepository.GetStatusesByEffectText(limit.Name, limit.Effects); FilterAttachElementFromStatuses(newlimit.LimitStatuses); newlimit.LimitOthers = new Dictionary <string, List <SheetOthers> >(); foreach (var status in newlimit.LimitStatuses.SelectMany(x => x.Value)) { statusRepository.GetOthersByNamesAndSource(status.Name, newlimit.LimitOthers); } newlimit.Info = limit; AddGuardianCommandsToLimitBreak(newlimit); newlimits.Add(newlimit); } ; return(newlimits); }
public void AddGuardianCommandsToLimitBreak(LimitBreak limitBreak) { var Guardians = soulbreakRepository.GetGuardianCommandsByCharacterAndLimitBreak(limitBreak.Info.Character, limitBreak.Info.Name); limitBreak.GuardianCommands = new List <GuardianCommand>(); foreach (var guardian in Guardians) { var newGuardian = new GuardianCommand(); newGuardian.Info = guardian; newGuardian.GuardianStatuses = statusRepository.GetStatusesByEffectText(guardian.Name, guardian.Effects); FilterAttachElementFromStatuses(newGuardian.GuardianStatuses); newGuardian.GuardianOthers = new Dictionary <string, List <SheetOthers> >(); foreach (var status in newGuardian.GuardianStatuses.SelectMany(x => x.Value)) { statusRepository.GetOthersByNamesAndSource(status.Name, newGuardian.GuardianOthers); } foreach (var other in newGuardian.GuardianOthers) { foreach (var otherStatus in other.Value) { FilterAttachElementFromStatuses(otherStatus.OtherStatuses); } } limitBreak.GuardianCommands.Add(newGuardian); } }
public IActionResult GetLimitBreaksBySearch([FromBody] D.LimitBreak searchPrototype) { _logger.LogInformation($"Controller Method invoked: {nameof(GetLimitBreaksBySearch)}"); LimitBreak LimitBreak = _mapper.Map <LimitBreak>(searchPrototype); IEnumerable <LimitBreak> model = _LimitBreaksLogic.GetLimitBreaksBySearch(LimitBreak); IEnumerable <D.LimitBreak> result = _mapper.Map <IEnumerable <D.LimitBreak> >(model); return(new ObjectResult(result)); }
// Use this for initialization void Start() { _spriteRenderer = GetComponentInChildren <SpriteRenderer> (); _anim = GetComponent <Animator> (); _limitBreak = GameObject.FindGameObjectWithTag("LimitBreak").GetComponent <LimitBreak>(); _mainGame = GameObject.FindGameObjectWithTag("MainGame").GetComponent <MainGame> (); _BG_Object = GameObject.FindGameObjectWithTag("GameMapController"); _BG_Sprite = _BG_Object.GetComponent <SpriteRenderer> ().sprite; _minXMove = _BG_Sprite.bounds.min.x * _BG_Object.transform.localScale.x + _BG_Object.transform.position.x + moveOffset; _maxXMove = _BG_Sprite.bounds.max.x * _BG_Object.transform.localScale.x + _BG_Object.transform.position.x - moveOffset; }
// Use this for initialization void Start () { maxHealth = health; levelManager = FindObjectOfType<LevelManager>(); anim = GetComponent<Animator>(); limitBreak = FindObjectOfType<LimitBreak>(); if (GetComponent<Defender>()) { playerHealthBar = FindObjectOfType<HealthBar>(); playerHealthBar.SetMaxHealth (maxHealth); playerHealthBar.UpdateDisplay (health); } scoreKeeper = GameObject.Find("Score").GetComponent<ScoreKeeper>(); }
public void ParseLine(string line) { string[] lineContents = line.Split('|'); int.TryParse(lineContents[0], out int messageType); if ((LogMessageType)messageType != LogMessageType.NetworkAOEAbility) { firstAOELine = true; } switch ((LogMessageType)messageType) { case LogMessageType.LogLine: break; case LogMessageType.ChangeZone: zoneName = lineContents[3]; if (ZoneData.zoneInfo.ContainsKey(zoneName)) { bossInformation = ZoneData.zoneInfo[zoneName]; currentEncounter.zoneName = zoneName; currentEncounter.bosses = bossInformation; currentEncounter.combatants.Clear(); Debug.WriteLine($"Entered {zoneName}..."); } else { Debug.WriteLine($"Entered {zoneName}..."); currentEncounter = new Encounter(zoneName); } break; case LogMessageType.ChangePrimaryPlayer: break; case LogMessageType.AddCombatant: Combatant addCombatant = ReadCombatant(lineContents); currentEncounter.combatants.Add(addCombatant); if (addCombatant.ID.ToString("X8").StartsWith("10")) { if (!currentEncounter.partyMemberIDs.Contains(addCombatant.ID)) { currentEncounter.partyMemberIDs.Add(addCombatant.ID); } } foreach (BossInfo boss in currentEncounter.bosses) { if (boss.Name == addCombatant.Name && boss.Level == addCombatant.Level && (boss.MaxHP == addCombatant.Health.MaxHP || boss.MaxHP == addCombatant.Health.CurrentHP)) { currentEncounter.endedEncounter = false; } } break; case LogMessageType.RemoveCombatant: Combatant removeCombatant = ReadCombatant(lineContents); currentEncounter.combatants.Remove(removeCombatant); break; case LogMessageType.AddBuff: break; case LogMessageType.RemoveBuff: break; case LogMessageType.FlyingText: break; case LogMessageType.OutgoingAbility: break; case LogMessageType.IncomingAbility: break; case LogMessageType.PartyList: //If the encounter hasnt started yet form the party memebers //This is to avoid the struggles of someone dcing and changing the party size which could end up crashing this algorithm if (!string.IsNullOrEmpty(currentEncounter.zoneName) && !currentEncounter.startedEncounter) { currentEncounter.partyMemberIDs.Clear(); uint.TryParse(lineContents[2], out uint size); int start = 3; //Start of first memeber and going to start + size try { for (int i = 0; i < size; i++) { currentEncounter.partyMemberIDs.Add(Convert.ToUInt32(lineContents[start + i], 16)); } } catch (OverflowException ex) { Debug.WriteLine("Someone seemed to have disconnected!"); } } break; case LogMessageType.PlayerStats: break; case LogMessageType.CombatantHP: break; case LogMessageType.ParsedPartyMember: break; case LogMessageType.NetworkStartsCasting: NetworkAbilityCast networkAbilityCast = ReadNetworkCast(lineContents); currentEncounter.networkCastingAbilities.Add(networkAbilityCast); Combatant combatant = currentEncounter.GetCombatantFromID(networkAbilityCast.ActorID); //They started casting so we count this as a skill usage even if cancelled or interruped if (combatant != null && !currentEncounter.startedEncounter && currentEncounter.bosses.Any(boss => boss.Name == networkAbilityCast.TargetName)) { currentEncounter.events.Add(new ReportEvent { EventTime = networkAbilityCast.Timestamp.TimeOfDay, EventDescription = $"{networkAbilityCast.ActorName} casts {networkAbilityCast.SkillName} on {networkAbilityCast.TargetName}", EventType = EventType.Summary | EventType.DamageDone }); } if (combatant != null) { if (!combatant.AbilityInfo.ContainsKey(networkAbilityCast.SkillName)) { combatant.AbilityInfo.Add(networkAbilityCast.SkillName, new AbilityInfo()); } combatant.AbilityInfo[networkAbilityCast.SkillName].CastAmount++; } break; case LogMessageType.NetworkAbility: case LogMessageType.NetworkAOEAbility: if (bossInformation.Count == 0) { break; } NetworkAbility ability = ReadAbilityUsed(lineContents); combatant = currentEncounter.GetCombatantFromID(ability.ActorID); //Check if the ability used is a new skill if it is lets keep track of it from the combatant side //Itll be updated in the NetworkEffectResult since thats when the information is able to be deteced if (combatant != null) { if (!combatant.AbilityInfo.ContainsKey(ability.SkillName)) { combatant.AbilityInfo.Add(ability.SkillName, new AbilityInfo()); } if (((LogMessageType)messageType == LogMessageType.NetworkAOEAbility && firstAOELine) || (LogMessageType)messageType == LogMessageType.NetworkAbility) { combatant.AbilityInfo[ability.SkillName].CastAmount++; firstAOELine = false; } } if (!currentEncounter.startedEncounter && bossInformation.Any(boss => boss.Name == ability.TargetName)) { currentEncounter.startTime = ability.Timestamp; Debug.WriteLine($"Start of fight: {ability.Timestamp}"); currentEncounter.startedEncounter = true; currentEncounter.AdjustTimeSpans(); //Makes time negative since actions happened before the start } if (currentEncounter.startedEncounter) { currentEncounter.events.Add(new ReportEvent { EventTime = ability.Timestamp.Subtract(currentEncounter.startTime), EventDescription = $"{ability.ActorName} prepares {ability.SkillName} on {ability.TargetName} {ability.GetAbilityDamageInformation()}", EventType = EventType.Summary | (ability.AbilityState == AbilityState.Damage? EventType.DamageDone : EventType.Healing) }); currentEncounter.abilities.Add(ability); } break; case LogMessageType.NetworkCancelAbility: NetworkAbilityCancel networkAbilityCancel = ReadNetworkSkillCancel(lineContents); break; case LogMessageType.NetworkDoT: break; case LogMessageType.NetworkDeath: NetworkDeath death = ReadNetworkDeath(lineContents); if (currentEncounter.startedEncounter) { currentEncounter.events.Add(new ReportEvent { EventTime = death.Timestamp.Subtract(currentEncounter.startTime), EventDescription = $"{death.ActorName} dies." }); } break; case LogMessageType.NetworkBuff: NetworkBuff networkBuff = ReadNetworkBuff(lineContents); if (currentEncounter.startedEncounter) { currentEncounter.events.Add(new ReportEvent { EventTime = networkBuff.Timestamp.Subtract(currentEncounter.startTime), EventDescription = $"{networkBuff.TargetName} gains {networkBuff.SkillName} from {networkBuff.ActorName}", EventType = EventType.Summary }); } break; case LogMessageType.NetworkTargetIcon: break; case LogMessageType.NetworkTargetMarker: break; case LogMessageType.NetworkBuffRemove: break; case LogMessageType.NetworkGauge: break; case LogMessageType.NetworkWorld: break; case LogMessageType.Network6D: if (currentEncounter.startedEncounter) { if (lineContents[3] == "40000010") //Ending Wipe { currentEncounter.endedEncounter = true; currentEncounter.endTime = DateTime.Parse(lineContents[1]); encounters.Add(currentEncounter); Debug.WriteLine($"A wipe has occurred... It took {currentEncounter.endTime.Subtract(currentEncounter.startTime)}"); currentEncounter.DumpSummaryToFile(encounterDirectoryInfo); currentEncounter = (Encounter)currentEncounter.Clone(); } } break; case LogMessageType.NetworkNameToggle: break; case LogMessageType.NetworkTether: break; case LogMessageType.NetworkLimitBreak: LimitBreak limitBreak = ReadLimitBreak(lineContents); if (currentEncounter.startedEncounter) { currentEncounter.events.Add(new ReportEvent { EventTime = limitBreak.Timestamp.Subtract(currentEncounter.startTime), EventDescription = $"The limit break guage has been updated to {limitBreak.LimitBreakGuage}. {limitBreak.MaxLimitBreakNumber} bars are available.", EventType = EventType.Summary }); } break; case LogMessageType.NetworkEffectResult: NetworkEffectResult result = ReadNetworkEffectResult(lineContents); foreach (BossInfo boss in currentEncounter.bosses) { if (result.ActorName == boss.Name && result.Health.CurrentHP == 0 && boss.HasToDie) { boss.IsDead = true; } } //Figure out the damage the skill inflicted and then go back and credit the ability for that damage if (currentEncounter.startedEncounter && !currentEncounter.endedEncounter && currentEncounter.AreRequiredBossesDead()) { currentEncounter.endedEncounter = true; currentEncounter.endTime = result.Timestamp; currentEncounter.isCleared = true; encounters.Add(currentEncounter); Debug.WriteLine($"Encounter cleared!!! It took {currentEncounter.endTime.Subtract(currentEncounter.startTime)}"); currentEncounter.DumpSummaryToFile(encounterDirectoryInfo); currentEncounter = (Encounter)currentEncounter.Clone(); } if (currentEncounter.startedEncounter) { combatant = currentEncounter.GetCombatantFromID(result.ActorID); if (combatant != null) { int healthChange = combatant.Health - result.Health; combatant.Health.CurrentHP -= (uint)healthChange; NetworkAbility networkAbility = currentEncounter.abilities.Where(ability => ability.Damage == (uint)Math.Abs(healthChange)).FirstOrDefault(); if (networkAbility != null) { currentEncounter.events.Add(new ReportEvent { EventTime = result.Timestamp.Subtract(currentEncounter.startTime), EventDescription = $"{networkAbility.ActorName} {networkAbility.SkillName} {networkAbility.TargetName} {networkAbility.Damage}", EventType = EventType.Summary | (networkAbility.AbilityState == AbilityState.Damage ? EventType.DamageDone : EventType.Healing) }); currentEncounter.abilities.Remove(networkAbility); Combatant caster = currentEncounter.GetCombatantFromID(networkAbility.ActorID); AbilityInfo abilityInfo = caster.AbilityInfo[networkAbility.SkillName]; abilityInfo.HitCount++; if (networkAbility.AbilityState == AbilityState.Damage) { abilityInfo.DamageInformation.TotalDamageDone += (uint)healthChange; abilityInfo.DamageInformation.DPS = abilityInfo.DamageInformation.TotalDamageDone / (result.Timestamp.Subtract(currentEncounter.startTime).TotalSeconds); } else if (networkAbility.AbilityState == AbilityState.Healing) { abilityInfo.HealingInformation.TotalHealingDone += (uint)Math.Abs(healthChange); abilityInfo.HealingInformation.HPS = abilityInfo.HealingInformation.TotalHealingDone / (result.Timestamp.Subtract(currentEncounter.startTime).TotalSeconds); } } } } break; case LogMessageType.NetworkStatusList: NetworkStatusList networkStatusList = ReadNetworkStatusList(lineContents); if (currentEncounter.startedEncounter) { combatant = currentEncounter.GetCombatantFromID(networkStatusList.TargetID); if (combatant != null) { int healthChange = combatant.Health - networkStatusList.Health; combatant.Health.CurrentHP -= (uint)healthChange; } } foreach (BossInfo boss in currentEncounter.bosses) { if (networkStatusList.TargetName == boss.Name && networkStatusList.Health.CurrentHP == 0 && boss.HasToDie) { boss.IsDead = true; } } //Figure out the damage the skill inflicted and then go back and credit the ability for that damage if (currentEncounter.startedEncounter && !currentEncounter.endedEncounter && currentEncounter.AreRequiredBossesDead()) { currentEncounter.endedEncounter = true; currentEncounter.endTime = networkStatusList.Timestamp; currentEncounter.isCleared = true; encounters.Add(currentEncounter); Debug.WriteLine($"Encounter cleared!!! It took {currentEncounter.endTime.Subtract(currentEncounter.startTime)}"); currentEncounter.DumpSummaryToFile(encounterDirectoryInfo); currentEncounter = (Encounter)currentEncounter.Clone(); } break; case LogMessageType.NetworkUpdateHp: combatant = ReadNetworkUpdateHP(lineContents); if (currentEncounter.startedEncounter) { Combatant oldCombatant = currentEncounter.GetCombatantFromID(combatant.ID); if (oldCombatant != null) { oldCombatant.Health = combatant.Health; } } break; case LogMessageType.Settings: string[] settings = lineContents[2].Split(','); //Debug.WriteLine("ACT Settings:"); foreach (string setting in settings) { //Debug.WriteLine(setting.Trim()); } break; case LogMessageType.Process: break; case LogMessageType.Debug: break; case LogMessageType.PacketDump: break; case LogMessageType.Version: //Debug.WriteLine($"You are using {lineContents[2]}"); break; case LogMessageType.Error: break; case LogMessageType.Timer: break; } }
public IEnumerable <LimitBreak> GetLimitBreaksBySearch(LimitBreak searchPrototype) { _logger.LogInformation($"Logic Method invoked: {nameof(GetLimitBreaksBySearch)}"); //ignore: Description, Effects, EnlirId, Id, ImagePath, IntroducingEventId, IntroducingEventName, IsChecked, IsCounterable, LimitBreakPointsGainedJapan var query = _enlirRepository.GetMergeResultsContainer().LimitBreaks; if (searchPrototype.AbilityType != 0) { query = query.Where(a => a.AbilityType == searchPrototype.AbilityType); } if (!string.IsNullOrWhiteSpace(searchPrototype.LimitBreakName)) { query = query.Where(a => a.LimitBreakName.ToLower().Contains(searchPrototype.LimitBreakName.ToLower())); } if (searchPrototype.Realm != 0) { query = query.Where(a => a.Realm == searchPrototype.Realm); } if (searchPrototype.CharacterId != 0) { query = query.Where(a => a.CharacterId == searchPrototype.CharacterId); } if (searchPrototype.Multiplier != 0) { query = query.Where(a => a.Multiplier >= searchPrototype.Multiplier); } if (searchPrototype.Elements != null && searchPrototype.Elements.Any()) { query = query.Where(a => a.Elements.Contains(searchPrototype.Elements.First()) || a.OtherEffects.Any(e => e.Elements.Contains(searchPrototype.Elements.First()))); } if (!string.IsNullOrWhiteSpace(searchPrototype.Effects)) { query = query.Where(a => a.Effects.ToLower().Contains(searchPrototype.Effects.ToLower())); } if (searchPrototype.LimitBreakTier != 0) { query = query.Where(a => a.LimitBreakTier == searchPrototype.LimitBreakTier); } if (!string.IsNullOrWhiteSpace(searchPrototype.LimitBreakBonus)) { query = query.Where(a => a.LimitBreakBonus.ToLower().Contains(searchPrototype.LimitBreakBonus.ToLower())); } if (searchPrototype.Statuses != null && searchPrototype.Statuses.Any()) { query = query.Where(a => a.Statuses.Any(s => s.Id == searchPrototype.Statuses.First().Id)); } if (searchPrototype.AutoTargetType != 0) { query = query.Where(a => a.AutoTargetType == searchPrototype.AutoTargetType); } if (searchPrototype.CastTime != 0) { query = query.Where(a => a.CastTime <= searchPrototype.CastTime); } if (searchPrototype.DamageFormulaType != 0) { query = query.Where(a => a.DamageFormulaType == searchPrototype.DamageFormulaType); } if (searchPrototype.TargetType != 0) { query = query.Where(a => a.TargetType == searchPrototype.TargetType); } return(query); }