/// <summary>
/// Calculate base stats for a unit.
/// </summary>
/// <param name="character"></param>
/// <returns></returns>
public static Model.Stat CalculateBaseStats(Model.Character character)
{
Model.Stat baseStats = new Model.Stat();
if (!Enum.IsDefined(typeof(Enums.Character), character.CharacterID) ||
!Enum.IsDefined(typeof(Enums.Class), character.ClassID))
{
return(null);
}
var characterData = Data.Database.Characters.GetByID(character.CharacterID);
var classData = Data.Database.Classes.GetByID(character.ClassID);
// Corrin and Bond units
if (character.CorrinName != null)
{
if (Enum.IsDefined(typeof(Enums.Stat), character.Boon) &&
Enum.IsDefined(typeof(Enums.Stat), character.Bane))
{
return(characterData.BaseStats +
Data.Database.Stats.GetByID(character.Boon).BaseBoonModifiers +
Data.Database.Stats.GetByID(character.Bane).BaseBaneModifiers +
classData.BaseStats);
}
else
{
return(null);
}
}
else // All other units
{
return(characterData.BaseStats + classData.BaseStats);
}
}
public Vitals(Model.Character c)
{
character = c;
LastChildFill = false;
Children.Add(new Label {
Content = "Body"
});
Children.Add(body_box);
Children.Add(body_max);
Children.Add(mind_max);
Children.Add(mind_box);
Children.Add(new Label {
Content = "Mind"
});
for (int i = 0; i < 3; i++)
{
DockPanel.SetDock(Children[i], Dock.Left);
}
for (int i = 3; i < 6; i++)
{
DockPanel.SetDock(Children[i], Dock.Right);
}
body_box.Change += v => character.body = v;
mind_box.Change += v => character.mind = v;
Update();
}
// TODO: Revert Corrin
// Remove marriage byte (otherwise paralogue 2 stays available)
/// <summary>
/// Level a unit, giving them the average gains that their growth rates would dictate
/// </summary>
public void LevelUp(Model.Character unit, int levels)
{
var characterGrowthRates = Data.Database.Characters.GetByID(unit.CharacterID).GrowthRates;
var classGrowthRates = Data.Database.Classes.GetByID(unit.ClassID).GrowthRates;
var combinedGrowthRates = characterGrowthRates + classGrowthRates;
int hp; int str; int mag; int skl; int spd; int lck; int def; int res;
hp = str = mag = skl = spd = lck = def = res = 0;
for (var i = 0; i < levels; i++)
{
hp += combinedGrowthRates.HP;
str += combinedGrowthRates.Str;
mag += combinedGrowthRates.Mag;
skl += combinedGrowthRates.Skl;
spd += combinedGrowthRates.Spd;
lck += combinedGrowthRates.Lck;
def += combinedGrowthRates.Def;
res += combinedGrowthRates.Res;
}
unit.Level += (byte)levels;
unit.GainedStats.HP += (sbyte)(hp / 100);
unit.GainedStats.Str += (sbyte)(str / 100);
unit.GainedStats.Mag += (sbyte)(mag / 100);
unit.GainedStats.Skl += (sbyte)(skl / 100);
unit.GainedStats.Spd += (sbyte)(spd / 100);
unit.GainedStats.Lck += (sbyte)(lck / 100);
unit.GainedStats.Def += (sbyte)(def / 100);
unit.GainedStats.Res += (sbyte)(res / 100);
}
public void LoadCharacter(Model.Character character)
{
if (character == null)
{
return;
}
_character = character;
PopulateControls();
}
public void SelectUnit(Model.Character unit)
{
if (lstLiving.Items.IndexOf(unit) > -1)
{
lstLiving.SelectedItem = unit;
}
else if (lstDead.Items.IndexOf(unit) > -1)
{
lstDead.SelectedItem = unit;
}
}
/// <summary>
/// Calculate the true stats for a character
/// </summary>
/// <returns>A character's true stats</returns>
public static Model.Stat CalculateTrueStats(Model.Character character)
{
Model.Stat baseStats = CalculateBaseStats(character);
if (baseStats != null)
{
return(baseStats + character.GainedStats);
}
else
{
return(null);
}
}
private void SelectDeadCharacter(object sender, EventArgs e)
{
var character = (Model.Character)lstDead.SelectedItem;
if (character == null)
{
return;
}
_selectedCharacter = character;
LoadCharacter(character);
lstLiving.ClearSelected();
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if ((null == value) || (false == (value is Model.Character)))
{
return(string.Empty);
}
Model.Character c = value as Model.Character;
string s = string.Format("{0}:{1}", c.Id, c.Name);
return(s);
}
public static void OnOpenChest(Packet packet)
{
CmdOpenChest cmd = new CmdOpenChest(packet);
if (packet.Sender.Character.Token != cmd.Token)
{
packet.SendBackError(12);
return;
}
Model.Character character = packet.Sender.Character;
if (character.CharacterDb.ChestCount > 0)
{
Random rnd = new Random();
int attributeNumber = rnd.Next(0, 4);
int unlockedItemNumber = rnd.Next(0, 8);
var entry = packet.Sender.Character.CharacterDb.Account.Inventory;
switch (attributeNumber)
{
case 0:
entry.Head = Utilities.AddAttributeItem(entry.Head, unlockedItemNumber);
break;
case 1:
entry.Shirt = Utilities.AddAttributeItem(entry.Shirt, unlockedItemNumber);
break;
case 2:
entry.Pant = Utilities.AddAttributeItem(entry.Pant, unlockedItemNumber);
break;
case 3:
entry.Shoe = Utilities.AddAttributeItem(entry.Shoe, unlockedItemNumber);
break;
}
character.CharacterDb.ChestCount--;
var ack = new GetChestRewardAck
{
AttributeNumber = attributeNumber,
ItemNumber = unlockedItemNumber
};
packet.SendBack(ack.CreatePacket());
}
else
{
packet.SendBackError(22);
}
}
public static void HandleAuth(Packet packet)
{
if (packet.Sender.Character != null)
{
packet.Sender.Character.CharacterDb.Account.IsLoggedIn = 0;
ServerMain.Instance.Database.Save();
// Save data
}
// Read the packet into readable format
UserAuthPacket authPkt = new UserAuthPacket(packet);
// Login and Retrieve the User
Controller.Database.Tables.Character character = ServerMain.Instance.Database.GetCharacter(authPkt.Username);
if (character == null || Password.GenerateSaltedHash(authPkt.Password, character.Account.Salt) != character.Account.Password)
{
packet.SendBackError(5);
return;
}
if (character.Account.IsLoggedIn == 1)
{
packet.SendBackError(6);
return;
}
if (character.Account.Permission == 0 && packet.Sender.IsTeacherClient())
{
packet.SendBackError(4);
return;
}
// Prepare the Acknowledgment packet indicating success and token
character.Account.IsLoggedIn = 1;
character.Account.LastLoggedIn = DateTime.Now;
ServerMain.Instance.Database.Save();
Model.Character model = new Model.Character();
model.FromEntity(character);
packet.Sender.Character = model;
var ack = new UserAuthAck()
{
Token = model.Token
};
packet.Sender.Send(ack.CreatePacket());
if (ServerMain.Instance.Server.LoggedInClient.ContainsKey(model.Token))
{
ServerMain.Instance.Server.LoggedInClient.Remove(model.Token);
}
ServerMain.Instance.Server.LoggedInClient.Add(model.Token, packet.Sender);
return;
}
/// <summary>
/// Calculate stat caps for a character
/// </summary>
/// <returns>Character's stat caps</returns>
public static Model.Stat CalculateStatCaps(Model.Character character)
{
if (!Enum.IsDefined(typeof(Enums.Character), character.CharacterID) ||
!Enum.IsDefined(typeof(Enums.Class), character.ClassID))
{
return(null);
}
var characterData = Data.Database.Characters.GetByID(character.CharacterID);
var classData = Data.Database.Classes.GetByID(character.ClassID);
if (character.CorrinName != null) // Corrin and bond units
{
if (Enum.IsDefined(typeof(Enums.Stat), character.Boon) &&
Enum.IsDefined(typeof(Enums.Stat), character.Bane))
{
return(classData.MaximumStats +
Data.Database.Stats.GetByID(character.Boon).MaxBoonModifiers +
Data.Database.Stats.GetByID(character.Bane).MaxBaneModifiers +
character.StatueBonusStats);
}
else
{
return(null);
}
}
else if (characterData.IsChild) // Children
{
var childBonusStats = new Model.Stat {
HP = 0, Str = 1, Mag = 1, Skl = 1, Spd = 1, Lck = 1, Def = 1, Res = 1
};
return(classData.MaximumStats +
Data.Database.Characters.GetByID(character.FatherID).Modifiers +
Data.Database.Stats.GetByID(character.FatherBoon).MaxBoonModifiers +
Data.Database.Stats.GetByID(character.FatherBane).MaxBaneModifiers +
Data.Database.Characters.GetByID(character.MotherID).Modifiers +
Data.Database.Stats.GetByID(character.MotherBoon).MaxBoonModifiers +
Data.Database.Stats.GetByID(character.MotherBane).MaxBaneModifiers +
childBonusStats + character.StatueBonusStats);
}
else // All other units
{
return(classData.MaximumStats + characterData.Modifiers + character.StatueBonusStats);
}
}
public static void HandleRegistration(Packet packet)
{
if (packet.Sender.Character != null)
{
packet.Sender.Character.CharacterDb.Account.IsLoggedIn = 0;
ServerMain.Instance.Database.Save();
}
CmdUserReg registrationPkt = new CmdUserReg(packet);
Log.Debug("{0}", registrationPkt.ToString());
var ack = new UserRegAck();
int code = ServerMain.Instance.Database.CheckIfAccountExist(registrationPkt.Username, registrationPkt.Email);
if (code == 1)
{
packet.SendBackError(7, registrationPkt.Username);
return;
}
else if (code == 2)
{
packet.SendBackError(8, registrationPkt.Email);
return;
}
else if (registrationPkt.Username.Trim() == "" || registrationPkt.Password == "da39a3ee5e6b4b0d3255bfef95601890afd80709")
{
packet.SendBackError(9);
return;
}
else if (!registrationPkt.Email.Contains(".edu."))
{
packet.SendBackError(10);
return;
}
var salt = Password.CreateSalt(Password.SaltSize);
ServerMain.Instance.Database.CreateAccount(registrationPkt.Username, registrationPkt.Email, registrationPkt.Password, registrationPkt.StudentName, registrationPkt.Class, registrationPkt.Year, registrationPkt.Semester, salt);
Controller.Database.Tables.Character character = ServerMain.Instance.Database.GetCharacter(registrationPkt.Username);
Model.Character model = new Model.Character();
model.FromEntity(character);
ack.Token = model.Token;
packet.Sender.Character = model;
packet.Sender.Send(ack.CreatePacket());
ServerMain.Instance.Server.LoggedInClient.Add(model.Token, packet.Sender);
return;
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if ((null == value) || (false == (value is Model.Target)))
{
return(string.Empty);
}
Model.Target t = value as Model.Target;
if (false == ViewModel.Common.Instance.IsValidCharacter(t.CharacterId))
{
return(t.Id);
}
Model.Character c = ViewModel.Common.Instance.CharacterList[t.CharacterId];
string s = string.Format("{0}:{1}", t.Id, c.Name);
return(s);
}
public Character(Model.Character c)
{
ModelObject = c;
Codepoint = "U+" + c.CodepointHex;
Name = c.Name;
if (c.Codepoint <= 32)
{
Value = char.ConvertFromUtf32(0x2400 + c.Codepoint);
HasSpecialValue = true;
}
else if (c.Codepoint == 127)
{
Value = "\u2421";
HasSpecialValue = true;
}
else
{
Value = c.Value;
HasSpecialValue = false;
}
}
private bool IsDead(Model.Character unit)
{
return(unit.UnitBlock == Enums.UnitBlock.DeadByGameplay || unit.UnitBlock == Enums.UnitBlock.DeadByPlot);
}
/// <summary>
/// Load the unit viewer, then jump to a particular unit
/// </summary>
public void LoadUnitViewer(Model.Character unit)
{
LoadUnitViewer();
SelectUnit(unit);
}
public void LoadCharacter(Model.ChapterSave chapterSave, Model.Character unit)
{
_chapterSave = chapterSave;
_unit = unit;
PopulateControls();
}
public Turn(Model.Character c)
{
value = delay(c.stats["NTU"]);
character = c;
}
// Get character
protected void GetCharacter(bool ownCharacter)
{
try
{
Model.Character character = new Model.Character();
if (!ownCharacter)
{
int charID;
if (int.TryParse(Page.RouteData.Values["charID"].ToString(), out charID))
{
character = Service.GetCharacter(charID);
}
else
{
throw new ArgumentException("Felaktigt karaktärsID!");
}
}
else
{
character = Service.GetCharacter(null, int.Parse(Context.User.Identity.Name));
CheckIfLevelUp(character);
}
if (character.Health > 0)
{
CharacterPanel.Visible = true;
CharacterName.Text = character.Name;
CharacterRace.Text = String.Format("Ras: {0}", character.Race);
CharacterLevel.Text = String.Format("Level: {0}", character.Level);
CharacterExperience.Text = String.Format("Erfarenhetspoäng: {0}/{1}", character.Experience, GetNextLevelXP(character));
CharacterHealth.Text = String.Format("Livspoäng: {0}/{1}", character.Health, character.MaxHealth);
CharacterStanima.Text = String.Format("Uthållighetspoäng: {0}/{1}", character.Stanima, character.MaxStanima);
CharacterStrength.Text = String.Format("Styrka: {0}", character.Strength);
CharacterSpeed.Text = String.Format("Snabbhet: {0}", character.Speed);
CharacterAgility.Text = String.Format("Undvika: {0}", character.Agility);
CharacterDexterity.Text = String.Format("Träffsäkerhet: {0}", character.Dexterity);
if (character.Biografy != null)
{
CharacterBiografyLiteral.Text = character.Biografy;
}
else
{
if (ownCharacter)
{
CharacterBiografyLiteral.Text = "Du har inte skrivt någon biografi till din karaktär ännu!";
}
else
{
CharacterBiografyLiteral.Text = "Karaktären har ingen biografi ännu!";
}
}
}
else
{
CharacterDeadPanel.Visible = true;
}
}
catch (SqlException ex)
{
Page.ModelState.AddModelError(String.Empty, ex.Message);
}
catch (ValidationException ex)
{
Page.ModelState.AddModelError(String.Empty, ex.Message);
}
catch (ArgumentException ex)
{
Page.ModelState.AddModelError(String.Empty, ex.Message);
}
catch (ApplicationException ex)
{
Page.ModelState.AddModelError(String.Empty, ex.Message);
}
catch
{
Page.ModelState.AddModelError(String.Empty, "Ett oväntat fel inträffade.");
}
}
protected void CreateCharacter_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
if (CheckNewCharacterPoints())
{
try
{
Model.Character newCharacter = new Model.Character
{
CharID = 0,
UserID = int.Parse(Context.User.Identity.Name),
Race = RaceList.SelectedItem.Text,
Name = Name.Text,
Level = 1,
Experience = 0,
Health = int.Parse(Session["Health"].ToString()),
MaxHealth = int.Parse(Session["Health"].ToString()),
Stanima = int.Parse(Session["Stanima"].ToString()),
MaxStanima = int.Parse(Session["Stanima"].ToString()),
Strength = int.Parse(Session["Strength"].ToString()),
Speed = int.Parse(Session["Speed"].ToString()),
Agility = int.Parse(Session["Agility"].ToString()),
Dexterity = int.Parse(Session["Dexterity"].ToString()),
WeaponID = null,
ShieldID = null,
ArmorID = null,
Biografy = null,
CreatedOn = new DateTime()
};
Service.CreateCharacter(newCharacter, int.Parse(RaceList.SelectedValue));
// Reset all sessions
Session["Health"] = Session["Stanima"] = Session["Strength"] = Session["Speed"] =
Session["Agility"] = Session["Dexterity"] = Session["RaceHealth"] =
Session["RaceStanima"] = Session["RaceStrength"] = Session["RaceSpeed"] =
Session["RaceAgility"] = Session["RaceDexterity"] = Session["Races"] =
Session["NewRace"] = Session["PointsLeft"] = null;
Session["SiteMsg"] = String.Format("Grattis! Du skapade karaktären {0}!", Name.Text);
Response.RedirectToRoute("Character");
}
catch (SqlException ex)
{
Page.ModelState.AddModelError(String.Empty, ex.Message);
}
catch (ValidationException ex)
{
Page.ModelState.AddModelError(String.Empty, ex.Message);
}
catch (ApplicationException ex)
{
Page.ModelState.AddModelError(String.Empty, ex.Message);
}
catch
{
Page.ModelState.AddModelError(String.Empty, "Ett oväntat fel inträffade.");
}
}
else
{
Page.ModelState.AddModelError(String.Empty, "Du har inte satt ut alla poäng!");
}
}
}
public LearnedSkillsViewer(Model.Character character)
{
_character = character;
_tempLearnedSkills = new Model.LearnedSkills(_character.LearnedSkills.Raw.ToArray());
InitializeComponent();
}
private void LoadCharacter(Model.Character character)
{
if (character == null)
{
return;
}
var message = "";
if (Enum.IsDefined(typeof(Enums.Character), character.CharacterID))
{
if (character.CorrinName != null)
{
lblName.Text = character.CorrinName;
}
else if (Data.Database.Characters.GetByID(character.CharacterID).IsPrisoner)
{
lblName.Text = Data.Database.Prisoners.GetByID(character.PrisonerID).DisplayName;
}
else
{
lblName.Text = Data.Database.Characters.GetByID(character.CharacterID).DisplayName;
}
}
else
{
lblName.Text = character.CharacterID.ToString();
}
try { classAndLevel1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Class and Level data"; }
try { stats1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Stats data"; }
try { unitBlockInfo1.LoadCharacter(_chapterSave, _selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Unit Block Info data"; }
try { flags1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Flags data"; }
try { battleData1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Battle data"; }
try { skills1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Skills data"; }
try { inventory1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Inventory data"; }
try { accessories1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Accessories data"; }
try { hairColor1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Hair Color data"; }
try { weaponExperience1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Weapon Experience data"; }
try { dragonVein1.LoadCharacter(_selectedCharacter); }
catch (Exception) { message += Environment.NewLine + "Error loading Dragon Vein data"; }
if (message.Length > 0)
{
message = "One or more values is invalid for this character. You can still use the hex editor, though." + Environment.NewLine + Environment.NewLine + message;
_unitViewerBlanket.SetMessage(message);
_unitViewerBlanket.Cover();
btnOpenHexEditor.BringToFront();
}
else
{
_unitViewerBlanket.Uncover();
}
}
bool CanSelectCharacter(Model.Character character)
{
return(character != null);
}
void SelectCharacter(Model.Character character)
{
_notification.SelectedCharacter = character;
FinishInteraction?.Invoke();
}
/// <summary>
/// Calculate stats for a character
/// </summary>
/// <returns>Character's stats</returns>
public static Model.Stat CalculateStats(Model.Character character)
{
Model.Stat stats = new Model.Stat();
Model.Stat trueStats = CalculateTrueStats(character);
Model.Stat caps = CalculateStatCaps(character);
if (trueStats != null && caps != null)
{
if (trueStats.HP < 0)
{
stats.HP = 0;
}
else if (trueStats.HP < caps.HP)
{
stats.HP = trueStats.HP;
}
else
{
stats.HP = caps.HP;
}
if (trueStats.Str < 0)
{
stats.Str = 0;
}
else if (trueStats.Str < caps.Str)
{
stats.Str = trueStats.Str;
}
else
{
stats.Str = caps.Str;
}
if (trueStats.Mag < 0)
{
stats.Mag = 0;
}
else if (trueStats.Mag < caps.Mag)
{
stats.Mag = trueStats.Mag;
}
else
{
stats.Mag = caps.Mag;
}
if (trueStats.Skl < 0)
{
stats.Skl = 0;
}
else if (trueStats.Skl < caps.Skl)
{
stats.Skl = trueStats.Skl;
}
else
{
stats.Skl = caps.Skl;
}
if (trueStats.Spd < 0)
{
stats.Spd = 0;
}
else if (trueStats.Spd < caps.Spd)
{
stats.Spd = trueStats.Spd;
}
else
{
stats.Spd = caps.Spd;
}
if (trueStats.Lck < 0)
{
stats.Lck = 0;
}
else if (trueStats.Lck < caps.Lck)
{
stats.Lck = trueStats.Lck;
}
else
{
stats.Lck = caps.Lck;
}
if (trueStats.Def < 0)
{
stats.Def = 0;
}
else if (trueStats.Def < caps.Def)
{
stats.Def = trueStats.Def;
}
else
{
stats.Def = caps.Def;
}
if (trueStats.Res < 0)
{
stats.Res = 0;
}
else if (trueStats.Res < caps.Res)
{
stats.Res = trueStats.Res;
}
else
{
stats.Res = caps.Res;
}
}
else
{
stats = null;
}
return(stats);
}
public HexEditor(Model.Character character)
{
_character = character;
InitializeComponent();
SetTitle();
}
public void LoadCharacter(Model.Character character)
{
_character = character;
PopulateControls();
}
private void WriteCurrentCharacter(BinaryWriter bw, Model.Character character)
{
byte[] chunk;
bw.BaseStream.Seek(character.BinaryPosition, SeekOrigin.Begin);
// TODO
bw.BaseStream.Seek(1, SeekOrigin.Current);
// Flags
chunk = new byte[8];
bw.BaseStream.Read(chunk, 0, 8);
if (character.IsManakete && !Model.Character.IsCorrin(character.CharacterID))
{
chunk[2] |= 0x80;
}
else
{
chunk[2] &= 0x7F;
}
if (character.IsBeast && !Model.Character.IsBeastCharacter(character.CharacterID))
{
chunk[3] |= 0x01;
}
else
{
chunk[3] &= 0xFE;
}
if (character.CanUseDragonVein && !Model.Character.IsRoyal(character.CharacterID))
{
chunk[4] |= 0x08;
}
else
{
chunk[4] &= 0xF7;
}
bw.BaseStream.Seek(-8, SeekOrigin.Current);
bw.BaseStream.Write(chunk, 0, 8);
// Character main data
chunk = new byte[] {
character.Level,
character.Experience,
character.InternalLevel,
character.EternalSealsUsed,
(byte)((ushort)character.CharacterID & 0xFF),
(byte)(((ushort)character.CharacterID >> 8) & 0xFF),
(byte)character.ClassID,
character.Unknown011
};
bw.Write(chunk);
// TODO
bw.BaseStream.Seek(46, SeekOrigin.Current);
// Weapon exp
chunk = new byte[] {
character.WeaponExperience_Sword,
character.WeaponExperience_Lance,
character.WeaponExperience_Axe,
character.WeaponExperience_Shuriken,
character.WeaponExperience_Bow,
character.WeaponExperience_Tome,
character.WeaponExperience_Staff,
character.WeaponExperience_Stone
};
bw.Write(chunk);
// Max HP
bw.BaseStream.Seek(1, SeekOrigin.Current);
// Filler - FF FF FF FF
bw.BaseStream.Seek(4, SeekOrigin.Current);
// Flags block (shield, dead, etc)
bw.BaseStream.Seek(5, SeekOrigin.Current);
// Filler - 00 00 00 FF FF 00
bw.BaseStream.Seek(6, SeekOrigin.Current);
// TODO
bw.BaseStream.Seek(2, SeekOrigin.Current);
// Skills
bw.BaseStream.Seek(10, SeekOrigin.Current);
// Inventory
bw.BaseStream.Seek(25, SeekOrigin.Current);
// Supports
int supportCount = bw.BaseStream.ReadByte();
if (supportCount > 0)
{
bw.BaseStream.Seek(supportCount, SeekOrigin.Current);
}
// TODO
bw.BaseStream.Seek(7, SeekOrigin.Current);
// Boots
bw.Write(character.Boots);
// TODO
bw.BaseStream.Seek(9, SeekOrigin.Current);
// DLC class flags
bw.Write(character.DLCClassFlags);
// Hair color
bw.Write(character.HairColor);
// TODO
bw.BaseStream.Seek(47, SeekOrigin.Current);
// Learned skills
bw.Write(character.LearnedSkills);
// Stuff only on deployed characters
if (character.IsDeployed)
{
bw.BaseStream.Seek(54, SeekOrigin.Current);
}
// TODO
bw.BaseStream.Seek(5, SeekOrigin.Current);
// Accessories
chunk = new byte[] {
(byte)character.Headwear,
(byte)character.Facewear,
(byte)character.Armwear,
(byte)character.Underwear
};
bw.Write(chunk);
// TODO
bw.BaseStream.Seek(1, SeekOrigin.Current);
// Battles and Victories
bw.Write(BitConverter.GetBytes(character.BattleCount));
bw.Write(BitConverter.GetBytes(character.VictoryCount));
// TODO
bw.BaseStream.Seek(5, SeekOrigin.Current);
// Determine end block size
int endBlockSize;
int endByte = bw.BaseStream.ReadByte();
switch (endByte)
{
case 0x04:
endBlockSize = 44;
break;
case 0x01:
endBlockSize = 42;
break;
default:
endBlockSize = 0;
break;
}
// TODO
bw.BaseStream.Seek(endBlockSize, SeekOrigin.Current);
}
