public static PathingCategory FromNanoXmlNode(NanoXmlNode categoryNode, PathingCategory parent)
{
string categoryName = categoryNode.GetAttribute(MARKERCATEGORY_NAME_ATTR)?.Value;
// Can't define a marker category without a name
if (string.IsNullOrEmpty(categoryName))
{
return(null);
}
var subjCategory = parent.Contains(categoryName)
// We're extending an existing category
? parent[categoryName]
// We're adding a new category
: parent.GetOrAddCategoryFromNamespace(categoryName);
subjCategory.DisplayName = categoryNode.GetAttribute(MARKERCATEGORY_DISPLAYNAME_ATTR)?.Value;
subjCategory.IsSeparator = categoryNode.GetAttribute(MARKERCATEGORY_ISSEPARATOR_ATTR)?.Value == "1";
subjCategory.DefaultToggle = categoryNode.GetAttribute(MARKERCATEGORY_DEFAULTTOGGLE_ATTR)?.Value != "0";
subjCategory.SetAttributes(AttributeBuilder.FromNanoXmlNode(categoryNode));
if (parent.Namespace == "Tactical.GuildMission.Bounty")
{
subjCategory.SetAttributes(new PathableAttributeCollection(new List <PathableAttribute> {
new PathableAttribute("IconFile", "Data\\Bounty.png")
}));
}
return(subjCategory);
}
public static PathingCategory FromNanoXmlNode(NanoXmlNode categoryNode, PathingCategory parent)
{
string categoryName = categoryNode.GetAttribute(MARKERCATEGORY_NAME_ATTR)?.Value;
// Can't define a marker category without a name.
if (string.IsNullOrEmpty(categoryName))
{
// TODO: Log markercategory has no name.
return(null);
}
var subjCategory = parent.Contains(categoryName)
// We're extending an existing category.
? parent[categoryName]
// We're adding a new category.
: parent.GetOrAddCategoryFromNamespace(categoryName);
subjCategory.LoadedFromPack = true;
// Have to ensure we only override if the attributes exist in case we're overwriting an existing category.
if (categoryNode.TryGetAttribute(MARKERCATEGORY_DISPLAYNAME_ATTR, out var displayNameAttr))
{
subjCategory.DisplayName = displayNameAttr.Value;
}
if (categoryNode.TryGetAttribute(MARKERCATEGORY_ISSEPARATOR_ATTR, out var isSeparatorAttr))
{
subjCategory.IsSeparator = isSeparatorAttr.Value == "1";
}
if (categoryNode.TryGetAttribute(MARKERCATEGORY_DEFAULTTOGGLE_ATTR, out var defaultToggleAttr))
{
subjCategory.DefaultToggle = defaultToggleAttr.Value != "0";
}
// Remove redundant attributes now kept track of by the pathable itself.
categoryNode.Attributes.RemoveAll(attr => new[] {
MARKERCATEGORY_NAME_ATTR,
//MARKERCATEGORY_DISPLAYNAME_ATTR,
MARKERCATEGORY_ISSEPARATOR_ATTR,
MARKERCATEGORY_DEFAULTTOGGLE_ATTR
}.Contains(attr.Name));
subjCategory.SetAttributes(PathablePrototypeAttributeBuilder.FromNanoXmlNode(categoryNode));
return(subjCategory);
}
private void WriteMarkerCategory(XmlWriter categoryWriter, PathingCategory pathingCategory)
{
categoryWriter.WriteStartElement(PackConstImpl.XML_ELEMENT_MARKERCATEGORY);
categoryWriter.WriteAttributeString(PackConstImpl.XML_KNOWNATTRIBUTE_NAME, pathingCategory.Name);
foreach (var attribute in pathingCategory.ExplicitAttributes.Where(attribute => !_manualMarkerCategories.Contains(attribute.Name)))
{
categoryWriter.WriteAttributeString(attribute.Name, attribute.Value);
}
foreach (var subcategory in pathingCategory)
{
WriteMarkerCategory(categoryWriter, subcategory);
}
categoryWriter.WriteEndElement();
}
public static void UnpackCategory(NanoXmlNode categoryNode, PathingCategory pathingCategoryParent)
{
if (!string.Equals(categoryNode.Name, ELEMENT_CATEGORY, StringComparison.OrdinalIgnoreCase))
{
// TODO: Log attempted to unpack wrong element type as markercategory
return;
}
var loadedCategory = FromNanoXmlNode(categoryNode, pathingCategoryParent);
if (loadedCategory == null)
{
return;
}
foreach (var childCategoryNode in categoryNode.SubNodes)
{
UnpackCategory(childCategoryNode, loadedCategory);
}
}
public static void UnpackCategory(NanoXmlNode categoryNode, PathingCategory categoryParent)
{
if (!string.Equals(categoryNode.Name, ELEMENT_CATEGORY, StringComparison.OrdinalIgnoreCase))
{
Logger.Warn("Tried to unpack {categoryNodeName} as a MarkerCategory!", categoryNode.Name);
return;
}
var loadedCategory = FromNanoXmlNode(categoryNode, categoryParent);
if (loadedCategory == null)
{
return;
}
foreach (NanoXmlNode childCategoryNode in categoryNode.SubNodes)
{
UnpackCategory(childCategoryNode, loadedCategory);
}
}
public static void UnpackCategory(XmlNode categoryNode, PathingCategory categoryParent)
{
if (!string.Equals(categoryNode.Name, ELEMENT_CATEGORY, StringComparison.OrdinalIgnoreCase) && categoryNode.NodeType == XmlNodeType.Element)
{
Logger.Warn("Tried to unpack {categoryNodeName} (type: {nodeType}) as category!", categoryNode.Name, categoryNode.NodeType);
return;
}
var loadedCategory = FromXmlNode(categoryNode, categoryParent);
if (loadedCategory == null)
{
return;
}
foreach (XmlNode childCategoryNode in categoryNode)
{
UnpackCategory(childCategoryNode, loadedCategory);
}
}
public static PathingCategory FromNanoXmlNode(NanoXmlNode categoryNode, PathingCategory parent)
{
string categoryName = categoryNode.GetAttribute(MARKERCATEGORY_NAME_ATTR)?.Value;
// Can't define a marker category without a name
if (string.IsNullOrEmpty(categoryName))
{
return(null);
}
var subjCategory = parent.Contains(categoryName)
// We're extending an existing category
? parent[categoryName]
// We're adding a new category
: parent.GetOrAddCategoryFromNamespace(categoryName);
subjCategory.DisplayName = categoryNode.GetAttribute(MARKERCATEGORY_DISPLAYNAME_ATTR)?.Value;
subjCategory.SetAttributes(AttributeBuilder.FromNanoXmlNode(categoryNode));
return(subjCategory);
}
public static PathingCategory FromXmlNode(XmlNode categoryNode, PathingCategory parent)
{
string categoryName = categoryNode.Attributes["name"]?.Value;
// Can't define a marker category without a name
if (string.IsNullOrEmpty(categoryName))
{
return(null);
}
var subjCategory = parent.Contains(categoryName)
// We're extending an existing category
? parent[categoryName]
// We're adding a new category
: parent.GetOrAddCategoryFromNamespace(categoryName);
subjCategory.DisplayName = categoryNode.Attributes["DisplayName"]?.Value;
subjCategory.SourceXmlNode = categoryNode;
return(subjCategory);
}
public static void UnpackPathable(NanoXmlNode pathableNode, PathableResourceManager pathableResourceManager, PathingCategory rootCategory)
{
switch (pathableNode.Name.ToLowerInvariant())
{
case ELEMENT_POITYPE_POI:
var poiAttributes = AttributeBuilder.FromNanoXmlNode(pathableNode);
var newPoiMarker = new Pathables.TacOMarkerPathable(poiAttributes, pathableResourceManager, rootCategory);
if (newPoiMarker.SuccessfullyLoaded)
{
MarkersAndPathsModule.ModuleInstance._currentReader.RegisterPathable(newPoiMarker);
}
else
{
Logger.Warn("Failed to load marker: {markerInfo}", poiAttributes);
}
break;
case ELEMENT_POITYPE_TRAIL:
var trailAttributes = AttributeBuilder.FromNanoXmlNode(pathableNode);
var newPathTrail = new Pathables.TacOTrailPathable(trailAttributes, pathableResourceManager, rootCategory);
if (newPathTrail.SuccessfullyLoaded)
{
MarkersAndPathsModule.ModuleInstance._currentReader.RegisterPathable(newPathTrail);
}
else
{
Logger.Warn("Failed to load trail: {trailInfo}", trailAttributes);
}
break;
case ELEMENT_POITYPE_ROUTE:
var poiNodes = pathableNode.SelectNodes("poi");
foreach (var poiNode in poiNodes)
{
UnpackPathable(poiNode, pathableResourceManager, rootCategory);
}
break;
default:
Logger.Warn("Tried to pack {pathableNodeName} as a POI!", pathableNode.Name);
break;
}
}
public static void UnpackPathable(XmlNode pathableNode, PathableResourceManager pathableResourceManager, PathingCategory rootCategory)
{
switch (pathableNode.Name.ToLower())
{
case ELEMENT_POITYPE_POI:
var newPoiMarker = new Pathables.TacOMarkerPathable(pathableNode, pathableResourceManager, rootCategory);
if (newPoiMarker.SuccessfullyLoaded)
{
//Logger.Info("Marker {markerGuid} was successfully loaded!", newPoiMarker.Guid);
Readers.MarkerPackReader.RegisterPathable(newPoiMarker);
}
else
{
Logger.Warn("Failed to load marker!");
}
break;
case ELEMENT_POITYPE_TRAIL:
var newPathTrail = new Pathables.TacOTrailPathable(pathableNode, pathableResourceManager, rootCategory);
if (newPathTrail.SuccessfullyLoaded)
{
//Logger.Info("Trail {trailGuid} was successfully loaded!", newPathTrail.Guid);
Readers.MarkerPackReader.RegisterPathable(newPathTrail);
}
else
{
Logger.Warn("Failed to load trail!");
}
break;
case ELEMENT_POITYPE_ROUTE:
Logger.Warn("Support for routes has not been added yet. They have been skipped.");
break;
default:
Logger.Warn("Tried to pack {pathableNodeName} as a POI!", pathableNode.Name);
break;
}
}
private static void TryLoadPOIs(XmlDocument packDocument, PathableResourceManager pathableResourceManager, PathingCategory rootCategory)
{
var poiNodes = packDocument.DocumentElement?.SelectSingleNode("/OverlayData/POIs");
if (poiNodes == null)
{
return;
}
Logger.Info("Found {poiCount} markers to load.", poiNodes.ChildNodes.Count);
foreach (XmlNode poiNode in poiNodes)
{
Builders.PoiBuilder.UnpackPathable(poiNode, pathableResourceManager, rootCategory);
}
}
public static void UnpackPathable(XmlNode pathableNode, IPackFileSystemContext packContext, PathingCategory rootCategory)
{
switch (pathableNode.Name.ToLower())
{
case ELEMENT_POITYPE_POI:
var newPoiMarker = new TacOMarkerPathable(pathableNode, packContext, rootCategory);
if (newPoiMarker.SuccessfullyLoaded)
{
GameService.Pathing.RegisterPathable(newPoiMarker);
}
else
{
Console.WriteLine("Failed to load marker: ");
Console.WriteLine(string.Join("; ", pathableNode.Attributes.Select(s => ((XmlAttribute)s).Name + " = " + ((XmlAttribute)s).Value)));
}
break;
case ELEMENT_POITYPE_TRAIL:
var newPathTrail = new TacOTrailPathable(pathableNode, packContext, rootCategory);
if (newPathTrail.SuccessfullyLoaded)
{
GameService.Pathing.RegisterPathable(newPathTrail);
}
else
{
Console.WriteLine("Failed to load trail: ");
Console.WriteLine(string.Join("; ", pathableNode.Attributes.Select(s => ((XmlAttribute)s).Name + " = " + ((XmlAttribute)s).Value)));
}
break;
case ELEMENT_POITYPE_ROUTE:
Console.WriteLine("Skipped loading route.");
//RouteBuilder.UnpackNode(pathableNode);
break;
default:
Console.WriteLine($"Tried to unpack '{pathableNode.Name}' as POI!");
break;
}
}
internal PackCollection(PathingCategory categories = null, IEnumerable <PointOfInterest> pointsOfInterest = null)
{
this.Categories = categories ?? new PathingCategory(true);
this.PointsOfInterest = pointsOfInterest?.ToList() ?? new List <PointOfInterest>();
}
public static async Task <PointOfInterest> UnpackPathableAsync(NanoXmlNode pathableNode, IPackResourceManager pathableResourceManager, PathingCategory rootPathingCategory)
{
return(pathableNode.Name.ToLowerInvariant() switch {
PackConstImpl.XML_ELEMENT_POI => await UnpackMarkerPoi(pathableNode, pathableResourceManager, rootPathingCategory),
PackConstImpl.XML_ELEMENT_TRAIL => await UnpackTrailPoi(pathableNode, pathableResourceManager, rootPathingCategory),
PackConstImpl.XML_ELEMENT_ROUTE => await UnpackRoutePoi(pathableNode, pathableResourceManager, rootPathingCategory),
_ => await UnpackOtherPoi(pathableNode, pathableResourceManager, rootPathingCategory)
});
private static void TryLoadPOIs(XmlDocument packDocument, IPackFileSystemContext packContext, PathingCategory rootCategory)
{
var poiNodes = packDocument.DocumentElement?.SelectSingleNode("/OverlayData/POIs");
if (poiNodes == null)
{
return;
}
foreach (XmlNode poiNode in poiNodes)
{
PoiBuilder.UnpackPathable(poiNode, packContext, rootCategory);
}
}
private void TryLoadPOIs(NanoXmlDocument packDocument, PathableResourceManager pathableResourceManager, PathingCategory rootCategory)
{
var poisNodes = packDocument.RootNode.SelectNodes("pois");
for (int pSet = 0; pSet < poisNodes.Length; pSet++)
{
//ref var poisNode = ref poisNodes[pSet];
var poisNode = poisNodes[pSet];
Logger.Info("Found {poiCount} POIs to load.", poisNode.SubNodes.Count());
for (int i = 0; i < poisNode.SubNodes.Count; i++)
{
Builders.PoiBuilder.UnpackPathable(poisNode.SubNodes[i], pathableResourceManager, rootCategory);
}
}
}
public static List <Trail> FromTrlFile(string trlFile, Texture2D pathTexture, PathingCategory refCategory)
{
if (!File.Exists(trlFile))
{
Console.WriteLine("No trl file found at " + trlFile);
return(new List <Trail>());
}
var trlSections = new List <Trail>();
byte[] rawTacoTrlData = File.ReadAllBytes(trlFile);
// 32 bit, little-endian
using (var mReader = new MemoryStream(rawTacoTrlData)) {
using (var bReader = new BinaryReader(mReader, Encoding.ASCII)) {
// First four bytes are just 0000 to signify the first path section
bReader.ReadInt32();
int mapId = bReader.ReadInt32();
var trailPoints = new List <Vector3>();
while (bReader.PeekChar() != -1)
{
float x = bReader.ReadSingle();
float z = bReader.ReadSingle();
float y = bReader.ReadSingle();
// Indicates a new section in the trail (trails do not always consist of only one "section")
if (x == 0 && y == 0 && z == 0)
{
// Copy current trail to current trailSet
var nTrlSection = Trail.FromPositions(pathTexture, trailPoints, mapId);
if (nTrlSection != null)
{
trlSections.Add(nTrlSection);
}
trailPoints.Clear();
}
else
{
trailPoints.Add(new Vector3(x, y, z));
//var t = new Blish_HUD.Entities.Marker(pathTexture, new Vector3(x, y, z), Vector2.One);
//t.MapId = mapId;
//GameService.Pathing.RegisterMarker(t);
}
}
if (trailPoints.Count > 0)
{
var endTrlSection = Trail.FromPositions(pathTexture, trailPoints, mapId);
if (endTrlSection != null)
{
endTrlSection.RefCategory = refCategory;
trlSections.Add(endTrlSection);
}
trailPoints.Clear();
}
}
}
return(trlSections);
}
