public void Read(OsiReader reader)
{
Name = reader.ReadString();
if (Name.Length > 0)
{
var hasParams = reader.ReadByte();
if (hasParams > 0)
{
Parameters = new List<TypedValue>();
var numParams = reader.ReadByte();
while (numParams-- > 0)
{
TypedValue param;
var type = reader.ReadByte();
if (type == 1)
param = new Variable();
else
param = new TypedValue();
param.Read(reader);
Parameters.Add(param);
}
}
Negate = reader.ReadBoolean();
}
GoalIdOrDebugHook = reader.ReadInt32();
}
public override void Read(OsiReader reader)
{
base.Read(reader);
Calls = reader.ReadList<Call>();
Variables = new List<Variable>();
var variables = reader.ReadByte();
while (variables-- > 0)
{
var type = reader.ReadByte();
if (type != 1) throw new InvalidDataException("Illegal value type in rule variable list");
var variable = new Variable();
variable.Read(reader);
if (variable.Adapted)
{
variable.VariableName = String.Format("_Var{0}", Variables.Count + 1);
}
Variables.Add(variable);
}
Line = reader.ReadUInt32();
if (reader.MajorVersion > 1 || (reader.MajorVersion == 1 && reader.MinorVersion >= 6))
IsQuery = reader.ReadBoolean();
else
IsQuery = false;
}
public void Read(OsiReader reader)
{
Index = reader.ReadUInt32();
Name = reader.ReadString();
SubGoalCombination = reader.ReadByte();
ParentGoals = new List<uint>();
var numItems = reader.ReadUInt32();
while (numItems-- > 0)
{
ParentGoals.Add(reader.ReadUInt32());
}
SubGoals = new List<uint>();
numItems = reader.ReadUInt32();
while (numItems-- > 0)
{
SubGoals.Add(reader.ReadUInt32());
}
Unknown = reader.ReadByte();
if (reader.MajorVersion > 1 || (reader.MajorVersion == 1 && reader.MinorVersion >= 1))
{
InitCalls = reader.ReadList<Call>();
ExitCalls = reader.ReadList<Call>();
}
else
{
InitCalls = new List<Call>();
ExitCalls = new List<Call>();
}
}
public void Read(OsiReader reader)
{
Types = new List<UInt32>();
var count = reader.ReadByte();
while (count-- > 0)
{
Types.Add(reader.ReadUInt32());
}
}
public virtual void Read(OsiReader reader)
{
DatabaseRef = reader.ReadDatabaseRef();
Name = reader.ReadString();
if (Name.Length > 0)
{
NameIndex = reader.ReadByte();
}
}
public override void Read(OsiReader reader)
{
base.Read(reader);
ParentRef = reader.ReadNodeRef();
AdapterRef = reader.ReadAdapterRef();
RelDatabaseRef = reader.ReadDatabaseRef();
RelDatabase = new NodeEntryItem();
RelDatabase.Read(reader);
RelDatabaseFlag = reader.ReadByte();
}
public void Read(OsiReader reader)
{
Name = reader.ReadString();
OutParamMask = new List<byte>();
var outParamBytes = reader.ReadUInt32();
while (outParamBytes-- > 0)
{
OutParamMask.Add(reader.ReadByte());
}
Parameters = new ParameterList();
Parameters.Read(reader);
}
public override void Read(OsiReader reader)
{
base.Read(reader);
Value1Index = reader.ReadSByte();
Value2Index = reader.ReadSByte();
Value1 = new Value();
Value1.Read(reader);
Value2 = new Value();
Value2.Read(reader);
RelOp = (RelOpType)reader.ReadInt32();
}
public override void Read(OsiReader reader)
{
base.Read(reader);
LeftParentRef = reader.ReadNodeRef();
RightParentRef = reader.ReadNodeRef();
Adapter1Ref = reader.ReadAdapterRef();
Adapter2Ref = reader.ReadAdapterRef();
Database1Ref = reader.ReadDatabaseRef();
Database1 = new NodeEntryItem();
Database1.Read(reader);
Database1Flag = reader.ReadByte();
Database2Ref = reader.ReadDatabaseRef();
Database2 = new NodeEntryItem();
Database2.Read(reader);
Database2Flag = reader.ReadByte();
}
public virtual void Read(OsiReader reader)
{
var wtf = reader.ReadByte();
if (wtf == 49)
{
TypeId = reader.ReadUInt32();
IntValue = reader.ReadInt32();
}
else if (wtf == 48)
{
TypeId = reader.ReadUInt32();
switch ((Type)TypeId)
{
case Type.Unknown:
break;
case Type.Integer:
IntValue = reader.ReadInt32();
break;
case Type.Float:
FloatValue = reader.ReadSingle();
break;
case Type.String:
if (reader.ReadByte() > 0)
{
StringValue = reader.ReadString();
}
break;
default:
StringValue = reader.ReadString();
break;
}
}
else
{
throw new InvalidDataException("Unrecognized value type");
}
}
public void Read(OsiReader reader)
{
Constants = new Tuple();
Constants.Read(reader);
LogicalIndices = new List<sbyte>();
var count = reader.ReadByte();
while (count-- > 0)
{
LogicalIndices.Add(reader.ReadSByte());
}
LogicalToPhysicalMap = new Dictionary<byte, byte>();
count = reader.ReadByte();
while (count-- > 0)
{
var key = reader.ReadByte();
var value = reader.ReadByte();
LogicalToPhysicalMap.Add(key, value);
}
}
public override void Read(OsiReader reader)
{
base.Read(reader);
ReferencedBy = reader.ReadList<NodeEntryItem>();
}
public void Read(OsiReader reader)
{
Line = reader.ReadUInt32();
Unknown1 = reader.ReadUInt32();
Unknown2 = reader.ReadUInt32();
NodeRef = reader.ReadNodeRef();
Type = (FunctionType)reader.ReadByte();
GUID = reader.ReadGuid();
Name = new FunctionSignature();
Name.Read(reader);
}
public void Read(OsiReader reader)
{
DatabaseIndex = reader.ReadUInt32();
}
public override void Read(OsiReader reader)
{
base.Read(reader);
NextNode = new NodeEntryItem();
NextNode.Read(reader);
}
public void Read(OsiReader reader)
{
NodeIndex = reader.ReadUInt32();
}
public void Read(OsiReader reader)
{
AdapterIndex = reader.ReadUInt32();
}
public void Read(OsiReader reader)
{
Physical.Clear();
Logical.Clear();
var count = reader.ReadByte();
while (count-- > 0)
{
var index = reader.ReadByte();
var value = new Value();
value.Read(reader);
Physical.Add(value);
Logical.Add(index, value);
}
}
private Dictionary<uint, Node> ReadNodes(OsiReader reader)
{
var nodes = new Dictionary<uint, Node>();
var count = reader.ReadUInt32();
while (count-- > 0)
{
Node node = null;
var type = reader.ReadByte();
var nodeId = reader.ReadUInt32();
switch ((Node.Type)type)
{
case Node.Type.Database:
node = new DatabaseNode();
break;
case Node.Type.Proc:
node = new ProcNode();
break;
case Node.Type.DivQuery:
node = new DivQueryNode();
break;
case Node.Type.InternalQuery:
node = new InternalQueryNode();
break;
case Node.Type.And:
node = new AndNode();
break;
case Node.Type.NotAnd:
node = new NotAndNode();
break;
case Node.Type.RelOp:
node = new RelOpNode();
break;
case Node.Type.Rule:
node = new RuleNode();
break;
case Node.Type.UserQuery:
node = new UserQueryNode();
break;
default:
throw new NotImplementedException("No serializer found for this node type");
}
node.Read(reader);
nodes.Add(nodeId, node);
}
return nodes;
}
public override void Read(OsiReader reader)
{
base.Read(reader);
IsValid = reader.ReadBoolean();
OutParam = reader.ReadBoolean();
IsAType = reader.ReadBoolean();
}
public override void Read(OsiReader reader)
{
base.Read(reader);
Index = reader.ReadSByte();
Unused = reader.ReadBoolean();
Adapted = reader.ReadBoolean();
}
private Dictionary<uint, Adapter> ReadAdapters(OsiReader reader)
{
var adapters = new Dictionary<uint, Adapter>();
var count = reader.ReadUInt32();
while (count-- > 0)
{
var adapterId = reader.ReadUInt32();
var adapter = new Adapter();
adapter.Read(reader);
adapters.Add(adapterId, adapter);
}
return adapters;
}
private Dictionary<uint, Database> ReadDatabases(OsiReader reader)
{
var databases = new Dictionary<uint, Database>();
var count = reader.ReadUInt32();
while (count-- > 0)
{
var databaseId = reader.ReadUInt32();
var database = new Database();
database.Read(reader);
databases.Add(databaseId, database);
}
return databases;
}
private Dictionary<uint, Goal> ReadGoals(OsiReader reader)
{
var goals = new Dictionary<uint, Goal>();
var count = reader.ReadUInt32();
while (count-- > 0)
{
var goal = new Goal();
goal.Read(reader);
goals.Add(goal.Index, goal);
}
return goals;
}
private Dictionary<uint, OsirisType> ReadTypes(OsiReader reader)
{
var types = new Dictionary<uint, OsirisType>();
var count = reader.ReadUInt32();
while (count-- > 0)
{
var type = new OsirisType();
type.Read(reader);
types.Add(type.Index, type);
}
return types;
}
public Story Read(Stream stream)
{
using (var reader = new OsiReader(stream))
{
var story = new Story();
var header = new OsirisHeader();
header.Read(reader);
reader.MinorVersion = header.MinorVersion;
reader.MajorVersion = header.MajorVersion;
story.MinorVersion = header.MinorVersion;
story.MajorVersion = header.MajorVersion;
if (reader.MajorVersion > 1 || (reader.MajorVersion == 1 && reader.MinorVersion > 7))
{
var msg = String.Format(
"Osiris version v{0}.{1} unsupported; this tool supports versions up to v1.7.",
reader.MajorVersion, reader.MinorVersion
);
throw new InvalidDataException(msg);
}
if (reader.MajorVersion > 1 || (reader.MajorVersion == 1 && reader.MinorVersion >= 4))
reader.Scramble = 0xAD;
if (reader.MajorVersion > 1 || (reader.MajorVersion == 1 && reader.MinorVersion >= 5))
story.Types = ReadTypes(reader);
else
story.Types = new Dictionary<uint, OsirisType>();
story.Types[0] = new OsirisType();
story.Types[0].Index = 0;
story.Types[0].Name = "UNKNOWN";
story.Types[1] = new OsirisType();
story.Types[1].Index = 1;
story.Types[1].Name = "INTEGER";
story.Types[2] = new OsirisType();
story.Types[2].Index = 2;
story.Types[2].Name = "FLOAT";
story.Types[3] = new OsirisType();
story.Types[3].Index = 3;
story.Types[3].Name = "STRING";
story.DivObjects = reader.ReadList<OsirisDivObject>();
story.Functions = reader.ReadList<Function>();
story.Nodes = ReadNodes(reader);
story.Adapters = ReadAdapters(reader);
story.Databases = ReadDatabases(reader);
story.Goals = ReadGoals(reader);
story.GlobalActions = reader.ReadList<Call>();
foreach (var node in story.Nodes)
{
if (node.Value.DatabaseRef.IsValid())
{
var database = story.Databases[node.Value.DatabaseRef.DatabaseIndex];
if (database.OwnerNode != null)
{
throw new InvalidDataException("A database cannot be assigned to multiple database nodes!");
}
database.OwnerNode = node.Value;
}
if (node.Value is RuleNode)
{
// Remove the __DEF__ postfix that is added to the end of Query nodes
var rule = node.Value as RuleNode;
if (rule.IsQuery)
{
var ruleRoot = rule.GetRoot(story);
if (ruleRoot.Name != null &&
ruleRoot.Name.Length > 7 &&
ruleRoot.Name.Substring(ruleRoot.Name.Length - 7) == "__DEF__")
{
ruleRoot.Name = ruleRoot.Name.Substring(0, ruleRoot.Name.Length - 7);
}
}
}
if (node.Value is DataNode)
{
var data = node.Value as DataNode;
foreach (var reference in data.ReferencedBy)
{
if (reference.NodeRef.IsValid())
{
var ruleNode = story.Nodes[reference.NodeRef.NodeIndex];
if (reference.GoalId > 0 &&
ruleNode is RuleNode)
{
(ruleNode as RuleNode).DerivedGoalId = reference.GoalId;
}
}
}
}
if (node.Value is TreeNode)
{
var tree = node.Value as TreeNode;
if (tree.NextNode.NodeRef.IsValid())
{
var nextNode = story.Nodes[tree.NextNode.NodeRef.NodeIndex];
if (nextNode is RuleNode)
{
(nextNode as RuleNode).DerivedGoalId = tree.NextNode.GoalId;
}
}
}
if (node.Value is RelNode)
{
var rel = node.Value as RelNode;
if (rel.AdapterRef.IsValid())
{
var adapter = story.Adapters[rel.AdapterRef.AdapterIndex];
if (adapter.OwnerNode != null)
{
throw new InvalidDataException("An adapter cannot be assigned to multiple join/rel nodes!");
}
adapter.OwnerNode = node.Value;
}
}
else if (node.Value is JoinNode)
{
var join = node.Value as JoinNode;
if (join.Adapter1Ref.IsValid())
{
var adapter = story.Adapters[join.Adapter1Ref.AdapterIndex];
if (adapter.OwnerNode != null)
{
throw new InvalidDataException("An adapter cannot be assigned to multiple join/rel nodes!");
}
adapter.OwnerNode = node.Value;
}
if (join.Adapter2Ref.IsValid())
{
var adapter = story.Adapters[join.Adapter2Ref.AdapterIndex];
if (adapter.OwnerNode != null)
{
throw new InvalidDataException("An adapter cannot be assigned to multiple join/rel nodes!");
}
adapter.OwnerNode = node.Value;
}
}
}
return story;
}
}
