public static void SetLocation(IExportEntry export, float x, float y, float z)
{
StructProperty prop = export.GetProperty <StructProperty>("location");
SetLocation(prop, x, y, z);
export.WriteProperty(prop);
}
static void addObjectToSequence(int index, bool removeLinks, IExportEntry sequenceExport)
{
var seqObjs = sequenceExport.GetProperty<ArrayProperty<ObjectProperty>>("SequenceObjects");
if (seqObjs != null)
{
seqObjs.Add(new ObjectProperty(index + 1));
sequenceExport.WriteProperty(seqObjs);
PropertyCollection props = sequenceExport.GetProperties();
IExportEntry newObject = sequenceExport.FileRef.getExport(index);
PropertyCollection newObjectProps = newObject.GetProperties();
newObjectProps.AddOrReplaceProp(new ObjectProperty(sequenceExport.UIndex, "ParentSequence"));
if (removeLinks)
{
var outLinksProp = newObjectProps.GetProp<ArrayProperty<StructProperty>>("OutputLinks");
if (outLinksProp != null)
{
foreach (var prop in outLinksProp)
{
prop.GetProp<ArrayProperty<StructProperty>>("Links").Clear();
}
}
var varLinksProp = newObjectProps.GetProp<ArrayProperty<StructProperty>>("VariableLinks");
if (varLinksProp != null)
{
foreach (var prop in varLinksProp)
{
prop.GetProp<ArrayProperty<ObjectProperty>>("LinkedVariables").Clear();
}
}
}
newObject.WriteProperties(newObjectProps);
newObject.idxLink = sequenceExport.UIndex;
}
}
static void cloneSequence(IExportEntry exp, IExportEntry parentSequence)
{
IMEPackage pcc = exp.FileRef;
if (exp.ClassName == "Sequence")
{
var seqObjs = exp.GetProperty<ArrayProperty<ObjectProperty>>("SequenceObjects");
if (seqObjs == null || seqObjs.Count == 0)
{
return;
}
//store original list of sequence objects;
List<int> oldObjects = seqObjs.Select(x => x.Value).ToList();
//clear original sequence objects
seqObjs.Clear();
exp.WriteProperty(seqObjs);
//clone all children
for (int i = 0; i < oldObjects.Count; i++)
{
cloneObject(oldObjects[i] - 1, exp, false);
}
//re-point children's links to new objects
seqObjs = exp.GetProperty<ArrayProperty<ObjectProperty>>("SequenceObjects");
foreach (var seqObj in seqObjs)
{
IExportEntry obj = pcc.getExport(seqObj.Value - 1);
var props = obj.GetProperties();
var outLinksProp = props.GetProp<ArrayProperty<StructProperty>>("OutputLinks");
if (outLinksProp != null)
{
foreach (var outLinkStruct in outLinksProp)
{
var links = outLinkStruct.GetProp<ArrayProperty<StructProperty>>("Links");
foreach (var link in links)
{
var linkedOp = link.GetProp<ObjectProperty>("LinkedOp");
linkedOp.Value = seqObjs[oldObjects.IndexOf(linkedOp.Value)].Value;
}
}
}
var varLinksProp = props.GetProp<ArrayProperty<StructProperty>>("VariableLinks");
if (varLinksProp != null)
{
foreach (var varLinkStruct in varLinksProp)
{
var links = varLinkStruct.GetProp<ArrayProperty<ObjectProperty>>("LinkedVariables");
foreach (var link in links)
{
link.Value = seqObjs[oldObjects.IndexOf(link.Value)].Value;
}
}
}
var eventLinksProp = props.GetProp<ArrayProperty<StructProperty>>("EventLinks");
if (eventLinksProp != null)
{
foreach (var eventLinkStruct in eventLinksProp)
{
var links = eventLinkStruct.GetProp<ArrayProperty<ObjectProperty>>("LinkedEvents");
foreach (var link in links)
{
link.Value = seqObjs[oldObjects.IndexOf(link.Value)].Value;
}
}
}
obj.WriteProperties(props);
}
//re-point sequence links to new objects
int oldObj = 0;
int newObj = 0;
var propCollection = exp.GetProperties();
var inputLinksProp = propCollection.GetProp<ArrayProperty<StructProperty>>("InputLinks");
if (inputLinksProp != null)
{
foreach (var inLinkStruct in inputLinksProp)
{
var linkedOp = inLinkStruct.GetProp<ObjectProperty>("LinkedOp");
oldObj = linkedOp.Value;
if (oldObj != 0)
{
newObj = seqObjs[oldObjects.IndexOf(oldObj)].Value;
linkedOp.Value = newObj;
NameProperty linkAction = inLinkStruct.GetProp<NameProperty>("LinkAction");
var nameRef = linkAction.Value;
nameRef.count = pcc.getExport(newObj - 1).indexValue;
linkAction.Value = nameRef;
}
}
}
var outputLinksProp = propCollection.GetProp<ArrayProperty<StructProperty>>("OutputLinks");
if (outputLinksProp != null)
{
foreach (var outLinkStruct in outputLinksProp)
{
var linkedOp = outLinkStruct.GetProp<ObjectProperty>("LinkedOp");
oldObj = linkedOp.Value;
if (oldObj != 0)
{
newObj = seqObjs[oldObjects.IndexOf(oldObj)].Value;
linkedOp.Value = newObj;
NameProperty linkAction = outLinkStruct.GetProp<NameProperty>("LinkAction");
var nameRef = linkAction.Value;
nameRef.count = pcc.getExport(newObj - 1).indexValue;
linkAction.Value = nameRef;
}
}
}
exp.WriteProperties(propCollection);
}
else if (exp.ClassName == "SequenceReference")
{
//set OSequenceReference to new sequence
var oSeqRefProp = exp.GetProperty<ObjectProperty>("oSequenceReference");
if (oSeqRefProp == null || oSeqRefProp.Value == 0)
{
return;
}
int oldSeqIndex = oSeqRefProp.Value;
oSeqRefProp.Value = exp.UIndex + 1;
exp.WriteProperty(oSeqRefProp);
//clone sequence
cloneObject(oldSeqIndex - 1, parentSequence, false);
//remove cloned sequence from SeqRef's parent's sequenceobjects
var seqObjs = parentSequence.GetProperty<ArrayProperty<ObjectProperty>>("SequenceObjects");
seqObjs.RemoveAt(seqObjs.Count - 1);
parentSequence.WriteProperty(seqObjs);
//set SequenceReference's linked name indices
List<int> inputIndices = new List<int>();
List<int> outputIndices = new List<int>();
IExportEntry newSequence = pcc.getExport(exp.Index + 1);
var props = newSequence.GetProperties();
var inLinksProp = props.GetProp<ArrayProperty<StructProperty>>("InputLinks");
if (inLinksProp != null)
{
foreach (var inLink in inLinksProp)
{
inputIndices.Add(inLink.GetProp<NameProperty>("LinkAction").Value.count);
}
}
var outLinksProp = props.GetProp<ArrayProperty<StructProperty>>("OutputLinks");
if (outLinksProp != null)
{
foreach (var outLinks in outLinksProp)
{
outputIndices.Add(outLinks.GetProp<NameProperty>("LinkAction").Value.count);
}
}
props = exp.GetProperties();
inLinksProp = props.GetProp<ArrayProperty<StructProperty>>("InputLinks");
if (inLinksProp != null)
{
for (int i = 0; i < inLinksProp.Count; i++)
{
NameProperty linkAction = inLinksProp[i].GetProp<NameProperty>("LinkAction");
var nameRef = linkAction.Value;
nameRef.count = inputIndices[i];
linkAction.Value = nameRef;
}
}
outLinksProp = props.GetProp<ArrayProperty<StructProperty>>("OutputLinks");
if (outLinksProp != null)
{
for (int i = 0; i < outLinksProp.Count; i++)
{
NameProperty linkAction = outLinksProp[i].GetProp<NameProperty>("LinkAction");
var nameRef = linkAction.Value;
nameRef.count = outputIndices[i];
linkAction.Value = nameRef;
}
}
exp.WriteProperties(props);
//set new Sequence's link and ParentSequence prop to SeqRef
newSequence.WriteProperty(new ObjectProperty(exp.UIndex, "ParentSequence"));
newSequence.idxLink = exp.UIndex;
//set DefaultViewZoom to magic number to flag that this is a cloned Sequence Reference and global saves cannot be used with it
//ugly, but it should work
newSequence.WriteProperty(new FloatProperty(CLONED_SEQREF_MAGIC, "DefaultViewZoom"));
}
}
public static void CreateReachSpec(IExportEntry startNode, bool createTwoWay, IExportEntry destinationNode, string reachSpecClass, ReachSpecSize size, PropertyCollection externalGUIDProperties = null)
{
IMEPackage Pcc = startNode.FileRef;
IExportEntry reachSpectoClone = Pcc.Exports.FirstOrDefault(x => x.ClassName == "ReachSpec");
if (externalGUIDProperties != null) //EXTERNAL
{
//external node
//Debug.WriteLine("Num Exports: " + pcc.Exports.Count);
if (reachSpectoClone != null)
{
IExportEntry outgoingSpec = reachSpectoClone.Clone();
Pcc.addExport(outgoingSpec);
IEntry reachSpecClassImp = GetEntryOrAddImport(Pcc, reachSpecClass); //new class type.
outgoingSpec.idxClass = reachSpecClassImp.UIndex;
outgoingSpec.idxObjectName = reachSpecClassImp.idxObjectName;
var properties = outgoingSpec.GetProperties();
ObjectProperty outgoingSpecStartProp = properties.GetProp <ObjectProperty>("Start"); //START
StructProperty outgoingEndStructProp = properties.GetProp <StructProperty>("End"); //Embeds END
ObjectProperty outgoingSpecEndProp = outgoingEndStructProp.Properties.GetProp <ObjectProperty>(SharedPathfinding.GetReachSpecEndName(outgoingSpec)); //END
outgoingSpecStartProp.Value = startNode.UIndex;
outgoingSpecEndProp.Value = 0;
var endGuid = outgoingEndStructProp.GetProp <StructProperty>("Guid");
endGuid.Properties = externalGUIDProperties; //set the other guid values to our guid values
//Add to source node prop
ArrayProperty <ObjectProperty> PathList = startNode.GetProperty <ArrayProperty <ObjectProperty> >("PathList");
PathList.Add(new ObjectProperty(outgoingSpec.UIndex));
startNode.WriteProperty(PathList);
outgoingSpec.WriteProperties(properties);
//Write Spec Size
SharedPathfinding.SetReachSpecSize(outgoingSpec, size.SpecRadius, size.SpecHeight);
//Reindex reachspecs.
SharedPathfinding.ReindexMatchingObjects(outgoingSpec);
}
}
else
{
//Debug.WriteLine("Source Node: " + startNode.Index);
//Debug.WriteLine("Num Exports: " + pcc.Exports.Count);
//int outgoingSpec = pcc.ExportCount;
//int incomingSpec = pcc.ExportCount + 1;
if (reachSpectoClone != null)
{
IExportEntry outgoingSpec = reachSpectoClone.Clone();
Pcc.addExport(outgoingSpec);
IExportEntry incomingSpec = null;
if (createTwoWay)
{
incomingSpec = reachSpectoClone.Clone();
Pcc.addExport(incomingSpec);
}
IEntry reachSpecClassImp = GetEntryOrAddImport(Pcc, reachSpecClass); //new class type.
outgoingSpec.idxClass = reachSpecClassImp.UIndex;
outgoingSpec.idxObjectName = reachSpecClassImp.idxObjectName;
var outgoingSpecProperties = outgoingSpec.GetProperties();
if (reachSpecClass == "Engine.SlotToSlotReachSpec")
{
outgoingSpecProperties.Add(new ByteProperty(1, "SpecDirection")); //We might need to find a way to support this edit
}
//Debug.WriteLine("Outgoing UIndex: " + outgoingSpecExp.UIndex);
ObjectProperty outgoingSpecStartProp = outgoingSpecProperties.GetProp <ObjectProperty>("Start"); //START
StructProperty outgoingEndStructProp = outgoingSpecProperties.GetProp <StructProperty>("End"); //Embeds END
ObjectProperty outgoingSpecEndProp = outgoingEndStructProp.Properties.GetProp <ObjectProperty>(SharedPathfinding.GetReachSpecEndName(outgoingSpec)); //END
outgoingSpecStartProp.Value = startNode.UIndex;
outgoingSpecEndProp.Value = destinationNode.UIndex;
//Add to source node prop
var PathList = startNode.GetProperty <ArrayProperty <ObjectProperty> >("PathList");
PathList.Add(new ObjectProperty(outgoingSpec.UIndex));
startNode.WriteProperty(PathList);
//Write Spec Size
SetReachSpecSize(outgoingSpecProperties, size.SpecRadius, size.SpecHeight);
outgoingSpec.WriteProperties(outgoingSpecProperties);
if (createTwoWay)
{
incomingSpec.idxClass = reachSpecClassImp.UIndex;
incomingSpec.idxObjectName = reachSpecClassImp.idxObjectName;
var incomingSpecProperties = incomingSpec.GetProperties();
if (reachSpecClass == "Engine.SlotToSlotReachSpec")
{
incomingSpecProperties.Add(new ByteProperty(2, "SpecDirection"));
}
ObjectProperty incomingSpecStartProp = incomingSpecProperties.GetProp <ObjectProperty>("Start"); //START
StructProperty incomingEndStructProp = incomingSpecProperties.GetProp <StructProperty>("End"); //Embeds END
ObjectProperty incomingSpecEndProp = incomingEndStructProp.Properties.GetProp <ObjectProperty>(SharedPathfinding.GetReachSpecEndName(incomingSpec)); //END
incomingSpecStartProp.Value = destinationNode.UIndex; //Uindex
incomingSpecEndProp.Value = startNode.UIndex;
//Add reachspec to destination node's path list (returning)
var DestPathList = destinationNode.GetProperty <ArrayProperty <ObjectProperty> >("PathList");
DestPathList.Add(new ObjectProperty(incomingSpec.UIndex));
destinationNode.WriteProperty(DestPathList);
//destNode.WriteProperty(DestPathList);
SetReachSpecSize(incomingSpecProperties, size.SpecRadius, size.SpecHeight);
incomingSpec.WriteProperties(incomingSpecProperties);
}
//Reindex reachspecs.
SharedPathfinding.ReindexMatchingObjects(outgoingSpec);
}
}
}
public void serializeTalkfileToExport(ME1Package pcc, IExportEntry export, bool savePackage = false)
{
/* converts Huffmann Tree to binary form */
byte[] treeBuffer = ConvertHuffmanTreeToBuffer();
var encodedStrings = new List <EncodedString>();
int i = 0;
foreach (var entry in _inputData)
{
if (entry.Flags == 0)
{
if (entry.StringID > 0)
{
entry.Index = -1;
}
else
{
entry.Index = 0;
}
}
else
{
entry.Index = i;
i++;
var binaryData = new List <BitArray>();
int binaryLength = 0;
/* for every character in a string, put it's binary code into data array */
foreach (char c in entry.ASCIIData)
{
binaryData.Add(_huffmanCodes[c]);
binaryLength += _huffmanCodes[c].Count;
}
byte[] buffer = BitArrayListToByteArray(binaryData, binaryLength);
encodedStrings.Add(new EncodedString(entry.ASCIIData.Length, buffer.Length, buffer));
}
}
/* writing properties */
export.WriteProperty(new IntProperty(_inputData.Count, "m_nHashTableSize"));
MemoryStream m = new MemoryStream();
/* writing entries */
m.Write(BitConverter.GetBytes(_inputData.Count), 0, 4);
foreach (TLKStringRef entry in _inputData)
{
m.Write(BitConverter.GetBytes(entry.StringID), 0, 4);
m.Write(BitConverter.GetBytes(entry.Flags), 0, 4);
m.Write(BitConverter.GetBytes(entry.Index), 0, 4);
}
/* writing HuffmanTree */
m.Write(treeBuffer, 0, treeBuffer.Length);
/* writing data */
m.Write(BitConverter.GetBytes(encodedStrings.Count), 0, 4);
foreach (EncodedString enc in encodedStrings)
{
m.Write(BitConverter.GetBytes(enc.stringLength), 0, 4);
m.Write(BitConverter.GetBytes(enc.encodedLength), 0, 4);
m.Write(enc.binaryData, 0, enc.encodedLength);
}
byte[] buff = m.ToArray();
export.setBinaryData(buff);
if (savePackage)
{
pcc.save(pcc.FileName);
}
}
