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