public void SmallPayload() { var unpacker = new DataUnpacker(new IdentityTransformer()); var input = new byte[] { 1, 2, 3, 2, 1, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; var output = new byte[16]; var unpacked = unpacker.UnpackData( new ArraySegment <byte>(output), out var bytesWritten, out var bytesRead, out var pairId, out var serialId, out var payloadSize, new ArraySegment <byte>(input)); Assert.True(unpacked); Assert.Equal(payloadSize, bytesWritten); Assert.Equal(input.Length, bytesRead); Assert.Equal(1, pairId); Assert.Equal(2, serialId); Assert.Equal(4, payloadSize); }
private static string GetEffectCode(Propeller.MemoryManager memory, bool useShortOpcodes) { Spin.ParsedAssignment ParsedAssignment = new Spin.ParsedAssignment(memory.ReadByte()); string effect = ParsedAssignment.Push ? "" : "POP "; if (useShortOpcodes) { effect += "(" + ParsedAssignment.GetBasicInstruction().NameBrief + ")"; } else { effect += ParsedAssignment.GetBasicInstruction().Name; } if (!ParsedAssignment.Math) { Propeller.Spin.SubAssignment SubAssignment = ParsedAssignment.GetSubAssignment(); switch (SubAssignment.ArgumentMode) { case Propeller.Spin.ArgumentMode.None: break; case Propeller.Spin.ArgumentMode.SignedPackedOffset: effect += " " + DataUnpacker.GetSignedPackedOffset(memory); break; default: throw new Exception("Unexpected Spin Argument Mode: " + SubAssignment.ArgumentMode.ToString()); } } return(effect); }
public void Unpack(DataUnpacker unpacker) { unpacker.Unpack(out this.VariableID); byte oper; unpacker.Unpack(out oper); this.Operator = (VariableOperation)oper; if (this.VariableID != HamTimeline.InvalidID) { this.Operand = new VariableValue(); this.Operand.Unpack(unpacker); } }
public void Unpack(DataUnpacker unpacker) { unpacker.Unpack(out this.VariableID); byte comparisonByte; unpacker.Unpack(out comparisonByte); this.Comparison = (VariableComparison)comparisonByte; if (this.VariableID == HamTimeline.InvalidID) { this.CompareValue = null; } else { this.CompareValue = new VariableValue(); this.CompareValue.Unpack(unpacker); } unpacker.Unpack(out this.NextNodeID); }
public void SmallPayloadSliced() { var unpacker = new DataUnpacker(new IdentityTransformer()); var input = new byte[] { 1, 2, 3, 2, 1, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; var output = new byte[16]; var unpacked = false; int bytesWritten, bytesRead, pairId, serialId, payloadSize; for (int i = 0; i < 4; i++) { unpacked = unpacker.UnpackData( new ArraySegment <byte>(output), out bytesWritten, out bytesRead, out pairId, out serialId, out payloadSize, new ArraySegment <byte>(input, i * 4, 4)); Assert.False(unpacked); } unpacked = unpacker.UnpackData( new ArraySegment <byte>(output), out bytesWritten, out bytesRead, out pairId, out serialId, out payloadSize, new ArraySegment <byte>(input, 4 * 4, 16)); Assert.True(unpacked); Assert.Equal(payloadSize, bytesWritten); Assert.Equal(16, bytesRead); Assert.Equal(1, pairId); Assert.Equal(2, serialId); Assert.Equal(4, payloadSize); }
public static void Unpack(out HamTimelineNode node, DataUnpacker unpacker) { byte typeByte; unpacker.Unpack(out typeByte); TimelineNodeType type = (TimelineNodeType)typeByte; int id; unpacker.Unpack(out id); int numPrevIDs; unpacker.Unpack(out numPrevIDs); List<int> previousNodeIDs = new List<int>(); for (int i = 0; i < numPrevIDs; ++i) { int prevID; unpacker.Unpack(out prevID); previousNodeIDs.Add(prevID); } switch (type) { case TimelineNodeType.Dialog: node = new HamDialogNode(); break; case TimelineNodeType.Branch: node = new HamBranchNode(); break; case TimelineNodeType.Decision: node = new HamDecisionNode(); break; case TimelineNodeType.Consequence: node = new HamConsequenceNode(); break; default: node = null; return; } node.ID = id; node.Type = type; node.PreviousNodeIDs = previousNodeIDs; node.Unpack(unpacker); }
private void VerifyOutput(byte[] input, byte[] output, int bytesWritten) { Assert.True(bytesWritten > input.Length); Assert.True(bytesWritten <= output.Length); Assert.True(bytesWritten % (new IdentityTransformer().OutputBlockSize) == 0); var pos = ParseHeader(output, bytesWritten); Assert.True(pos > 0 && pos < bytesWritten - 1); var pairId = DataUnpacker.ReadInt(output, ref pos); Assert.Equal(1, pairId); var serialId = DataUnpacker.ReadInt(output, ref pos); Assert.Equal(2, serialId); var payloadSize = DataUnpacker.ReadInt(output, ref pos); Assert.Equal(input.Length, payloadSize); Assert.True(Enumerable.SequenceEqual(output.Skip(pos).Take(input.Length), input)); }
public void Unpack(DataUnpacker unpacker) { this.timeline = new HamTimeline(); this.timeline.Unpack(unpacker); int varSize; unpacker.Unpack(out varSize); for (int i = 0; i < varSize; ++i) { int key; unpacker.Unpack(out key); VariableValue val = new VariableValue(); val.Unpack(unpacker); this.variables[key] = val; } unpacker.Unpack(out this.currentNodeID); unpacker.Unpack(out this.currentSceneID); int charSize; unpacker.Unpack(out charSize); for (int i = 0; i < charSize; ++i) { int next; unpacker.Unpack(out next); this.currentCharactersInScene.Add(next); } int historySize; unpacker.Unpack(out historySize); for (int i = 0; i < historySize; ++i) { int history; unpacker.Unpack(out history); this.nodeHistory.Add(history); } }
public override void Unpack(DataUnpacker unpacker) { unpacker.Unpack(out this.SceneID); int size; unpacker.Unpack(out size); this.CharacterIDs = new List<int>(); for (int i = 0; i < size; ++i) { int id; unpacker.Unpack(out id); this.CharacterIDs.Add(id); } unpacker.Unpack(out this.SpeakerID); unpacker.Unpack(out this.Dialog); unpacker.Unpack(out this.NextNodeID); }
public override void Unpack(DataUnpacker unpacker) { unpacker.Unpack(out this.DefaultNextID); int size; this.Predicates = new List<HamPredicate>(); unpacker.Unpack(out size); for (int i = 0; i < size; ++i) { HamPredicate predicate = new HamPredicate(); predicate.Unpack(unpacker); this.Predicates.Add(predicate); } }
public void Unpack(DataUnpacker unpacker) { int versionInt; unpacker.Unpack(out versionInt); // TODO - In the future, we'll want to have separate unpacker functions based on version diffs // For now there aren't any, but we'll stick this version int here for when that day arrives unpacker.Unpack(out this.Name); unpacker.Unpack(out this.IDCount); unpacker.Unpack(out this.OriginNodeID); unpacker.Unpack(out this.NarratorID); unpacker.Unpack(out this.DefaultSceneID); int numVars; unpacker.Unpack(out numVars); for (int i = 0; i < numVars; ++i) { HamTimelineVariable variable = new HamTimelineVariable(); variable.Unpack(unpacker); this.Variables[variable.ID] = variable; } int numScenes; unpacker.Unpack(out numScenes); for (int i = 0; i < numScenes; ++i) { HamScene scene = new HamScene(); scene.Unpack(unpacker); this.Scenes[scene.ID] = scene; } int numCharacters; unpacker.Unpack(out numCharacters); for (int i = 0; i < numCharacters; ++i) { HamCharacter character = new HamCharacter(); character.Unpack(unpacker); this.Characters[character.ID] = character; } int numNodes; unpacker.Unpack(out numNodes); for (int i = 0; i < numNodes; ++i) { HamTimelineNode node; HamTimelineNode.Unpack(out node, unpacker); this.Nodes[node.ID] = node; } }
public void Unpack(DataUnpacker unpacker) { unpacker.Unpack(out this.DecisionText); unpacker.Unpack(out this.IsDialog); int size; unpacker.Unpack(out size); this.Predicates = new List<HamPredicate>(); for (int i = 0; i < size; ++i) { HamPredicate p = new HamPredicate(); p.Unpack(unpacker); this.Predicates.Add(p); } unpacker.Unpack(out this.NextNodeID); }
public override void Unpack(DataUnpacker unpacker) { int numDecisions; unpacker.Unpack(out numDecisions); this.Decisions = new List<Decision>(); for (int i = 0; i < numDecisions; ++i) { Decision d = new Decision(); d.Unpack(unpacker); this.Decisions.Add(d); } }
public void Unpack(DataUnpacker unpacker) { unpacker.Unpack(out this.ID); unpacker.Unpack(out this.Name); }
public static string InterpreterText(Propeller.MemoryManager memory, bool displayAsHexadecimal, bool useShortOpcodes) { string format; if (displayAsHexadecimal) { format = "{0} ${1:X}"; } else { format = "{0} {1}"; } Propeller.Spin.Instruction Instr = Propeller.Spin.Instructions[memory.ReadByte()]; string Name; if (useShortOpcodes) { Name = Instr.NameBrief; } else { Name = Instr.Name; } switch (Instr.ArgumentMode) { case Propeller.Spin.ArgumentMode.None: return(Name); case Propeller.Spin.ArgumentMode.UnsignedOffset: return(String.Format(format, Name, DataUnpacker.GetPackedOffset(memory))); case Propeller.Spin.ArgumentMode.UnsignedEffectedOffset: return(String.Format("{0} {1} {2}", Name, DataUnpacker.GetPackedOffset(memory), GetEffectCode(memory, useShortOpcodes))); case Propeller.Spin.ArgumentMode.Effect: return(String.Format(format, Name, GetEffectCode(memory, useShortOpcodes))); case Propeller.Spin.ArgumentMode.SignedOffset: return(String.Format(format, Name, DataUnpacker.GetSignedOffset(memory))); case Propeller.Spin.ArgumentMode.PackedLiteral: return(String.Format(format, Name, DataUnpacker.GetPackedLiteral(memory))); case Propeller.Spin.ArgumentMode.ByteLiteral: return(String.Format(format, Name, memory.ReadByte())); case Propeller.Spin.ArgumentMode.WordLiteral: return(String.Format(format, Name, DataUnpacker.GetWordLiteral(memory))); case Propeller.Spin.ArgumentMode.NearLongLiteral: return(String.Format(format, Name, DataUnpacker.GetNearLongLiteral(memory))); case Propeller.Spin.ArgumentMode.LongLiteral: return(String.Format(format, Name, DataUnpacker.GetLongLiteral(memory))); case Propeller.Spin.ArgumentMode.ObjCallPair: { byte obj = memory.ReadByte(); byte funct = memory.ReadByte(); return(String.Format("{0} {1}.{2}", Name, obj, funct)); } case Propeller.Spin.ArgumentMode.MemoryOpCode: return(String.Format("{0} {1}", Name, GetMemoryOp(memory, useShortOpcodes))); default: throw new Exception("Unknown Spin Argument Mode: " + Instr.ArgumentMode.ToString()); } }
public abstract void Unpack(DataUnpacker unpacker);
public override void Unpack(DataUnpacker unpacker) { unpacker.Unpack(out this.NextNodeID); int size; unpacker.Unpack(out size); this.Operations = new List<HamOperation>(); for (int i = 0; i < size; ++i) { HamOperation operation = new HamOperation(); operation.Unpack(unpacker); this.Operations.Add(operation); } }