public object Clone()
{
var powerEntry = new PowerEntry(Level, Power, Chosen)
{
StatInclude = StatInclude,
ProcInclude = ProcInclude,
Tag = Tag,
VariableValue = VariableValue,
SubPowers = (PowerSubEntry[])SubPowers.Clone(),
Slots = new SlotEntry[Slots.Length]
};
for (var index = 0; index < SlotCount; ++index)
{
powerEntry.Slots[index].Level = Slots[index].Level;
powerEntry.Slots[index].Enhancement = Slots[index].Enhancement.Clone() as I9Slot;
powerEntry.Slots[index].FlippedEnhancement = Slots[index].FlippedEnhancement.Clone() as I9Slot;
}
return(powerEntry);
}
public void Assign(PowerEntry iPe)
{
Level = iPe.Level;
NIDPowerset = iPe.NIDPowerset;
IDXPower = iPe.IDXPower;
NIDPower = iPe.NIDPower;
Tag = iPe.Tag;
StatInclude = iPe.StatInclude;
VariableValue = iPe.VariableValue;
ProcInclude = iPe.ProcInclude;
if (iPe.Slots != null)
{
Slots = new SlotEntry[iPe.Slots.Length];
for (var index = 0; index <= Slots.Length - 1; ++index)
{
Slots[index].Assign(iPe.Slots[index]);
}
}
else
{
Slots = new SlotEntry[0];
}
if (iPe.SubPowers != null)
{
SubPowers = new PowerSubEntry[iPe.SubPowers.Length];
for (var index = 0; index <= SubPowers.Length - 1; ++index)
{
SubPowers[index].Assign(iPe.SubPowers[index]);
}
}
else
{
SubPowers = new PowerSubEntry[0];
}
}
private static bool MxDReadSaveData(ref byte[] buffer, bool silent)
{
InherentPowers = new List <PowerEntry>();
DisplayIndex = -1;
if (buffer.Length < 1)
{
MessageBox.Show("Unable to read data - Empty Buffer.", "ReadSaveData Failed");
return(false);
}
MemoryStream memoryStream;
BinaryReader r;
try
{
memoryStream = new MemoryStream(buffer, false);
r = new BinaryReader(memoryStream);
r.BaseStream.Seek(0L, SeekOrigin.Begin);
}
catch (Exception ex)
{
MessageBox.Show("Unable to read data - " + ex.Message, "ReadSaveData Failed");
return(false);
}
try
{
var streamIndex = 0;
bool magicFound;
// try to find magic number, reading 4 bytes at a time, offset by 1 on each failure
do
{
r.BaseStream.Seek(streamIndex, SeekOrigin.Begin);
var numArray = r.ReadBytes(4);
if (numArray.Length >= 4)
{
magicFound = true;
for (var index = 0; index < MagicNumber.Length; ++index)
{
if (MagicNumber[index] != numArray[index])
{
magicFound = false;
}
}
if (!magicFound)
{
++streamIndex;
}
}
else
{
if (!silent)
{
MessageBox.Show("Unable to read data - Magic Number not found.", "ReadSaveData Failed");
}
r.Close();
memoryStream.Close();
return(false);
}
} while (!magicFound);
var fVersion = r.ReadSingle();
if (fVersion > 2.0)
{
MessageBox.Show(
"File was saved by a newer version of the application. Please obtain the most recent release in order to open this file.",
"Unable to Load");
r.Close();
memoryStream.Close();
return(false);
}
var qualifiedNames = r.ReadBoolean();
var hasSubPower = r.ReadBoolean();
var nIDClass = DatabaseAPI.NidFromUidClass(r.ReadString());
if (nIDClass < 0)
{
if (!silent)
{
MessageBox.Show("Unable to read data - Invalid Class UID.", "ReadSaveData Failed");
}
r.Close();
memoryStream.Close();
return(false);
}
var iOrigin = DatabaseAPI.NidFromUidOrigin(r.ReadString(), nIDClass);
MidsContext.Character.Reset(DatabaseAPI.Database.Classes[nIDClass], iOrigin);
if (fVersion > 1.0)
{
var align = r.ReadInt32();
MidsContext.Character.Alignment = (Enums.Alignment)align;
}
MidsContext.Character.Name = r.ReadString();
var powerSetCount = r.ReadInt32();
var expectedArrayLength = new IPowerset[powerSetCount + 1].Length;
var names = new List <string>();
for (var index = 0; index < powerSetCount + 1; ++index)
{
var iName = r.ReadString();
names.Add(iName);
}
var errors = MidsContext.Character.LoadPowersetsByName(names);
foreach (var(i, n) in errors)
{
MessageBox.Show($"Failed to load powerset by name:{n} at {i}", "Powerset load failure");
}
MidsContext.Character.CurrentBuild.LastPower = r.ReadInt32() - 1;
var pEntryList = new List <PowerEntry>();
var powerCount = r.ReadInt32();
try
{
for (var powerIndex = 0; powerIndex <= powerCount; ++powerIndex)
{
var nId = -1;
var name1 = string.Empty;
var sidPower1 = -1;
if (qualifiedNames)
{
name1 = r.ReadString();
if (!string.IsNullOrEmpty(name1))
{
nId = DatabaseAPI.NidFromUidPower(name1);
}
}
else
{
sidPower1 = r.ReadInt32();
nId = DatabaseAPI.NidFromStaticIndexPower(sidPower1);
}
var flag5 = false;
PowerEntry powerEntry1;
if (powerIndex < MidsContext.Character.CurrentBuild.Powers.Count)
{
powerEntry1 = MidsContext.Character.CurrentBuild.Powers[powerIndex];
}
else
{
powerEntry1 = new PowerEntry();
flag5 = true;
}
if ((sidPower1 > -1) | !string.IsNullOrEmpty(name1))
{
powerEntry1.Level = r.ReadSByte();
powerEntry1.StatInclude = r.ReadBoolean();
powerEntry1.VariableValue = r.ReadInt32();
if (hasSubPower)
{
powerEntry1.SubPowers = new PowerSubEntry[r.ReadSByte() + 1];
for (var subPowerIndex = 0; subPowerIndex < powerEntry1.SubPowers.Length; ++subPowerIndex)
{
var powerSub = new PowerSubEntry();
powerEntry1.SubPowers[subPowerIndex] = powerSub;
if (qualifiedNames)
{
var name2 = r.ReadString();
if (!string.IsNullOrEmpty(name2))
{
powerSub.nIDPower = DatabaseAPI.NidFromUidPower(name2);
}
}
else
{
var sidPower2 = r.ReadInt32();
powerSub.nIDPower = DatabaseAPI.NidFromStaticIndexPower(sidPower2);
}
if (powerSub.nIDPower > -1)
{
powerSub.Powerset = DatabaseAPI.Database.Power[powerSub.nIDPower].PowerSetID;
powerSub.Power = DatabaseAPI.Database.Power[powerSub.nIDPower].PowerSetIndex;
}
powerSub.StatInclude = r.ReadBoolean();
if (!((powerSub.nIDPower > -1) & powerSub.StatInclude))
{
continue;
}
var powerEntry2 = new PowerEntry(DatabaseAPI.Database.Power[powerSub.nIDPower])
{
StatInclude = true
};
MidsContext.Character.CurrentBuild.Powers.Add(powerEntry2);
}
}
}
if (nId < 0 && powerIndex < DatabaseAPI.Database.Levels_MainPowers.Length)
{
powerEntry1.Level = DatabaseAPI.Database.Levels_MainPowers[powerIndex];
}
powerEntry1.Slots = new SlotEntry[r.ReadSByte() + 1];
for (var index3 = 0; index3 < powerEntry1.Slots.Length; ++index3)
{
powerEntry1.Slots[index3] = new SlotEntry
{
Level = r.ReadSByte(),
Enhancement = new I9Slot(),
FlippedEnhancement = new I9Slot()
};
ReadSlotData(r, ref powerEntry1.Slots[index3].Enhancement, qualifiedNames, fVersion);
if (r.ReadBoolean())
{
ReadSlotData(r, ref powerEntry1.Slots[index3].FlippedEnhancement, qualifiedNames, fVersion);
}
}
if (powerEntry1.SubPowers.Length > 0)
{
nId = -1;
}
if (nId <= -1)
{
continue;
}
powerEntry1.NIDPower = nId;
powerEntry1.NIDPowerset = DatabaseAPI.Database.Power[nId].PowerSetID;
powerEntry1.IDXPower = DatabaseAPI.Database.Power[nId].PowerSetIndex;
if (powerEntry1.Level == 0 && powerEntry1.Power.FullSetName == "Pool.Fitness")
{
if (powerEntry1.NIDPower == 2553)
{
powerEntry1.NIDPower = 1521;
}
if (powerEntry1.NIDPower == 2554)
{
powerEntry1.NIDPower = 1523;
}
if (powerEntry1.NIDPower == 2555)
{
powerEntry1.NIDPower = 1522;
}
if (powerEntry1.NIDPower == 2556)
{
powerEntry1.NIDPower = 1524;
}
powerEntry1.NIDPowerset = DatabaseAPI.Database.Power[nId].PowerSetID;
powerEntry1.IDXPower = DatabaseAPI.Database.Power[nId].PowerSetIndex;
}
var ps = powerEntry1.Power?.GetPowerSet();
if (powerIndex < MidsContext.Character.CurrentBuild.Powers.Count)
{
if (powerEntry1.Power != null && !(!MidsContext.Character.CurrentBuild.Powers[powerIndex].Chosen & (ps != null && ps.nArchetype > -1 || powerEntry1.Power.GroupName == "Pool")))
{
flag5 = !MidsContext.Character.CurrentBuild.Powers[powerIndex].Chosen;
}
else
{
continue;
}
}
if (flag5)
{
if (powerEntry1.Power.InherentType != Enums.eGridType.None)
{
InherentPowers.Add(powerEntry1);
}
//Console.WriteLine($"{powerEntry1.Power.DisplayName} - {powerEntry1.Power.InherentType}");
//MidsContext.Character.CurrentBuild.Powers.Add(powerEntry1);
}
else if (powerEntry1.Power != null && (ps != null && ps.nArchetype > -1 || powerEntry1.Power.GroupName == "Pool"))
{
MidsContext.Character.CurrentBuild.Powers[powerIndex] = powerEntry1;
}
}
var newPowerList = new List <PowerEntry>();
newPowerList.AddRange(SortGridPowers(InherentPowers, Enums.eGridType.Class));
newPowerList.AddRange(SortGridPowers(InherentPowers, Enums.eGridType.Inherent));
newPowerList.AddRange(SortGridPowers(InherentPowers, Enums.eGridType.Powerset));
newPowerList.AddRange(SortGridPowers(InherentPowers, Enums.eGridType.Power));
newPowerList.AddRange(SortGridPowers(InherentPowers, Enums.eGridType.Prestige));
newPowerList.AddRange(SortGridPowers(InherentPowers, Enums.eGridType.Incarnate));
newPowerList.AddRange(SortGridPowers(InherentPowers, Enums.eGridType.Accolade));
newPowerList.AddRange(SortGridPowers(InherentPowers, Enums.eGridType.Pet));
newPowerList.AddRange(SortGridPowers(InherentPowers, Enums.eGridType.Temp));
foreach (var entry in newPowerList)
{
MidsContext.Character.CurrentBuild.Powers.Add(entry);
}
}
catch (Exception ex)
{
if (!silent)
{
MessageBox.Show($"Error reading some power data, will attempt to build character with known data.\r\n{ex.Message}\r\n\r\n{ex.StackTrace}", "ReadSaveData Failed");
}
return(false);
}
MidsContext.Archetype = MidsContext.Character.Archetype;
MidsContext.Character.Validate();
MidsContext.Character.Lock();
return(true);
}
catch (Exception ex)
{
if (!silent)
{
MessageBox.Show("Unable to read data - " + ex.Message, "ReadSaveData Failed");
}
return(false);
}
}
private static List <PowerEntry> SortGridPowers(List <PowerEntry> powerList, Enums.eGridType iType)
{
var tList = powerList.FindAll(x => x.Power.InherentType == iType);
var tempList = new PowerEntry[tList.Count];
for (var eIndex = 0; eIndex < tList.Count; eIndex++)
{
var power = tList[eIndex];
switch (power.Power.InherentType)
{
case Enums.eGridType.Class:
tempList[eIndex] = power;
break;
case Enums.eGridType.Inherent:
switch (power.Power.PowerName)
{
case "Brawl":
tempList[0] = power;
break;
case "Sprint":
tempList[1] = power;
break;
case "Rest":
tempList[2] = power;
break;
case "Swift":
tempList[3] = power;
break;
case "Hurdle":
tempList[4] = power;
break;
case "Health":
tempList[5] = power;
break;
case "Stamina":
tempList[6] = power;
break;
}
break;
case Enums.eGridType.Powerset:
tempList[eIndex] = power;
break;
case Enums.eGridType.Power:
tempList[eIndex] = power;
break;
case Enums.eGridType.Prestige:
tempList[eIndex] = power;
break;
case Enums.eGridType.Incarnate:
tempList[eIndex] = power;
break;
case Enums.eGridType.Accolade:
power.Level = 49;
tempList[eIndex] = power;
break;
case Enums.eGridType.Pet:
tempList[eIndex] = power;
break;
case Enums.eGridType.Temp:
tempList[eIndex] = power;
break;
}
}
var outList = tempList.ToList();
return(outList);
}