private static void SetGeneralInformation(this RaidModel raidModel, dynamic logData)
{
raidModel.EncounterTime = logData.encounterDuration.Value;
raidModel.EncounterIcon = logData.fightIcon.Value;
raidModel.EncounterName = logData.fightName.Value;
raidModel.EncounterId = int.Parse(logData.fightID.Value.ToString());
raidModel.Killed = logData.success.Value;
}
private static void SetRemainingHealth(this RaidModel raidModel, dynamic logData)
{
for (var i = 0; i < logData.phases[0].targets.Count; i++)
{
var targetData = logData.targets[(int)logData.phases[0].targets[i]];
raidModel.HpLeft.Add(targetData.hpLeft.Value);
}
}
private void AssertExpectations(RaidModel log)
{
log.EncounterName.Should().Be(ExpectedEncounterName);
log.EncounterTime.Should().Be(ExpectedEncounterTime);
log.EncounterIcon.Should().Be(ExpectedEncounterIcon);
log.Killed.Should().Be(ExpectedKilled);
log.HpLeft.Count().Should().Be(ExpectedNumberOfHpLeft);
log.HpLeft[0].Should().Be(ExpectedHpLeft);
log.Players.Count().Should().Be(ExpectedPlayers);
log.OccurenceStart.Should().Be(ExpectedOccurenceStart);
log.OccurenceEnd.Should().Be(ExpectedOccurenceEnd);
}
private static void ParseMechanics(this PlayerModel playerModel, RaidModel raidModel, dynamic logData,
ILogger logger = null)
{
var strategy = MechanicsFactory.FindStrategy(raidModel.EncounterIcon);
try
{
strategy?.Parse(logData, playerModel);
}
catch (Exception)
{
logger?.LogDebug(">>> Mechanics not parsable: " + raidModel.LogUrl);
}
}
public SoftResRaidBuilder()
{
_raidModel = new RaidModel
{
Amount = 2,
Faction = "Horde",
Discord = false,
Instance = "naxxramas",
ItemLimit = 0,
HideReserves = false,
CharacterNotes = true,
PlusModifier = 1,
RestrictByClass = true
};
}
internal static Encounter Convert(RaidModel raidModel)
{
var encounter = new Encounter
{
Killed = raidModel.Killed,
EncounterTime = raidModel.EncounterTime,
OccurenceStart = raidModel.OccurenceStart,
OccurenceEnd = raidModel.OccurenceEnd,
HitPointsRemaining = raidModel.HpLeft.Average(),
Boss = ConvertBossData(raidModel),
Players = raidModel.Players
.Select(PlayerModelToPlayerConverter.Convert).ToList()
};
return(encounter);
}
internal static RaidModel ParseLog(string filePath, ILogger logger = null)
{
var model = new RaidModel(filePath);
try
{
var logData = GetLogData(File.ReadAllText(model.LogPath));
SetRemainingHealth(model, logData);
SetGeneralInformation(model, logData);
if (logData.eiVersion != null || logData.parser != null)
{
model.OccurenceStart = DateTime.ParseExact(
logData.encounterStart.Value, "yyyy-MM-dd HH:mm:ss zzz", CultureInfo.InvariantCulture);
model.OccurenceEnd = DateTime.ParseExact(
logData.encounterEnd.Value, "yyyy-MM-dd HH:mm:ss zzz", CultureInfo.InvariantCulture);
}
var fightDuration = (long)logData.phases[0].duration.Value;
for (var j = 0; j < logData.players.Count; j++)
{
var playerModel = new PlayerModel
{
Index = j,
AccountName = logData.players[j].acc
};
ParseSupportStats(playerModel, logData);
ParseDamageStats(playerModel, fightDuration, logData);
ParseMechanics(playerModel, model, logData, logger);
ParseBoons(playerModel, logData);
model.Players.Add(playerModel);
}
}
catch (Exception e)
{
logger?.LogError($">>> {filePath} cannot be parsed.");
logger?.LogDebug(e.Message);
return(null);
}
return(model);
}
void Start()
{
_audioSource = GetComponent <AudioSource>();
_raid = World.ChosenRaid;
Viking.Reset();
Village.Reset();
if (_raid == null && DebugRaidModel)
{
_raid = DebugRaidModel;
}
_actionDialogModels.Add(_raid.RaidActionDialogModel);
_actionDialogModels.Add(_raid.MeadActionDialogModel);
_actionDialogModels.Add(_raid.OdinActionDialogModel);
_actionDialogModels.Add(_raid.EnglandActionDialogModel);
NextPhase();
}
public async Task <Embed> CreateRaidMonitorEmbed(RaidModel raidModel)
{
var embedBuilder = new EmbedBuilder()
.WithTitle($"Soft Res Raid Event - {raidModel.RaidId}")
.AddField("Soft Res Sheet", $"[SoftRes.It](https://softres.it/raid/{raidModel.RaidId})", true)
.AddField("Filler", "Filler", true)
.AddField("Total Reserves", raidModel.Reserved.Count, true);
var reservedCount = raidModel.Reserved.Count;
if (reservedCount == 0)
{
return(embedBuilder.Build());
}
var emptySpacesOnFinalRow = (3 - reservedCount % 3);
var reservedGroups = raidModel.Reserved.SplitList(3).ToList();
for (var i = 0; i < reservedGroups.Count; i++)
{
foreach (var softResUserModel in reservedGroups[i])
{
var itemSb = new StringBuilder();
foreach (var item in softResUserModel.Items)
{
var itemData = await _itemRepository.FindAsync(item);
var itemString = itemData?.Name ?? $"Item#{item}";
itemSb.AppendLine(itemString);
}
embedBuilder.AddField($"{softResUserModel.Name}", itemSb.ToString(), true);
}
if (i != reservedGroups.Count)
{
continue;
}
for (var j = 0; j < emptySpacesOnFinalRow; j++)
{
embedBuilder.AddField(EmbedConstants.EmptySpace, EmbedConstants.EmptySpace);
}
}
return(embedBuilder.Build());
}
/// <summary>
/// Gets all of a characters raids using a lookback period specified as an integer representing days
/// </summary>
/// <param name="pCharacterName">The character name, case-insensitive</param>
/// <param name="pLookback">The lookback period specified in days</param>
/// <returns></returns>
public static IEnumerable GetCharacterRaids(string pClientId, string pCharacterName, int pLookback = 0)
{
Dictionary <int, RaidModel> vRaids = new Dictionary <int, RaidModel>();
using (opendkpContext vDatabase = new opendkpContext())
{
var vCharacter = vDatabase.Characters.First(x => x.ClientId.Equals(pClientId) && x.Name.Equals(pCharacterName, StringComparison.InvariantCultureIgnoreCase));
List <TicksXCharacters> vResult = null;
if (pLookback > 0)
{
vResult = vDatabase.TicksXCharacters
.Include("IdTickNavigation.Raid.IdPoolNavigation")
.Where(x => x.ClientId.Equals(pClientId) && x.IdCharacter == vCharacter.IdCharacter &&
DateTime.Compare(x.IdTickNavigation.Raid.Timestamp.Date,
DateTime.Now.AddDays(pLookback * -1).Date) >= 0)
.ToList();
}
else
{
vResult = vDatabase.TicksXCharacters
.Where(x => x.ClientId.Equals(pClientId) && x.IdCharacter == vCharacter.IdCharacter)
.Include("IdTickNavigation.Raid.IdPoolNavigation")
.ToList();
}
foreach (var vModel in vResult)
{
TickModel vTick = new TickModel(vModel.IdTickNavigation);
if (!vRaids.ContainsKey(vModel.IdTickNavigation.RaidId))
{
RaidModel vRaid = new RaidModel(vModel.IdTickNavigation.Raid);
vRaid.TotalTicks = vDatabase.Ticks.Include("Raid").Count(x => x.ClientId.Equals(pClientId) && x.RaidId == vRaid.IdRaid);
vRaids.Add(vModel.IdTickNavigation.RaidId, vRaid);
}
vRaids[vModel.IdTickNavigation.RaidId].Ticks.Add(vTick);
}
}
return(vRaids.Values.ToList());
}
internal static StringBuilder BuildEncounterHeader(this StringBuilder stringBuilder, RaidModel raidModel)
{
var encounterTime = raidModel.OccurenceEnd - raidModel.OccurenceStart;
stringBuilder.Append($@"
<div class=""content"">
<a href=""{raidModel.LogUrl}"" target=""_blank"" style=""color: #aaa; text-decoration: none;"">
<img src=""{raidModel.EncounterIcon}"" alt=""{HttpUtility.HtmlEncode(raidModel.EncounterName)}"" width=""64"" height=""64"" style=""float: right;"">
<h2>{HttpUtility.HtmlEncode(raidModel.EncounterName)}</h2>
<p>{raidModel.OccurenceStart.ToLongTimeString()} ⇒ {raidModel.OccurenceEnd.ToLongTimeString()} ({encounterTime.Minutes}m {encounterTime.Seconds}s)
</a>
" );
foreach (var value in raidModel.HpLeft)
{
stringBuilder.Append($@"
<div title=""{RaidModel.DoubleAsHtml(value)}% left"" style=""background: rgba(0, 0, 0, 0)
linear-gradient(to right, red {RaidModel.DoubleAsHtml(value)}%, {RaidModel.DoubleAsHtml(value)}%, green {RaidModel.DoubleAsHtml(100 - value)}%)
repeat scroll 0% 0%; height: 10px; width: 100%; border-radius: 5px; margin-top: 3px;"">
</div>" );
}
return(stringBuilder);
}
public override string CreateHtml(RaidModel model)
{
var top = "";
top += @"<table class=""mechanicsTable"" style=""display: none;"">";
top += @"<tr>
<th>Player</th>
<th title=""Hit by Shockwave"">Shockwave</th>
</tr>" ;
foreach (var player in model.Players.OrderByDescending(i => i.CombinedMechanics.Sum(j => j.Value)).Take(3))
{
var mid = $@"
<tr>
<td>{HttpUtility.HtmlEncode(player.AccountName)}</td>
<td>{player.CombinedMechanics["sabir_shockwave"]}</td>
</tr>" ;
top += mid;
}
top += "</table>";
return(top);
}
internal static StringBuilder BuildResurrectionTable(this StringBuilder stringBuilder, RaidModel raidModel)
{
stringBuilder.Append(@"<table class=""resTable"" style=""display: none;"">");
foreach (var player in raidModel.Players.OrderByDescending(i => i.ResAmount).Take(3))
{
stringBuilder.Append($@"
<tr>
<td>{HttpUtility.HtmlEncode(player.AccountName)}</td>
<td title=""Total res: {player.ResTime}"">{player.ResTime}s - {player.ResAmount}x</td>
</tr>" );
}
stringBuilder.Append("</table>");
return(stringBuilder);
}
internal static StringBuilder BuildBoonTable(this StringBuilder stringBuilder, RaidModel raidModel)
{
var boonList = CombineBoons(raidModel.Players);
var counter = 0;
var increment = boonList.Count / 2;
while (boonList.Skip(counter).Take(increment).Any())
{
stringBuilder.Append(@"<table class=""boonTable"" style=""display: none;"">");
var boonHeader = @"<tr>";
var boonBody = @"<tr>";
foreach (var boon in boonList.Skip(counter).Take(6))
{
boonHeader += $@"
<th class=""boonColumn"">
<img src=""{boon.Icon}"" class=""boonIcon"" title=""{boon.Name}"">
</th>" ;
if (boon.Stacking && boon.Stacks != null)
{
boonBody += $@"
<td class=""boonColumn"" title=""{Math.Round((double)boon.Stacks, 0)}%"">
{Math.Round(boon.Value, 0)}
</td>" ;
}
else
{
boonBody += $@"
<td class=""boonColumn"">
{Math.Round(boon.Value, 0)}%
</td>" ;
}
}
boonHeader += @"</tr>";
boonBody += @"</tr>";
stringBuilder.Append(boonHeader);
stringBuilder.Append(boonBody);
stringBuilder.Append("</table>");
counter += increment;
}
return(stringBuilder);
}
private void SelectRaid(RaidModel raidModel)
{
World.ChosenRaid = raidModel;
SceneManager.LoadScene("Raid");
}
private static StringBuilder BuildCommonHtml(this StringBuilder stringBuilder, RaidModel model)
{
return(stringBuilder.BuildEncounterHeader(model)
.BuildDamagePerSecondTable(model)
.BuildCrowdControlTable(model)
.BuildResurrectionTable(model)
.BuildBoonTable(model)
.BuildMechanicsTable(model)
.BuildEncounterFooter());
}
internal static StringBuilder BuildMechanicsTable(this StringBuilder stringBuilder, RaidModel raidModel)
{
var strategy = MechanicsFactory
.GetMechanicsFactory()
.FindStrategy(raidModel.EncounterIcon);
if (strategy != null)
{
stringBuilder.Append(strategy.CreateHtml(raidModel));
}
return(stringBuilder);
}
internal static StringBuilder BuildCrowdControlTable(this StringBuilder stringBuilder, RaidModel raidModel)
{
stringBuilder.Append(@"<table class=""ccTable"" style=""display: none;"">");
var allCc = raidModel.Players.Sum(i => i.Cc) != 0 ? raidModel.Players.Sum(i => i.Cc) : 1;
foreach (var player in raidModel.Players.OrderByDescending(i => i.Cc).Take(3))
{
stringBuilder.Append($@"
<tr>
<td>{HttpUtility.HtmlEncode(player.AccountName)}</td>
<td title=""Total CC: {player.Cc}"">{player.Cc} cc</td>
<td>{Math.Round((double)player.Cc / allCc * 100, 2):F}%</td>
</tr>" );
}
stringBuilder.Append("</table>");
return(stringBuilder);
}
internal static StringBuilder BuildDamagePerSecondTable(this StringBuilder stringBuilder, RaidModel raidModel)
{
stringBuilder.Append(@"<table class=""dpsTable"">");
var allDamage = raidModel.Players.Sum(i => i.Damage) != 0 ? raidModel.Players.Sum(i => i.Damage) : 1;
foreach (var player in raidModel.Players.OrderByDescending(i => i.Dps).Take(3))
{
stringBuilder.Append($@"
<tr>
<td>{HttpUtility.HtmlEncode(player.AccountName)}</td>
<td title=""Total Damage: {player.Damage}"">{player.Dps} dps</td>
<td>{Math.Round((double)player.Damage / allDamage * 100, 2):F}%</td>
</tr>" );
}
stringBuilder.Append("</table>");
return(stringBuilder);
}
public abstract string CreateHtml(RaidModel model);
