// Find the ArrayEntry for this column.
// If create is true, create the ArrayEntry if it doesn't exist.
private ArrayEntry FindColumn(ArrayEntry entry, int col, bool create)
{
// Find the entry before the required one.
ArrayEntry before = FindColumnBefore(entry, col);
// If we found it, return it.
if ((before.NextEntry != null) && (before.NextEntry.ColumnNumber == col))
{
return(before.NextEntry);
}
// We didn't find it. See if we should create it.
if (create)
{
// Create the new ArrayEntry.
ArrayEntry newEntry = new ArrayEntry();
newEntry.ColumnNumber = col;
// Insert it in the row's column list.
newEntry.NextEntry = before.NextEntry;
before.NextEntry = newEntry;
// Return it.
return(newEntry);
}
// We didn't find it and shouldn't create it. Return null.
return(null);
}
public override int GetHashCode()
{
int hashcode = 157;
unchecked {
if (__isset.primitiveEntry)
{
hashcode = (hashcode * 397) + PrimitiveEntry.GetHashCode();
}
if (__isset.arrayEntry)
{
hashcode = (hashcode * 397) + ArrayEntry.GetHashCode();
}
if (__isset.mapEntry)
{
hashcode = (hashcode * 397) + MapEntry.GetHashCode();
}
if (__isset.structEntry)
{
hashcode = (hashcode * 397) + StructEntry.GetHashCode();
}
if (__isset.unionEntry)
{
hashcode = (hashcode * 397) + UnionEntry.GetHashCode();
}
if (__isset.userDefinedTypeEntry)
{
hashcode = (hashcode * 397) + UserDefinedTypeEntry.GetHashCode();
}
}
return(hashcode);
}
public static ObjectInfo ParseObjectInfo(
ArrayEntry objectEntry, Dictionary <long, ObjectInfo> objectInfosByReference,
Dictionary <string, List <ObjectInfo> > infosByListName, string objListName)
{
ObjectInfo info = GetObjectInfo(ref objectEntry, null);
infosByListName[objListName].Add(info);
if (!objectInfosByReference.ContainsKey(objectEntry.Position))
{
objectInfosByReference.Add(objectEntry.Position, info);
}
foreach (DictionaryEntry link in info.LinkEntries.Values)
{
foreach (ArrayEntry linked in link.IterArray())
{
if (!objectInfosByReference.ContainsKey(linked.Position))
{
ParseObjectInfo(linked, objectInfosByReference, infosByListName, str_Links);
}
}
}
return(info);
}
// Get or set an array value.
public T this[int row, int col]
{
get
{
// Find the entry.
ArrayEntry entry = FindEntry(row, col, false);
// If we didn't find it, return the default value.
if (entry == null)
{
return(DefaultValue);
}
// Return the entry's value.
return(entry.Value);
}
set
{
// See if this is the default value.
if (value.Equals(DefaultValue))
{
// Remove the entry from the array.
DeleteEntry(row, col);
}
else
{
// Save the new value.
// Find the entry, creating it if necessary.
ArrayEntry entry = FindEntry(row, col, true);
// Save the value.
entry.Value = value;
}
}
}
// Find the ArrayEntry for this column.
private ArrayEntry FindColumnBefore(ArrayEntry entry, int col)
{
// Find the entry before the required one.
while ((entry.NextEntry != null) && (entry.NextEntry.ColumnNumber < col))
{
entry = entry.NextEntry;
}
// Return the ArrayRow before the row or null.
return(entry);
}
protected void ReleaseArrayImpl(T[] array)
{
ArrayEntry foundEntry = null;
lock (this.ArrayEntries) {
foundEntry = this.ArrayEntries.FirstOrDefault(ae => ae.Array == array);
if (foundEntry != null)
{
foundEntry.InUse = false;
}
}
}
protected T[] GetArrayImpl(uint atLeastItemCount)
{
ArrayEntry foundEntry = null;
lock (this.ArrayEntries) {
foundEntry = this.ArrayEntries.FirstOrDefault(ae => ae.InUse == false && ae.Array.Length >= atLeastItemCount);
if (foundEntry == null)
{
foundEntry = new ArrayEntry()
{
Array = new T[atLeastItemCount],
InUse = true
};
this.ArrayEntries.Add(foundEntry);
}
}
return(foundEntry.Array);
}
public override string ToString()
{
StringBuilder sb = new StringBuilder("TTypeEntry(");
sb.Append("PrimitiveEntry: ");
sb.Append(PrimitiveEntry == null ? "<null>" : PrimitiveEntry.ToString());
sb.Append(",ArrayEntry: ");
sb.Append(ArrayEntry == null ? "<null>" : ArrayEntry.ToString());
sb.Append(",MapEntry: ");
sb.Append(MapEntry == null ? "<null>" : MapEntry.ToString());
sb.Append(",StructEntry: ");
sb.Append(StructEntry == null ? "<null>" : StructEntry.ToString());
sb.Append(",UnionEntry: ");
sb.Append(UnionEntry == null ? "<null>" : UnionEntry.ToString());
sb.Append(",UserDefinedTypeEntry: ");
sb.Append(UserDefinedTypeEntry == null ? "<null>" : UserDefinedTypeEntry.ToString());
sb.Append(")");
return(sb.ToString());
}
// Iterator.
public IEnumerator <ArrayValue <T> > GetEnumerator()
{
ArrayRow arrayRow = TopSentinel.NextRow;
while (arrayRow != null)
{
ArrayEntry arrayEntry = arrayRow.RowSentinel.NextEntry;
while (arrayEntry != null)
{
yield return(new ArrayValue <T>
{
Row = arrayRow.RowNumber,
Column = arrayEntry.ColumnNumber,
Value = arrayEntry.Value
});
arrayEntry = arrayEntry.NextEntry;
}
arrayRow = arrayRow.NextRow;
}
}
// Delete the indicated entry if it exists.
public void DeleteEntry(int row, int col)
{
// Find the row before the entry's row.
ArrayRow rowBefore = FindRowBefore(row);
// If we didn't find the row, we're done.
ArrayRow arrayRow = rowBefore.NextRow;
if ((arrayRow == null) || (arrayRow.RowNumber != row))
{
return;
}
// Find the entry before this entry's entry.
ArrayEntry entryBefore = FindColumnBefore(arrayRow.RowSentinel, col);
ArrayEntry arrayEntry = entryBefore.NextEntry;
// If we didn't find the entry, we're done.
if ((arrayEntry == null) || (arrayEntry.ColumnNumber != col))
{
return;
}
// Remove the entry from the row's list.
entryBefore.NextEntry = arrayEntry.NextEntry;
// arrayEntry.NextEntry = null;
// free(arrayEntry);
// If there are no more entries in the row, remove it.
ArrayEntry arraySentinel = arrayRow.RowSentinel;
if (arraySentinel.NextEntry == null)
{
rowBefore.NextRow = arrayRow.NextRow;
// arrayRow.RowSentinel = null;
// free(arraySentinel);
// free(arrayRow);
}
}
public ObjectCamera(ArrayEntry bymlEntry, out string objID)
{
objID = string.Empty;
foreach (var parameter in bymlEntry.IterDictionary())
{
if (parameter.Key == "Id")
{
string id = parameter.Parse();
string[] idParts = id.Split('_');
if (idParts.Length > 1)
{
idSuffix = idParts[1];
}
objID = idParts[0];
}
else
{
dynamic data = parameter.Parse();
if (data is Dictionary <string, dynamic> dict && dict.Count == 3 && dict.ContainsKey("X") && dict.ContainsKey("Y") && dict.ContainsKey("Z"))
{
data = new Vector3(
dict["X"] / 100,
dict["Y"] / 100,
dict["Z"] / 100
);
}
properties.Add(parameter.Key, data);
}
}
}
public async Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
{
oprot.IncrementRecursionDepth();
try
{
var struc = new TStruct("TTypeEntry");
await oprot.WriteStructBeginAsync(struc, cancellationToken);
var field = new TField();
if (PrimitiveEntry != null && __isset.primitiveEntry)
{
field.Name = "primitiveEntry";
field.Type = TType.Struct;
field.ID = 1;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await PrimitiveEntry.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (ArrayEntry != null && __isset.arrayEntry)
{
field.Name = "arrayEntry";
field.Type = TType.Struct;
field.ID = 2;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await ArrayEntry.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (MapEntry != null && __isset.mapEntry)
{
field.Name = "mapEntry";
field.Type = TType.Struct;
field.ID = 3;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await MapEntry.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (StructEntry != null && __isset.structEntry)
{
field.Name = "structEntry";
field.Type = TType.Struct;
field.ID = 4;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await StructEntry.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (UnionEntry != null && __isset.unionEntry)
{
field.Name = "unionEntry";
field.Type = TType.Struct;
field.ID = 5;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await UnionEntry.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
if (UserDefinedTypeEntry != null && __isset.userDefinedTypeEntry)
{
field.Name = "userDefinedTypeEntry";
field.Type = TType.Struct;
field.ID = 6;
await oprot.WriteFieldBeginAsync(field, cancellationToken);
await UserDefinedTypeEntry.WriteAsync(oprot, cancellationToken);
await oprot.WriteFieldEndAsync(cancellationToken);
}
await oprot.WriteFieldStopAsync(cancellationToken);
await oprot.WriteStructEndAsync(cancellationToken);
}
finally
{
oprot.DecrementRecursionDepth();
}
}
public void Write(TProtocol oprot)
{
TStruct struc = new TStruct("TTypeEntry");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (PrimitiveEntry != null && __isset.primitiveEntry)
{
field.Name = "primitiveEntry";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
PrimitiveEntry.Write(oprot);
oprot.WriteFieldEnd();
}
if (ArrayEntry != null && __isset.arrayEntry)
{
field.Name = "arrayEntry";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
ArrayEntry.Write(oprot);
oprot.WriteFieldEnd();
}
if (MapEntry != null && __isset.mapEntry)
{
field.Name = "mapEntry";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
MapEntry.Write(oprot);
oprot.WriteFieldEnd();
}
if (StructEntry != null && __isset.structEntry)
{
field.Name = "structEntry";
field.Type = TType.Struct;
field.ID = 4;
oprot.WriteFieldBegin(field);
StructEntry.Write(oprot);
oprot.WriteFieldEnd();
}
if (UnionEntry != null && __isset.unionEntry)
{
field.Name = "unionEntry";
field.Type = TType.Struct;
field.ID = 5;
oprot.WriteFieldBegin(field);
UnionEntry.Write(oprot);
oprot.WriteFieldEnd();
}
if (UserDefinedTypeEntry != null && __isset.userDefinedTypeEntry)
{
field.Name = "userDefinedTypeEntry";
field.Type = TType.Struct;
field.ID = 6;
oprot.WriteFieldBegin(field);
UserDefinedTypeEntry.Write(oprot);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
/// <summary>
/// Parses a 3d World from an ArrayEntry
/// </summary>
/// <param name="objectEntry"></param>
/// <param name="zone"></param>
/// <param name="objectsByReference"></param>
/// <returns></returns>
public static I3dWorldObject ParseObject(ArrayEntry objectEntry, SM3DWorldZone zone, Dictionary <long, I3dWorldObject> objectsByReference, out bool alreadyInLinks, Dictionary <string, I3dWorldObject> linkedObjsByID, bool isLinked = false)
{
ObjectInfo info = GetObjectInfo(ref objectEntry, zone);
I3dWorldObject obj;
bool loadLinks;
if ((info.ClassName == "Area") || info.ObjectName.Contains("Area") && AreaModelNames.Contains(info.ModelName))
{
obj = new AreaObject(in info, zone, out loadLinks);
}
else if (info.PropertyEntries.TryGetValue("RailPoints", out DictionaryEntry railPointEntry) && railPointEntry.NodeType == ByamlFile.ByamlNodeType.Array) //at this point we can be sure it's a rail
{
obj = new Rail(in info, zone, out loadLinks);
}
else
{
obj = new General3dWorldObject(in info, zone, out loadLinks);
}
if (isLinked && linkedObjsByID != null)
{
if (!linkedObjsByID.ContainsKey(info.ID))
{
linkedObjsByID.Add(info.ID, obj);
}
else
{
alreadyInLinks = true;
obj = linkedObjsByID[info.ID];
if (!isLinked)
{
alreadyInLinks = !zone.LinkedObjects.Remove(obj);
}
//in case this object was already read in another file
if (!objectsByReference.ContainsKey(objectEntry.Position))
{
objectsByReference.Add(objectEntry.Position, obj);
}
return(obj);
}
}
alreadyInLinks = false;
if (!objectsByReference.ContainsKey(objectEntry.Position))
{
objectsByReference.Add(objectEntry.Position, obj);
}
else if (!isLinked)
{
obj = objectsByReference[objectEntry.Position];
zone.LinkedObjects.Remove(obj);
return(obj);
}
if (loadLinks)
{
var links = new Dictionary <string, List <I3dWorldObject> >();
foreach (DictionaryEntry link in info.LinkEntries.Values)
{
links.Add(link.Key, new List <I3dWorldObject>());
foreach (ArrayEntry linked in link.IterArray())
{
if (objectsByReference.ContainsKey(linked.Position))
{
links[link.Key].Add(objectsByReference[linked.Position]);
objectsByReference[linked.Position].AddLinkDestination(link.Key, obj);
}
else
{
I3dWorldObject _obj = ParseObject(linked, zone, objectsByReference, out bool linkedAlreadyReferenced, linkedObjsByID, true);
_obj.AddLinkDestination(link.Key, obj);
links[link.Key].Add(_obj);
if (zone != null && !linkedAlreadyReferenced)
{
zone.LinkedObjects.Add(_obj);
}
}
}
}
if (links.Count > 0)
{
obj.Links = links;
}
}
return(obj);
}
private static ObjectInfo GetObjectInfo(ref ArrayEntry objectEntry, SM3DWorldZone zone)
{
Dictionary <string, DictionaryEntry> properties = new Dictionary <string, DictionaryEntry>();
Dictionary <string, DictionaryEntry> links = new Dictionary <string, DictionaryEntry>();
ObjectInfo info = new ObjectInfo();
foreach (DictionaryEntry entry in objectEntry.IterDictionary())
{
switch (entry.Key)
{
case "Comment":
case "IsLinkDest":
case "LayerConfigName":
#if ODYSSEY
case "SrcUnitLayerList":
case "PlacementFileName":
case "comment":
#endif
break; //ignore these
case "Id":
info.ID = entry.Parse();
break;
case "Links":
foreach (DictionaryEntry linkEntry in entry.IterDictionary())
{
links.Add(linkEntry.Key, linkEntry);
}
break;
case "ModelName":
info.ModelName = entry.Parse() ?? "";
break;
case "Rotate":
dynamic _data = entry.Parse();
info.Rotation = new Vector3(
_data["X"],
_data["Y"],
_data["Z"]
);
break;
case "Scale":
_data = entry.Parse();
info.Scale = new Vector3(
_data["X"],
_data["Y"],
_data["Z"]
);
break;
case "Translate":
_data = entry.Parse();
info.Position = new Vector3(
_data["X"] / 100f,
_data["Y"] / 100f,
_data["Z"] / 100f
);
break;
case "UnitConfigName":
info.ObjectName = entry.Parse();
break;
case "UnitConfig":
_data = entry.Parse();
info.DisplayTranslation = new Vector3(
_data["DisplayTranslate"]["X"] / 100f,
_data["DisplayTranslate"]["Y"] / 100f,
_data["DisplayTranslate"]["Z"] / 100f
);
info.DisplayRotation = new Vector3(
_data["DisplayRotate"]["X"],
_data["DisplayRotate"]["Y"],
_data["DisplayRotate"]["Z"]
);
info.DisplayScale = new Vector3(
_data["DisplayScale"]["X"],
_data["DisplayScale"]["Y"],
_data["DisplayScale"]["Z"]
);
info.ClassName = _data["ParameterConfigName"];
break;
default:
if (!properties.ContainsKey(entry.Key))
{
properties.Add(entry.Key, entry);
}
break;
}
}
info.PropertyEntries = properties;
info.LinkEntries = links;
return(info);
}
public override string ToString()
{
var sb = new StringBuilder("TTypeEntry(");
bool __first = true;
if (PrimitiveEntry != null && __isset.primitiveEntry)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("PrimitiveEntry: ");
sb.Append(PrimitiveEntry == null ? "<null>" : PrimitiveEntry.ToString());
}
if (ArrayEntry != null && __isset.arrayEntry)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("ArrayEntry: ");
sb.Append(ArrayEntry == null ? "<null>" : ArrayEntry.ToString());
}
if (MapEntry != null && __isset.mapEntry)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("MapEntry: ");
sb.Append(MapEntry == null ? "<null>" : MapEntry.ToString());
}
if (StructEntry != null && __isset.structEntry)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("StructEntry: ");
sb.Append(StructEntry == null ? "<null>" : StructEntry.ToString());
}
if (UnionEntry != null && __isset.unionEntry)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("UnionEntry: ");
sb.Append(UnionEntry == null ? "<null>" : UnionEntry.ToString());
}
if (UserDefinedTypeEntry != null && __isset.userDefinedTypeEntry)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("UserDefinedTypeEntry: ");
sb.Append(UserDefinedTypeEntry == null ? "<null>" : UserDefinedTypeEntry.ToString());
}
sb.Append(")");
return(sb.ToString());
}
/// <summary>
/// Parses a 3d World from an ArrayEntry
/// </summary>
/// <param name="objectEntry"></param>
/// <param name="zone"></param>
/// <param name="objectsByReference"></param>
/// <returns></returns>
public static I3dWorldObject ParseObject(ArrayEntry objectEntry, SM3DWorldZone zone, Dictionary <long, I3dWorldObject> objectsByReference, out bool alreadyInLinks, Dictionary <string, I3dWorldObject> linkedObjsByID, bool isLinked = false)
{
ObjectInfo info = GetObjectInfo(ref objectEntry, zone);
I3dWorldObject obj;
bool loadLinks;
if (Enum.GetNames(typeof(Rail.RailObjType)).Contains(info.ClassName))
{
obj = new Rail(info, zone, out loadLinks);
}
else
{
obj = new General3dWorldObject(info, zone, out loadLinks);
}
if (linkedObjsByID != null && isLinked)
{
if (!linkedObjsByID.ContainsKey(info.ID))
{
linkedObjsByID.Add(info.ID, obj);
}
else
{
alreadyInLinks = true;
obj = linkedObjsByID[info.ID];
if (!isLinked)
{
alreadyInLinks = !zone.LinkedObjects.Remove(obj);
}
//in case this object was already read in another file
if (!objectsByReference.ContainsKey(objectEntry.Position))
{
objectsByReference.Add(objectEntry.Position, obj);
}
return(obj);
}
}
alreadyInLinks = false;
if (!objectsByReference.ContainsKey(objectEntry.Position))
{
objectsByReference.Add(objectEntry.Position, obj);
}
else if (!isLinked)
{
obj = objectsByReference[objectEntry.Position];
zone.LinkedObjects.Remove(obj);
return(obj);
}
if (loadLinks)
{
obj.Links = new Dictionary <string, List <I3dWorldObject> >();
foreach (DictionaryEntry link in info.LinkEntries.Values)
{
obj.Links.Add(link.Key, new List <I3dWorldObject>());
foreach (ArrayEntry linked in link.IterArray())
{
if (objectsByReference.ContainsKey(linked.Position))
{
obj.Links[link.Key].Add(objectsByReference[linked.Position]);
objectsByReference[linked.Position].AddLinkDestination(link.Key, obj);
}
else
{
I3dWorldObject _obj = ParseObject(linked, zone, objectsByReference, out bool linkedAlreadyReferenced, linkedObjsByID, true);
_obj.AddLinkDestination(link.Key, obj);
obj.Links[link.Key].Add(_obj);
if (zone != null && !linkedAlreadyReferenced)
{
zone.LinkedObjects.Add(_obj);
}
}
}
}
if (obj.Links.Count == 0)
{
obj.Links = null;
}
}
return(obj);
}
private static void oneDimensionalArrayWork()
{
Console.WriteLine("\nHow would you like to fill the Array? \nFillFromConsole -- 1 \nFillFromFile -- 2");
switch (Int32.Parse(Console.ReadLine()))
{
case 1:
fillFromConsole();
break;
case 2:
fillFromFile("");
break;
default:
Console.WriteLine("Wrong Input");
return;
}
Console.WriteLine("\nChoose the way of implementation: \nHand-Made -- 1 \nWithSystem.Array -- 2");
OneDimensionalArrayWorkerStrategy worker;
switch (Int32.Parse(Console.ReadLine()))
{
case 1:
worker = new HandMadeOneDimensionalArrayWorkerStrategy();
break;
case 2:
worker = new SystemOneDimensionalArrayWorkerStrategy();
break;
default:
Console.WriteLine("Wrong Input");
return;
}
while (true)
{
Console.WriteLine("\nChoose the method: \nPrint -- 1 \nSortAhead -- 2 \nSortConversely -- 3 \nGetEvenNumbers -- 4 \nGetMax -- 5 \nGetMin -- 6");
switch (Int32.Parse(Console.ReadLine()))
{
case 1:
worker.printArray(arr);
break;
case 2:
Console.WriteLine("Sorted Array:");
worker.printArray(worker.sortAhead(arr));
break;
case 3:
Console.WriteLine("Sorted Array:");
worker.printArray(worker.sortConversely(arr));
break;
case 4:
Console.WriteLine("EvenNumbers from Array:");
worker.printArray(worker.evenNumbers(arr));
break;
case 5:
ArrayEntry max = worker.maxArray(arr);
Console.WriteLine("Index of Max:" + max.key);
Console.WriteLine("Value of Max:" + max.value);
break;
case 6:
ArrayEntry min = worker.maxArray(arr);
Console.WriteLine("Index of Min:", min.key);
Console.WriteLine("Value of Min:", min.value);
break;
default:
Console.WriteLine("Wrong Input");
return;
}
}
}
