public void Assign(PowerSubEntry iPowerSubEntry)
{
this.Powerset = iPowerSubEntry.Powerset;
this.Power = iPowerSubEntry.Power;
this.nIDPower = iPowerSubEntry.nIDPower;
this.StatInclude = iPowerSubEntry.StatInclude;
}
public void Assign(PowerSubEntry iPowerSubEntry)
{
Powerset = iPowerSubEntry.Powerset;
Power = iPowerSubEntry.Power;
nIDPower = iPowerSubEntry.nIDPower;
StatInclude = iPowerSubEntry.StatInclude;
}
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;
if (iPe.Slots != null)
{
Slots = new SlotEntry[iPe.Slots.Length];
for (int 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 (int index = 0; index <= SubPowers.Length - 1; ++index)
{
SubPowers[index].Assign(iPe.SubPowers[index]);
}
}
else
{
SubPowers = new PowerSubEntry[0];
}
}
public PowerEntry(int iLevel = -1, IPower power = null, bool chosen = false)
{
StatInclude = false;
Level = iLevel;
Chosen = chosen;
if (power != null)
{
NIDPowerset = power.PowerSetID;
IDXPower = power.PowerSetIndex;
NIDPower = power.PowerIndex;
if (power.NIDSubPower.Length > 0)
{
SubPowers = new PowerSubEntry[power.NIDSubPower.Length];
for (int index = 0; index <= SubPowers.Length - 1; ++index)
{
SubPowers[index] = new PowerSubEntry
{
nIDPower = power.NIDSubPower[index]
};
SubPowers[index].Powerset = DatabaseAPI.Database.Power[SubPowers[index].nIDPower].PowerSetID;
SubPowers[index].Power = DatabaseAPI.Database.Power[SubPowers[index].nIDPower].PowerSetIndex;
}
}
else
{
SubPowers = new PowerSubEntry[0];
}
if (power.Slottable & power.GetPowerSet().GroupName != "Incarnate")
{
Slots = new SlotEntry[1];
Slots[0].Enhancement = new I9Slot();
Slots[0].FlippedEnhancement = new I9Slot();
Slots[0].Level = iLevel;
}
else
{
Slots = new SlotEntry[0];
}
if (power.AlwaysToggle | power.PowerType == Enums.ePowerType.Auto_)
{
StatInclude = true;
}
}
else
{
IDXPower = -1;
NIDPowerset = -1;
NIDPower = -1;
Slots = new SlotEntry[0];
SubPowers = new PowerSubEntry[0];
}
Tag = false;
VariableValue = 0;
}
public void Reset()
{
NIDPowerset = -1;
IDXPower = -1;
NIDPower = -1;
Tag = false;
StatInclude = false;
SubPowers = new PowerSubEntry[0];
if (Slots.Length != 1 || Slots[0].Enhancement.Enh != -1)
{
return;
}
Slots = new SlotEntry[0];
}
public PowerEntry(IPower power)
{
StatInclude = false;
Level = -1;
if (power == null)
{
IDXPower = -1;
NIDPowerset = -1;
NIDPower = -1;
}
else
{
IDXPower = power.PowerSetIndex;
NIDPower = power.PowerIndex;
NIDPowerset = power.PowerSetID;
}
Tag = false;
Slots = new SlotEntry[0];
SubPowers = new PowerSubEntry[0];
VariableValue = 0;
}
static bool MxDReadSaveData(ref byte[] buffer, bool silent)
{
if (buffer.Length < 1)
{
MessageBox.Show("Unable to read data - Empty Buffer.", "ReadSaveData Failed");
return(false);
}
else
{
MemoryStream memoryStream;
BinaryReader reader;
try
{
memoryStream = new MemoryStream(buffer, writable: false);
reader = new BinaryReader(memoryStream);
reader.BaseStream.Seek(0L, SeekOrigin.Begin);
}
catch (Exception ex)
{
MessageBox.Show("Unable to read data - " + ex.Message, "ReadSaveData Failed");
return(false);
}
try
{
int streamIndex = 0;
bool magicFound;
// try to find magic number, reading 4 bytes at a time, offset by 1 on each failure
do
{
reader.BaseStream.Seek(streamIndex, SeekOrigin.Begin);
var numArray = reader.ReadBytes(4);
if (numArray.Length >= 4)
{
magicFound = true;
for (int 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");
}
reader.Close();
memoryStream.Close();
return(false);
}
}while (!magicFound);
float fVersion = reader.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");
reader.Close();
memoryStream.Close();
return(false);
}
else
{
bool qualifiedNames = reader.ReadBoolean();
bool hasSubPower = reader.ReadBoolean();
int nIDClass = DatabaseAPI.NidFromUidClass(reader.ReadString());
if (nIDClass < 0)
{
if (!silent)
{
MessageBox.Show("Unable to read data - Invalid Class UID.", "ReadSaveData Failed");
}
reader.Close();
memoryStream.Close();
return(false);
}
else
{
int iOrigin = DatabaseAPI.NidFromUidOrigin(reader.ReadString(), nIDClass);
MidsContext.Character.Reset(DatabaseAPI.Database.Classes[nIDClass], iOrigin);
if (fVersion > 1.0)
{
int align = reader.ReadInt32();
MidsContext.Character.Alignment = (Enums.Alignment)align;
}
MidsContext.Character.Name = reader.ReadString();
int num4 = reader.ReadInt32();
if (MidsContext.Character.Powersets.Length - 1 != num4)
{
MidsContext.Character.Powersets = new IPowerset[num4 + 1];
}
for (int index = 0; index < MidsContext.Character.Powersets.Length; ++index)
{
string iName = reader.ReadString();
MidsContext.Character.Powersets[index] = !string.IsNullOrEmpty(iName) ? DatabaseAPI.GetPowersetByName(iName) : null;
}
MidsContext.Character.CurrentBuild.LastPower = reader.ReadInt32() - 1;
int powerCount = reader.ReadInt32();
try
{
for (int powerIndex = 0; powerIndex <= powerCount; ++powerIndex)
{
int nId = -1;
string name1 = "";
int sidPower1 = -1;
if (qualifiedNames)
{
name1 = reader.ReadString();
if (!string.IsNullOrEmpty(name1))
{
nId = DatabaseAPI.NidFromUidPower(name1);
}
}
else
{
sidPower1 = reader.ReadInt32();
nId = DatabaseAPI.NidFromStaticIndexPower(sidPower1);
}
bool flag5 = false;
PowerEntry powerEntry1;
if (powerIndex < MidsContext.Character.CurrentBuild.Powers.Count)
{
powerEntry1 = MidsContext.Character.CurrentBuild.Powers[powerIndex];
}
else
{
powerEntry1 = new PowerEntry(-1, null, false);
flag5 = true;
}
if (sidPower1 > -1 | !string.IsNullOrEmpty(name1))
{
powerEntry1.Level = reader.ReadSByte();
powerEntry1.StatInclude = reader.ReadBoolean();
powerEntry1.VariableValue = reader.ReadInt32();
if (hasSubPower)
{
powerEntry1.SubPowers = new PowerSubEntry[reader.ReadSByte() + 1];
for (int subPowerIndex = 0; subPowerIndex < powerEntry1.SubPowers.Length; ++subPowerIndex)
{
var powerSub = new PowerSubEntry();
powerEntry1.SubPowers[subPowerIndex] = powerSub;
if (qualifiedNames)
{
string name2 = reader.ReadString();
if (!string.IsNullOrEmpty(name2))
{
powerSub.nIDPower = DatabaseAPI.NidFromUidPower(name2);
}
}
else
{
int sidPower2 = reader.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 = reader.ReadBoolean();
if (powerSub.nIDPower > -1 & powerSub.StatInclude)
{
PowerEntry 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[reader.ReadSByte() + 1];
for (var index3 = 0; index3 < powerEntry1.Slots.Length; ++index3)
{
powerEntry1.Slots[index3] = new SlotEntry()
{
Level = reader.ReadSByte(),
Enhancement = new I9Slot(),
FlippedEnhancement = new I9Slot()
};
ReadSlotData(reader, ref powerEntry1.Slots[index3].Enhancement, qualifiedNames, fVersion);
if (reader.ReadBoolean())
{
ReadSlotData(reader, ref powerEntry1.Slots[index3].FlippedEnhancement, qualifiedNames, fVersion);
}
}
if (powerEntry1.SubPowers.Length > 0)
{
nId = -1;
}
if (nId > -1)
{
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 (!(!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)
{
MidsContext.Character.CurrentBuild.Powers.Add(powerEntry1);
}
else if ((ps != null && ps.nArchetype > -1) || powerEntry1.Power.GroupName == "Pool")
{
MidsContext.Character.CurrentBuild.Powers[powerIndex] = powerEntry1;
}
}
}
}
catch (Exception ex)
{
if (!silent)
{
MessageBox.Show("Error reading some power data, will attempt to build character with known data - " + ex.Message, "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);
}
}
}
