public void WriteToDataset(CardDataset cds, CardPart part)
{
if (part == CardPart.Program)
{
CardDataset.EngineRow er;
CardDataset.FlagRow fr;
for (int i = 0; i < cds.Engine.Count; i++)
{
cds.Engine.RemoveEngineRow(cds.Engine [i]);
}
er = cds.Engine.NewEngineRow();
er.AngleUnit = unit.ToString();
er.FlagCount = flags.Length;
er.CardRow = cds.Card [0];
cds.Engine.AddEngineRow(er);
for (int i = 0; i < flags.Length; i++)
{
fr = cds.Flag.NewFlagRow();
fr.Id = i;
fr.Value = flags [i];
fr.EngineRow = er;
cds.Flag.AddFlagRow(fr);
}
}
}
public void WriteToDataset(CardDataset cds, CardPart part)
{
if (part == CardPart.Data)
{
CardDataset.MemoryRow mr;
CardDataset.RegisterRow rr;
for (int i = 0; i < cds.Memory.Count; i++)
{
cds.Memory.RemoveMemoryRow(cds.Memory [i]);
}
mr = cds.Memory.NewMemoryRow();
mr.RegisterCount = registers.Length;
mr.CardRow = cds.Card [0];
cds.Memory.AddMemoryRow(mr);
for (int i = 0; i < registers.Length; i++)
{
rr = cds.Register.NewRegisterRow();
rr.Id = i;
// rr.Value = ...; // Not used anymore!
registers [i].WriteToRow(rr);
rr.MemoryRow = mr;
cds.Register.AddRegisterRow(rr);
}
}
}
static public void Read(Stream stream, Reader reader)
{
CardDataset cds = new CardDataset();
cds.ReadXml(stream);
CheckVersion(cds);
ReadFromDataset(cds, reader);
}
public void WriteToDataset(CardDataset cds, CardPart part)
{
if (part == CardPart.Program)
{
// Note that we write 1-based step numbers, in case someone wants to look at the
// generated XML.
CardDataset.ArgumentRow ar;
CardDataset.InstructionRow ir;
CardDataset.LabelRow lr;
CardDataset.ProgramRow pr;
CardDataset.StepRow sr;
for (int i = 0; i < cds.Program.Count; i++)
{
cds.Program.RemoveProgramRow(cds.Program [i]);
}
pr = cds.Program.NewProgramRow();
pr.InstructionCount = instructions.Length;
pr.LabelCount = labels.Length;
pr.CardRow = cds.Card [0];
cds.Program.AddProgramRow(pr);
for (int i = 0; i < instructions.Length; i++)
{
ir = cds.Instruction.NewInstructionRow();
ir.Step = i + 1;
ir.Instruction = instructions [i].Symbol.Name;
ir.ArgumentCount = instructions [i].Arguments.Length;
ir.ProgramRow = pr;
cds.Instruction.AddInstructionRow(ir);
for (int j = 0; j < instructions [i].Arguments.Length; j++)
{
Argument argument = instructions [i].Arguments [j];
ar = cds.Argument.NewArgumentRow();
ar.Id = j;
argument.WriteToArgumentRow(ar);
ar.InstructionRow = ir;
cds.Argument.AddArgumentRow(ar);
}
}
for (int i = 0; i < labels.Length; i++)
{
lr = cds.Label.NewLabelRow();
lr.Id = i;
lr.StepCount = labels [i].Count;
lr.ProgramRow = pr;
cds.Label.AddLabelRow(lr);
for (int j = 0; j < labels [i].Count; j++)
{
sr = cds.Step.NewStepRow();
sr.Step = (int)labels [i] [j] + 1;
sr.LabelRow = lr;
cds.Step.AddStepRow(sr);
}
}
}
}
public void MergeFromDataset(CardDataset cds, Reader reader)
{
CardDataset.ArgumentRow [] ars;
CardDataset.CardRow cr;
CardDataset.InstructionRow [] irs;
CardDataset.ProgramRow pr;
CardDataset.ProgramRow [] prs;
bool sourceProgramIsEmpty;
cr = cds.Card [0];
prs = cr.GetProgramRows();
if (prs.Length > 0)
{
pr = prs [0];
irs = pr.GetInstructionRows();
// A source program that only contains R/S is considered empty. No merge takes
// place in this case.
sourceProgramIsEmpty = true;
foreach (CardDataset.InstructionRow ir in irs)
{
if (reader.ToSymbol(ir.Instruction).Id != (int)SymbolConstants.SYMBOL_R_S)
{
sourceProgramIsEmpty = false;
break;
}
}
if (!sourceProgramIsEmpty)
{
foreach (CardDataset.InstructionRow ir in irs)
{
Argument [] arguments = new Argument [ir.ArgumentCount];
if (next == instructions.Length - 1)
{
break;
}
ars = ir.GetArgumentRows();
foreach (CardDataset.ArgumentRow ar in ars)
{
Argument argument;
argument = (Argument)Argument.ReadFromArgumentRow(ar);
arguments [ar.Id] = argument;
}
// We have to go through instruction insertion to make sure that the label
// table is properly updated.
Insert(new Instruction(reader,
reader.ToSymbol(ir.Instruction),
arguments));
}
isEmpty = false;
}
}
}
public void ReadFromDataset(CardDataset cds, Reader reader)
{
// Beware, the XML file uses 1-based step numbers, but we must go back to 0-based
// numbers internally.
CardDataset.ArgumentRow [] ars;
CardDataset.CardRow cr;
CardDataset.InstructionRow [] irs;
CardDataset.LabelRow [] lrs;
CardDataset.ProgramRow pr;
CardDataset.ProgramRow [] prs;
CardDataset.StepRow [] srs;
cr = cds.Card [0];
prs = cr.GetProgramRows();
isEmpty = true;
if (prs.Length > 0)
{
pr = prs [0];
instructions = new Instruction [pr.InstructionCount];
irs = pr.GetInstructionRows();
foreach (CardDataset.InstructionRow ir in irs)
{
Argument [] arguments = new Argument [ir.ArgumentCount];
if (reader.ToSymbol(ir.Instruction).Id != (int)SymbolConstants.SYMBOL_R_S)
{
isEmpty = false;
}
ars = ir.GetArgumentRows();
foreach (CardDataset.ArgumentRow ar in ars)
{
Argument argument;
argument = (Argument)Argument.ReadFromArgumentRow(ar);
arguments [ar.Id] = argument;
}
instructions [ir.Step - 1] =
new Instruction(reader, reader.ToSymbol(ir.Instruction), arguments);
}
labels = new ArrayList [pr.LabelCount];
lrs = pr.GetLabelRows();
foreach (CardDataset.LabelRow lr in lrs)
{
labels [lr.Id] = new ArrayList();
srs = lr.GetStepRows();
foreach (CardDataset.StepRow sr in srs)
{
labels [lr.Id].Add(sr.Step - 1);
}
// Should already be sorted, but just to be safe...
labels [lr.Id].Sort();
}
}
}
public void ReadFromDataset(CardDataset cds, Reader reader)
{
CardDataset.CardRow cr;
CardDataset.DisplayRow dr;
CardDataset.DisplayRow [] drs;
cr = cds.Card [0];
drs = cr.GetDisplayRows();
if (drs.Length > 0)
{
dr = drs [0];
Digits = dr.Digits;
Format = (DisplayFormat)Enum.Parse(typeof(DisplayFormat), dr.Format);
}
}
public void WriteToDataset(CardDataset cds, CardPart part)
{
if (part == CardPart.Program)
{
CardDataset.DisplayRow dr;
for (int i = 0; i < cds.Display.Count; i++)
{
cds.Display.RemoveDisplayRow(cds.Display [i]);
}
dr = cds.Display.NewDisplayRow();
dr.Digits = digits;
dr.Format = format.ToString();
dr.CardRow = cds.Card [0];
cds.Display.AddDisplayRow(dr);
}
}
public void ReadFromDataset(CardDataset cds, Reader reader)
{
CardDataset.CardRow cr;
CardDataset.MemoryRow mr;
CardDataset.MemoryRow [] mrs;
CardDataset.RegisterRow [] rrs;
cr = cds.Card [0];
mrs = cr.GetMemoryRows();
if (mrs.Length > 0)
{
mr = mrs [0];
registers = new Number [mr.RegisterCount];
rrs = mr.GetRegisterRows();
foreach (CardDataset.RegisterRow rr in rrs)
{
registers [rr.Id] = Number.ReadFromRow(rr);
}
}
}
public void MergeFromDataset(CardDataset cds, Reader reader)
{
CardDataset.CardRow cr;
CardDataset.MemoryRow mr;
CardDataset.MemoryRow [] mrs;
CardDataset.RegisterRow [] rrs;
bool sourceMemoryIsEmpty;
cr = cds.Card [0];
mrs = cr.GetMemoryRows();
if (mrs.Length > 0)
{
mr = mrs [0];
rrs = mr.GetRegisterRows();
// A source card that only constains zeros is considered empty. No merge takes
// place in this case.
sourceMemoryIsEmpty = true;
foreach (CardDataset.RegisterRow rr in rrs)
{
if (rr.Value != 0.0)
{
sourceMemoryIsEmpty = false;
break;
}
}
if (!sourceMemoryIsEmpty)
{
int last = (int)Number.Floor(Number.Abs(this [LetterRegister.I]));
foreach (CardDataset.RegisterRow rr in rrs)
{
if (rr.Id <= last)
{
registers [rr.Id] = Number.ReadFromRow(rr);
}
}
}
}
}
public void ReadFromDataset(CardDataset cds, Reader reader)
{
CardDataset.CardRow cr;
CardDataset.EngineRow er;
CardDataset.EngineRow [] ers;
CardDataset.FlagRow [] frs;
cr = cds.Card [0];
ers = cr.GetEngineRows();
if (ers.Length > 0)
{
er = ers [0];
unit = (AngleUnit)Enum.Parse(typeof(AngleUnit), er.AngleUnit);
flags = new bool [er.FlagCount];
frs = er.GetFlagRows();
foreach (CardDataset.FlagRow fr in frs)
{
flags [fr.Id] = fr.Value;
}
}
}
static public void Write(Stream stream, CardPart part)
{
CardDataset cds = new CardDataset();
if (stream.Length > 0)
{
cds.ReadXml(stream);
CheckVersion(cds);
}
else
{
CardDataset.CardRow cr;
cr = cds.Card.NewCardRow();
cr.Version = Version;
cds.Card.AddCardRow(cr);
}
WriteToDataset(cds, part);
stream.SetLength(0);
cds.WriteXml(stream);
}
private async Task <bool> GetPackagedFile(string folderName, string fileName, UIElement rootFrame)
{
StorageFolder installFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
StorageFile file = null;
if (folderName != null)
{
StorageFolder subFolder = await installFolder.GetFolderAsync(folderName);
file = await subFolder.GetFileAsync(fileName);
}
else
{
file = await installFolder.GetFileAsync(fileName);
}
//string text = await Windows.Storage.FileIO.ReadTextAsync(file);
//datafile df = new datafile();
//df = Newtonsoft.Json.JsonConvert.DeserializeObject<datafile>(text);
XmlLoadSettings settings = new XmlLoadSettings()
{
ValidateOnParse = false
};
XmlDocument xmlDoc = await XmlDocument.LoadFromFileAsync(file, settings);
foreach (IXmlNode xmlNode in xmlDoc.GetElementsByTagName("card"))
{
CardMini c = new CardMini();
foreach (XmlAttribute xa in xmlNode.Attributes)
{
if (xa.Value == null)
{
continue; //skip bad/blank entries
}
if (xa.Value == "")
{
continue;
}
switch (xa.Name.ToLower())
{
case "id":
c.Hero.EntryId = xa.Value;
break;
case "life":
c.Hero.Life = Convert.ToInt32(xa.Value);
break;
case "world":
c.Hero.World = xa.Value;
break;
case "set":
c.Hero.Set = xa.Value;
break;
case "collectornumber":
c.Hero.CollectorNumber = xa.Value;
break;
case "name":
c.Hero.Name = xa.Value;
break;
case "valkyrie":
c.Hero.Valkyrie = xa.Value;
break;
case "species":
c.Hero.Species = xa.Value;
break;
case "herotype":
c.Hero.HeroType = xa.Value;
break;
case "class":
c.Hero.ClassType = xa.Value;
break;
case "personality":
c.Hero.Personality = xa.Value;
break;
case "size":
c.Hero.Size = xa.Value;
break;
case "move":
c.Hero.Move = Convert.ToInt32(xa.Value);
break;
case "range":
c.Hero.Range = Convert.ToInt32(xa.Value);
break;
case "attack":
c.Hero.Attack = Convert.ToInt32(xa.Value);
break;
case "defense":
c.Hero.Defense = Convert.ToInt32(xa.Value);
break;
case "points":
c.Hero.Points = Convert.ToInt32(xa.Value);
break;
case "bmove":
c.Hero.BasicMove = Convert.ToInt32(xa.Value);
break;
case "brange":
c.Hero.BasicRange = Convert.ToInt32(xa.Value);
break;
case "battack":
c.Hero.BasicAttack = Convert.ToInt32(xa.Value);
break;
case "bdefense":
c.Hero.BasicDefense = Convert.ToInt32(xa.Value);
break;
case "armysize":
c.Hero.ArmySize = Convert.ToInt32(xa.Value);
break;
}
}
c.Hero.Image = string.Format("/Assets/Cards/{0}.png", c.Hero.EntryId);
c.Hero.Thumb = string.Format("/Assets/Cards/_t/{0}.png", c.Hero.EntryId);
//c.CardSource = ImageFromRelativePath(rootFrame, c.Hero.Thumb);
c.CardName = c.Hero.Name;
c.CardPoints = string.Format("{0} PTS", c.Hero.Points);
c.UpdateData();
CardDataset.Add(c);
}
foreach (IXmlNode xmlNode in xmlDoc.GetElementsByTagName("glyph"))
{
GlyphControl g = new GlyphControl();
foreach (XmlAttribute xa in xmlNode.Attributes)
{
switch (xa.Name.ToLower())
{
case "id":
g.EntryId = xa.Value;
break;
case "description":
g.Description = xa.Value;
break;
}
}
g.ImageFileName = string.Format("/Assets/Glyphs/{0}.png", g.EntryId);
// g.GlyphSource = ImageFromRelativePath(rootFrame, g.ImageFileName);
glyphdataset.Add(g);
}
GameSetting.DataLoaded = true;
return(true);
}
static private void CheckVersion(CardDataset cds)
{
CardDataset.CardRow cr = cds.Card [0];
CardDataset.ArgumentRow [] ars;
CardDataset.InstructionRow [] irs;
CardDataset.MemoryRow mr;
CardDataset.MemoryRow [] mrs;
CardDataset.ProgramRow pr;
CardDataset.ProgramRow [] prs;
CardDataset.RegisterRow rr;
CardDataset.RegisterRow [] rrs;
if (cr.Version == Version)
{
return;
}
// We didn't support compatibility before version 1.4.
if (cr.Version < 1.4F || cr.Version > Version)
{
// For some reason (read: compiler bug) we must compute text and caption separately,
// we cannot just write one humongous statement.
string text = Localization.FileHasVersionFormat(
cds.Card [0].Version.ToString(),
Version.ToString());
string caption = Localization.IncompatibleVersion;
MessageBox.Show(text, caption, MessageBoxButtons.OK, MessageBoxIcon.Error);
throw new Error();
}
// Compatibility code to read older cards.
if (cr.Version <= 1.4F)
{
// Version 1.4 used to have Text in instructions.
}
if (cr.Version <= 1.5F)
{
// Version 1.5 used to have GSB_F and LBL_F.
prs = cr.GetProgramRows();
if (prs.Length > 0)
{
pr = prs [0];
irs = pr.GetInstructionRows();
foreach (CardDataset.InstructionRow ir in irs)
{
if (ir.Instruction == "Gsb_f")
{
ir.Instruction = "Gsb";
}
else if (ir.Instruction == "Lbl_f")
{
ir.Instruction = "Lbl";
}
}
}
}
if (cr.Version <= 1.6F)
{
// Version 1.6 used to have argument types starting with HP67_Class_Library.
prs = cr.GetProgramRows();
if (prs.Length > 0)
{
pr = prs [0];
irs = pr.GetInstructionRows();
foreach (CardDataset.InstructionRow ir in irs)
{
ars = ir.GetArgumentRows();
foreach (CardDataset.ArgumentRow ar in ars)
{
if (ar.Type.StartsWith("HP67_Class_Library."))
{
ar.Type =
ar.Type.Replace
("HP67_Class_Library.", "Mockingbird.HP.Class_Library.");
}
}
}
}
}
if (cr.Version <= 1.7F)
{
// Version 1.7 used to have RC_I and ST_I.
prs = cr.GetProgramRows();
if (prs.Length > 0)
{
pr = prs [0];
irs = pr.GetInstructionRows();
foreach (CardDataset.InstructionRow ir in irs)
{
bool mustPatch = false;
if (ir.Instruction == "Rc_I")
{
ir.Instruction = "Rcl";
mustPatch = true;
}
else if (ir.Instruction == "St_I")
{
ir.Instruction = "Sto";
mustPatch = true;
}
if (mustPatch)
{
CardDataset.ArgumentRow ar;
ir.ArgumentCount = 1;
ar = cds.Argument.NewArgumentRow();
ar.Id = 0;
ar.Type = "Mockingbird.HP.Class_Library.Letter";
ar.Value = "I";
ar.InstructionRow = ir;
cds.Argument.AddArgumentRow(ar);
}
}
}
}
if (cr.Version <= 1.8F)
{
// Version 1.8 used to have the value of registers stored as double. Note that the
// Value column still exists so as to read old cards, but it is not used anymore.
mrs = cr.GetMemoryRows();
if (mrs.Length > 0)
{
mr = mrs [0];
rrs = mr.GetRegisterRows();
if (rrs.Length > 0)
{
// We need to split the Value because it might not be representable as a
// decimal. However, it doesn't really matter how we do the split, because
// Number will renormalize it anyway.
double d;
rr = rrs [0];
d = rr.Value;
rr.Exponent = (sbyte)Math.Log10((double)Math.Abs(d));
rr.Mantissa = (decimal)(d * Math.Pow(10.0, -rr.Exponent));
}
}
}
cds.Card [0].Version = Version;
}
