protected virtual void ParseDerv(IFFFile.Node node, ITemplateRepository repo)
{
var dervOfNode = node.FindSubNode("XXXX");
if (dervOfNode == null)
{
return;
}
var offset = 0;
var dervString = dervOfNode.Data.ReadAsciiString(ref offset);
if (string.IsNullOrEmpty(dervString))
{
return;
}
if (_loadedDervs.Contains(dervString))
{
return;
}
var dervIff = repo.LoadIff(dervString);
if (dervIff == null)
{
return;
}
_loadedDervs.Add(dervString);
ReadFile(dervIff, repo);
}
public static IEnumerable <IFFFile.Node> Siblings(this IFFFile.Node node)
{
if (node.Parent == null)
{
return(null);
}
return(node.Parent.Children);
}
public override void ReadNode(IFFFile.Node node, ITemplateRepository repo, bool checkType = true)
{
if (RootNodeType == null && checkType && node.Type != RootNodeType)
{
base.ReadNode(node, repo, checkType);
return;
}
ParseData(node, repo, (n, r) => { }, _Logger);
}
public override void ReadNode(IFFFile.Node node, ITemplateRepository repo, bool checkType = true)
{
if (checkType && node.Type != "STAT")
{
base.ReadNode(node, repo);
return;
}
//nothing special about filler buildings
ParseData(node, repo, (n, r) => { }, _Logger);
}
public static IEnumerable <IFFFile.Node> FindSiblingNodes(this IFFFile.Node node, string nodeToFind)
{
var found = FindSubNode(node, nodeToFind);
if (found == null || found.Parent == null)
{
return(new IFFFile.Node[0]);
}
return(found.Parent.Children);
}
public override void ReadNode(IFFFile.Node node, ITemplateRepository repo, bool checkType = true)
{
if (checkType && node.Type != "SCOT")
{
_Logger.Warn("Got {0} when expecting SHOT", node.Type);
base.ReadNode(node, repo);
return;
}
ParseData(node, repo, ParseNode, _Logger);
}
public virtual void ReadNode(IFFFile.Node node, ITemplateRepository repo, bool checkType = true)
{
if (checkType && node.Type != "SHOT")
{
_Logger.Warn("Got {0} when expecting SHOT", node.Type);
return;
}
ParseData(node, repo, ParseData, _Logger);
//InternalParse(node, repo);
}
public override void ReadNode(IFFFile.Node node, ITemplateRepository repo, bool checkType = true)
{
if (checkType && node.Type != "STOT")
{
base.ReadNode(node, repo);
return;
}
ParseData(node, repo, ParseData, _Logger);
}
protected T TryParseAssign <T>(IFFFile.Node node, ref int offset, T defaultValue)
where T : DataBase, new()
{
var newVal = new T();
if (newVal.Parse(node, ref offset))
{
return(newVal);
}
return(defaultValue);
}
public override void ReadNode(IFFFile.Node node, ITemplateRepository repo, bool checkType = true)
{
if (node.Type != "CCLT")
{
_Logger.Warn("Got {0} when expecting SHOT", node.Type);
base.ReadNode(node, repo, checkType);
return;
}
//nothing special about cell objects
ParseData(node, repo, (n, r) => { }, _Logger);
}
private TreeNode RefreshTreeView(TreeNodeCollection parentNodes, IFFFile.Node item, bool isRoot)
{
var node = new TreeNode();
node.Text = item.Type;
node.Tag = item;
node.SelectedImageIndex
= node.ImageIndex
= item.NodeType == IFFFile.NodeType.Form ? 0 : 1;
parentNodes.Add(node);
foreach (var childItem in item.Children)
{
RefreshTreeView(node.Nodes, childItem, false);
}
return(node);
}
private void ParseData(IFFFile.Node node, ITemplateRepository repo)
{
var offset = 0;
var varName = node.Data.ReadAsciiString(ref offset);
switch (varName)
{
case "terrainModificationFileName":
TerrainModificationFileName = TryParseAssign(node, ref offset, TerrainModificationFileName);
break;
case "interiorLayoutFileName":
InteriorLayoutFileName = TryParseAssign(node, ref offset, InteriorLayoutFileName);
break;
default:
break;
}
}
public override bool Parse(IFFFile.Node Source, ref int offset)
{
var toParse = Source.FindSiblingNodes("PCNT").ToList();
var pcnt = toParse.First(cur => cur.Type == "PCNT");
if (pcnt == null)
{
return(false);
}
var idx = 0;
var size = pcnt.Data.ReadInt32(ref idx);
if (toParse.Count != size - 1)
{
return(false);
}
foreach (var node in toParse.Where(cur => cur.Type == "XXXX"))
{
int readIdx = 0;
string varName = node.Data.ReadAsciiString(ref readIdx);
switch (varName)
{
case "variableName":
VariableName = new StringData(node, ref readIdx);
break;
case "palettePathName":
PalettePathName = new StringData(node, ref readIdx);
break;
case "defaultPaletteIndex":
DefaultValue = new IntegerData(node, ref readIdx);
break;
default:
break;
}
}
return(true);
}
private void ParseData(IFFFile.Node node, ITemplateRepository repo)
{
int offset = 0;
var name = node.Data.ReadAsciiString(ref offset);
switch (name)
{
case "paletteColorCustomizationVariables":
PaletteColorCustomizationVariables = TryParseAssign(node, ref offset, PaletteColorCustomizationVariables);
break;
case "rangedIntCustomizationVariables":
RangedIntCustomizationVariables = TryParseAssign(node, ref offset, RangedIntCustomizationVariables);
break;
/*case "constStringCustomizationVariables":
* break;
* case "socketDestinations":
* break;*/
/* case "structureFootprintFileName":
* var structureFootprintFileName = new StringData(node, ref offset);
* if(structureFootprintFileName.HasValue)
* {
* StructureFootprint = repo.LoadStructureFootprint(structureFootprintFileName.Value);
* }
* break;*/
case "useStructureFootprintOutline":
UseStructureFootprintOutline = TryParseAssign(node, ref offset, UseStructureFootprintOutline);
break;
case "targetable":
Targetable = TryParseAssign(node, ref offset, Targetable);
break;
/*case "certificationsRequired":
* break;
* case "customizationVariableMapping":
* break;*/
default:
break;
}
}
public static IFFFile.Node FindSubNode(this IFFFile.Node node, string nodeToFind, bool includeChirldren = true)
{
foreach (var item in node.Children)
{
if (item.Type == nodeToFind)
{
return(item);
}
if (includeChirldren)
{
var subSearch = FindSubNode(item, nodeToFind);
if (subSearch != null)
{
return(subSearch);
}
}
}
return(null);
}
public static IFFFile.Node FindNextSibling(this IFFFile.Node node)
{
var siblings = node.Siblings();
if (siblings == null)
{
return(null);
}
var nodeList = siblings as IList <IFFFile.Node>;
if (nodeList != null)
{
var indexOfNext = nodeList.IndexOf(node) + 1;
if (indexOfNext >= nodeList.Count)
{
return(null);
}
return(nodeList[indexOfNext]);
}
var found = false;
return(siblings.FirstOrDefault(cur =>
{
if (found)
{
return true;
}
if (cur == node)
{
found = true;
}
return false;
}));
}
public override bool Parse(IFFFile.Node Source, ref int offset)
{
var type1 = Source.Data.ReadByte(ref offset);
var numElements = Source.Data.ReadInt32(ref offset);
if (numElements == 0)
{
return(false);
}
Value = new List <T>(numElements);
foreach (var child in Source.Children.Where(cur => cur.Type == NodeName))
{
var toAdd = new T();
var ofst = 0;
if (toAdd.Parse(child, ref ofst))
{
Value.Add(toAdd);
}
}
return(true);
}
public override bool Parse(IFFFile.Node Source, ref int offset)
{
int numVars = Source.Data.ReadInt32(ref offset);
if (numVars != Source.Children.Count())
{
throw new InvalidOperationException(string.Format("count in data stream({0}) does not match the number of nodes ({1})", numVars, Source.Children.Count()));
}
foreach (var item in Source.Children.Where(cur => cur.Type == "XXXX"))
{
var readOffset = 0;
var varName = item.Data.ReadAsciiString(ref readOffset);
switch (varName)
{
case "variableName":
VariableName = new StringData(item, ref readOffset);
break;
case "minValueInclusive":
MinValueInclusive = new IntegerData(item, ref readOffset);
break;
case "defaultValue":
DefaultValue = new IntegerData(item, ref readOffset);
break;
case "maxValueExclusive":
MaxValueExclusive = new IntegerData(item, ref readOffset);
break;
}
}
return(true);
}
public override bool Parse(IFFFile.Node Source, ref int offset)
{
return(Parse(Source.Data, ref offset));
}
public FloatData(IFFFile.Node Source, ref int Offset) : base(Source, ref Offset, DataTypes.Float)
{
}
public VectorData(IFFFile.Node Source, ref int Offset) : base(Source, ref Offset, DataTypes.Vector)
{
}
public StringData(IFFFile.Node Source, ref int Offset) : base(Source, ref Offset, DataTypes.String)
{
}
protected void ParseData(IFFFile.Node node, ITemplateRepository repo, Action <IFFFile.Node, ITemplateRepository> parseDataAction, LogAbstraction.ILogger logger, Action <IFFFile.Node, ITemplateRepository> parseDerveAction = null, bool parseNext = true)
{
if (parseDerveAction == null)
{
parseDerveAction = ParseDerv;
}
var derv = node.FindSubNode("DERV");
if (derv != null)
{
parseDerveAction(node, repo);
}
var nextNode = derv != null?derv.FindNextSibling() : node.Children.FirstOrDefault();
if (nextNode == null)
{
_Logger.Trace("unable to locate next node for node {0}", node.Type);
return;
}
var sizeNode = nextNode.FindSubNode("PCNT", true);
if (sizeNode == null || nextNode.Children == null)
{
logger.Trace("Unable to locate PCNT node or its parent for node {0}", node.Type);
return;
}
var nodeList = nextNode.Children.ToList();
var size = sizeNode.Data.ReadInt32();
if (size == 0 || size != nodeList.Count - 1)
{
return;
}
for (int i = 0; i < size; i++)
{
switch (nodeList[i].Type)
{
case "PCNT":
continue;
case "XXXX":
parseDataAction(nodeList[i], repo);
break;
case "DERV":
parseDerveAction(nodeList[i], repo);
break;
default:
logger.Warn("Invalid node type {0}", nodeList[i].Type);
break;
}
}
nextNode = nextNode.FindNextSibling();
if (parseNext && nextNode != null)
{
ReadNode(nextNode, repo);
}
}
/*private void InternalParse(IFFFile.Node node, ITemplateRepository repo)
* {
* ParseData(node, repo, ParseData, _Logger);
* }*/
private void ParseData(IFFFile.Node node, ITemplateRepository repo)
{
int offset = 0;
var name = node.Data.ReadAsciiString(ref offset);
switch (name)
{
case "objectName":
ObjectName = TryParseAssign(node, ref offset, ObjectName);
break;
case "detailedDescription":
DetailedDescription = TryParseAssign(node, ref offset, DetailedDescription);
break;
case "lookAtText":
LookAtText = TryParseAssign(node, ref offset, LookAtText);
break;
case "snapToTerrain":
SnapToTerrain = TryParseAssign(node, ref offset, SnapToTerrain);
break;
case "containerType":
ContainerType = TryParseAssign(node, ref offset, ContainerType);
break;
case "containerVolumeLimit":
ContainerVolumeLimit = TryParseAssign(node, ref offset, ContainerVolumeLimit);
break;
case "tintPallete":
TintPallete = TryParseAssign(node, ref offset, TintPallete);
break;
case "slotDescriptorFilename":
SlotDescriptorFileName = TryParseAssign(node, ref offset, SlotDescriptorFileName);
break;
case "arrangementDescriptorFilename":
ArrangementDescriptorFileName = TryParseAssign(node, ref offset, ArrangementDescriptorFileName);
break;
case "appearanceFilename":
AppearanceFileName = TryParseAssign(node, ref offset, AppearanceFileName);
break;
case "portalLayoutFilename":
PortalLayoutFileName = TryParseAssign(node, ref offset, PortalLayoutFileName);
break;
case "clientDataFile":
ClientDataFile = TryParseAssign(node, ref offset, ClientDataFile);
break;
case "collisionMaterialFlags":
CollisionMaterialFlags = TryParseAssign(node, ref offset, CollisionMaterialFlags);
break;
case "collisionMaterialPassFlags":
CollisionMaterialPassFlags = TryParseAssign(node, ref offset, CollisionMaterialPassFlags);
break;
case "collisionMaterialBlockFlags":
CollisionMaterialBlockFlags = TryParseAssign(node, ref offset, CollisionMaterialBlockFlags);
break;
case "collisionActionFlags":
CollisionActionFlags = TryParseAssign(node, ref offset, CollisionActionFlags);
break;
case "collisionActionPassFlags":
CollisionActionPassFlags = TryParseAssign(node, ref offset, CollisionActionPassFlags);
break;
case "collisionActionBlockFlags":
CollisionActionBlockFlags = TryParseAssign(node, ref offset, CollisionActionBlockFlags);
break;
case "scale":
Scale = TryParseAssign(node, ref offset, Scale);
break;
case "gameObjectType":
GameObjectType = TryParseAssign(node, ref offset, GameObjectType);
ClientGameObjectType = GameObjectType.Value;
break;
case "sendToClient":
SendToClient = TryParseAssign(node, ref offset, SendToClient);
break;
case "scaleThresholdBeforeExtentTest":
ScaleThresholdBeforeExtentTest = TryParseAssign(node, ref offset, ScaleThresholdBeforeExtentTest);
break;
case "clearFloraRadius":
ClearFloraRadius = TryParseAssign(node, ref offset, ClearFloraRadius);
break;
case "surfaceType":
SurfaceType = TryParseAssign(node, ref offset, SurfaceType);
break;
case "noBuildRadius":
NoBuildRadius = TryParseAssign(node, ref offset, NoBuildRadius);
break;
case "onlyVisibleInTools":
OnlyVisibleInTools = TryParseAssign(node, ref offset, OnlyVisibleInTools);
break;
case "locationReservationRadius":
LocationReservationRadius = TryParseAssign(node, ref offset, LocationReservationRadius);
break;
default:
break;
}
}
public IntegerData(IFFFile.Node Source, ref int Offset) : base(Source, ref Offset, DataTypes.Int)
{
}
public GenericSharedTemplate(string rootNodeType, IFFFile.Node node, ITemplateRepository repo)
{
RootNodeType = rootNodeType;
ReadNode(node, repo);
}
public RangedIntCustomizationVariable(IFFFile.Node Source, ref int Offset) : base(Source, ref Offset, DataTypes.RangedIntCustomizationVariable)
{
}
public BoolData(IFFFile.Node Source, ref int Offset) : base(Source, ref Offset, DataTypes.Bool)
{
}
private void ParseNode(IFFFile.Node node, ITemplateRepository repo)
{
int offset = 0;
var name = node.Data.ReadAsciiString(ref offset);
switch (name)
{
case "gender":
Gender = TryParseAssign(node, ref offset, Gender);
break;
case "niche":
Niche = TryParseAssign(node, ref offset, Niche);
break;
case "species":
Species = TryParseAssign(node, ref offset, Species);
break;
case "race":
Race = TryParseAssign(node, ref offset, Race);
break;
case "acceleration":
Acceleration = TryParseAssign(node, ref offset, Acceleration);
break;
case "speed":
Speed = TryParseAssign(node, ref offset, Speed);
break;
case "turnRate":
TurnRate = TryParseAssign(node, ref offset, TurnRate);
break;
case "animationMapFilename":
AnimationMapFilename = TryParseAssign(node, ref offset, AnimationMapFilename);
break;
case "slopeModAngle":
SlopeModAngle = TryParseAssign(node, ref offset, SlopeModAngle);
break;
case "slopeModPercent":
SlopeModPercent = TryParseAssign(node, ref offset, SlopeModPercent);
break;
case "waterModPercent":
WaterModPercent = TryParseAssign(node, ref offset, WaterModPercent);
break;
case "stepHeight":
StepHeight = TryParseAssign(node, ref offset, StepHeight);
break;
case "collisionHeight":
CollisionHeight = TryParseAssign(node, ref offset, CollisionHeight);
break;
case "collisionRadius":
CollisionRadius = TryParseAssign(node, ref offset, CollisionRadius);
break;
case "movementDatatable":
MovementDatatable = TryParseAssign(node, ref offset, MovementDatatable);
break;
case "postureAlignToTerrain":
PostureAlignToTerrain = TryParseAssign(node, ref offset, PostureAlignToTerrain);
break;
case "swimHeight":
SwimHeight = TryParseAssign(node, ref offset, SwimHeight);
break;
case "warpTolerance":
WarpTolerance = TryParseAssign(node, ref offset, WarpTolerance);
break;
case "collisionOffsetX":
CollisionOffsetX = TryParseAssign(node, ref offset, CollisionOffsetX);
break;
case "collisionOffsetZ":
CollisionOffsetZ = TryParseAssign(node, ref offset, CollisionOffsetZ);
break;
case "collisionLength":
CollisionLength = TryParseAssign(node, ref offset, CollisionLength);
break;
case "cameraHeight":
CameraHeight = TryParseAssign(node, ref offset, CameraHeight);
break;
default:
break;
}
}
public PaletteColorCustomizationVariable(IFFFile.Node Source, ref int Offset)
: this()
{
Parse(Source, ref Offset);
}
