PichotM/experimental_path_fixing.cs

## experimental_path_fixing.cs
using System;
using CodeWalker.GameFiles;
using System.IO;
using SharpDX;
using System.Collections.Generic;
using NodReader;
using CodeWalker;

namespace YNDMover
{

    public partial class MainYND
    {
        private string basePath = "NODE_FOLDER";
        private string targetPath = "NODE_DESTINATION";

        private List<YndFile> AllYnds = new List<YndFile>();

        private static Dictionary<int, List<Node>> NodeList = new Dictionary<int, List<Node>>();
        private static Dictionary<int, NodeLink[]> LinkList = new Dictionary<int, NodeLink[]>();
        private static List<NodeData> NodeDataList = new List<NodeData>();

        private static List<YndFile> LegacyYndFileList = new List<YndFile>();
        private static Dictionary<int, YndFile> YndFileList = new Dictionary<int, YndFile>();
        private static Dictionary<int, YndFile> YndFileList2 = new Dictionary<int, YndFile>();

        private static List<NewLink> NewLinkList = new List<NewLink>();

        private static string logContent = "";

        private void WriteLine(string text)
        {
            logContent += text + "\n";
        }

        private void DoNodeStuff(YndNode uselessNode, YndNode centerNode, YndNode outerNode, YndLink link)
        {
            NewLink newLink = new NewLink();

            foreach (NodeData nodeData in NodeDataList)
            {
                if (nodeData.newNode.AreaID == uselessNode.AreaID && nodeData.newNode.NodeID == uselessNode.NodeID)
                {
                    NodeList[nodeData.newNode.AreaID].Remove(nodeData.Node);
                }
                else if (nodeData.newNode == centerNode)
                {
                    newLink.centerNode = nodeData.Node;
                }
                else if (nodeData.newNode == outerNode)
                {
                    newLink.outerNode = nodeData.Node;
                }
            }

            newLink.link = link;
            NewLinkList.Add(newLink);
        }

        private static void Main()
        {
            MainYND mainYND = new MainYND();
            mainYND.Launch();
        }

        private void BuildNodes(Dictionary<int, YndFile> yndList)
        {
            NodeDataList.Clear();

            foreach (KeyValuePair<int, List<Node>> entry in NodeList)
            {
                YndFile ynd;
                if (!yndList.ContainsKey(entry.Key))
                {
                    ynd = new YndFile();
                    ynd.AreaID = (ushort)entry.Key;
                    ynd.NodeDictionary = new NodeDictionary();

                    yndList[entry.Key] = ynd;
                }
                else
                {
                    ynd = yndList[entry.Key];
                }

                foreach (Node node in entry.Value)
                {
                    YndNode newNode = ynd.AddNode();
                    newNode.AreaID = (ushort)ynd.AreaID;
                    newNode.SetPosition(new Vector3(node.PositionX / 4.0f, node.PositionY / 4.0f, node.PositionZ / 32.0f));

                    var flag = node.LinkCountFlags.Value & 7;
                    var flags5 = (uint)(flag);
                    if (BitUtil.IsBitSet(node.Flags2, 6)) // Freeway
                    {
                        flags5 = BitUtil.UpdateBit(flags5, 0, BitUtil.IsBitSet(flags5, 0));
                        flags5 = BitUtil.UpdateBit(flags5, 1, true);
                        flags5 = BitUtil.UpdateBit(flags5, 2, true);
                    }

                    if (BitUtil.IsBitSet(node.Flags2, 2) && !BitUtil.IsBitSet(flags5, 0)) // Junction
                    {
                        flags5 = BitUtil.UpdateBit(flags5, 0, true);
                        flags5 = BitUtil.UpdateBit(flags5, 1, BitUtil.IsBitSet(flags5, 1));
                        flags5 = BitUtil.UpdateBit(flags5, 2, true);
                    }

                    newNode.Flags0 = node.Flags0;
                    newNode.Flags1 = node.Flags1;
                    newNode.Flags2 = node.Flags2;
                    newNode.Flags3 = node.Flags3;
                    newNode.Flags4 = node.Flags4;
                    newNode.LinkCountUnk = (int)flags5;
                    //Console.WriteLine(newNode.LinkCountUnk);

                    bool IsPedNode = newNode.Flags4 > 100;
                    if (IsPedNode)
                    {
                        ynd.NodeDictionary.NodesCountPed++;
                    }
                    else
                    {
                        ynd.NodeDictionary.NodesCountVehicle++;
                    }

                    NodeData nodeData = new NodeData();
                    nodeData.Node = node;
                    nodeData.newNode = newNode;
                    nodeData.AreaID = newNode.AreaID;

                    NodeDataList.Add(nodeData);
                }
            }
        }

        private void BuildNodesLinks(Dictionary<int, YndFile> yndList)
        {
            foreach (KeyValuePair<int, YndFile> entry in yndList)
            {
                YndFile ynd = entry.Value;
                foreach (YndNode yndNode in ynd.Nodes)
                {
                    NodeData nodeData = new NodeData();
                    foreach (NodeData iindoe in NodeDataList)
                    {
                        if (iindoe.newNode == yndNode)
                        {
                            nodeData = iindoe;
                            break;
                        }
                    }

                    int links = nodeData.Node.LinkCountFlags.Value >> 3;
                    if (links != 0)
                    {
                        for (var i = 0; i < links; i++)
                        {
                            int linkArrayIndex = nodeData.Node.LinkID + i;
                            NodeLink targetLink = LinkList[nodeData.Node.AreaID][linkArrayIndex];
                            foreach (NodeData node2 in NodeDataList)
                            {
                                if (node2.Node.NodeID == targetLink.NodeID && node2.AreaID == targetLink.AreaID)
                                {
                                    YndLink newLink = yndNode.AddLink(node2.newNode);

                                    newLink.Flags0 = targetLink.Flags0;
                                    newLink.Flags1 = targetLink.Flags1;
                                    newLink.Flags2 = targetLink.Flags2;

                                    newLink.UpdateLength();
                                }
                            }
                        }
                    }
                }
            }

            if (NewLinkList != null && NewLinkList.Count != 0)
            {
                foreach(NewLink newLink in NewLinkList)
                {
                    YndNode centerNode = null;
                    YndNode outerNode = null;

                    foreach(NodeData node in NodeDataList)
                    {
                        if (node.Node.AreaID == newLink.centerNode.AreaID && node.Node.NodeID == newLink.centerNode.NodeID)
                        {
                            centerNode = node.newNode;
                        }
                        else if (node.Node.AreaID == newLink.outerNode.AreaID && node.Node.NodeID == newLink.outerNode.NodeID)
                        {
                            outerNode = node.newNode;
                        }

                        if (outerNode != null && centerNode != null) { break; }
                    }

                    if (outerNode != null && centerNode != null)
                    {
                        YndLink n1 = outerNode.AddLink(centerNode);
                        n1.Flags0 = newLink.link.Flags0;
                        n1.Flags1 = newLink.link.Flags1;
                        n1.Flags2 = newLink.link.Flags2;

                        YndLink n2 = centerNode.AddLink(outerNode);
                        n2.Flags0 = newLink.link.Flags0;
                        n2.Flags1 = newLink.link.Flags1;
                        n2.Flags2 = newLink.link.Flags2;

                        n2.UpdateLength();
                        n1.UpdateLength();
                    }
                    else
                    {
                        WriteLine("ERROR.");
                    }
                }
            }
        }

        void Launch()
        {
            if (basePath == null || !Directory.Exists(basePath))
            {
                WriteLine("Wrong path");
                Console.ReadKey(true);
                return;
            }

            string[] yndFiles = Directory.GetFiles(basePath.Replace("\\", "//"), "*.ynd");
            if (yndFiles == null || yndFiles.Length == 0)
            {
                WriteLine("0 ynd file in this folder.");
                Console.ReadKey(true);
                return;
            }

            foreach (string filePath in yndFiles)
            {
                string fileName = Path.GetFileNameWithoutExtension(filePath);
                if (true || fileName == "nodes528")
                {

                    YndFile ynd = new YndFile();
                    byte[] data = File.ReadAllBytes(filePath);
                    ynd.Load(data);

                    string pathDir = Path.GetDirectoryName(filePath);
                    string areaidstr = fileName.ToLowerInvariant().Replace("nodes", "");

                    int areaid = 0;
                    int.TryParse(areaidstr, out areaid);
                    ynd.AreaID = areaid;

                    LegacyYndFileList.Add(ynd);

                    Console.WriteLine(ynd.AreaID.ToString());

                    WriteLine("----------------" + ynd.AreaID.ToString() + "--------------");

                    if (ynd.NodeDictionary.Links != null)
                        WriteLine("Links " + ynd.NodeDictionary.Links.Length + " | " + (ynd.Links != null ? ynd.Links.Length.ToString() : "0"));
                    if (ynd.NodeDictionary.LinksCount != null)
                        WriteLine("LinksCount " + ynd.NodeDictionary.LinksCount);
                    if (ynd.NodeDictionary.Nodes != null)
                        WriteLine("Nodes " + ynd.NodeDictionary.Nodes.Length + " | " + ynd.Nodes.Length);
                    if (ynd.NodeDictionary.NodesCount != null)
                        WriteLine("NodesCount " + ynd.NodeDictionary.NodesCount);
                    if (ynd.NodeDictionary.NodesCountPed != null)
                        WriteLine("NodesCountPed " + ynd.NodeDictionary.NodesCountPed);
                    if (ynd.NodeDictionary.NodesCountVehicle != null)
                        WriteLine("NodesCountVehicle " + ynd.NodeDictionary.NodesCountVehicle);
                    if (ynd.NodeDictionary.NodesPointer != null)
                        WriteLine("NodesPointer " + ynd.NodeDictionary.NodesPointer);

                    WriteLine("------------------------------");
                }
            }

            foreach(YndFile ynd in LegacyYndFileList)
            {
                NodeList[ynd.AreaID] = new List<Node>();
                foreach (Node node in ynd.NodeDictionary.Nodes)
                {
                    //if (node.AreaID == ynd.AreaID)
                        NodeList[ynd.AreaID].Add(node);
                }

                if (NodeList[ynd.AreaID] != null)
                {
                    WriteLine("Total nodes " + NodeList[ynd.AreaID].Count + " in " + ynd.AreaID);
                    if (ynd.Junctions != null)
                    WriteLine("Total junctions " + ynd.Junctions.Length);
                }

                LinkList[ynd.AreaID] = ynd.NodeDictionary.Links;
            }

            BuildNodes(YndFileList);
            BuildNodesLinks(YndFileList);

            int removedNodes = 0;
            foreach (KeyValuePair<int, YndFile> entry in YndFileList)
            {
                YndFile ynd = entry.Value;

                foreach (YndNode node in ynd.Nodes)
                {
                    if (node.Flags1 == 120 && node.LinkCount > 0)
                    {
                        foreach (YndLink nodeLink in node.Links)
                        {
                            if (nodeLink.Node1.LinkCountUnk != 7 && nodeLink.Node1.LinkCountUnk != 5 && !BitUtil.IsBitSet(nodeLink.Node1.Flags2, 2))
                            {
                                foreach (YndLink nodeLink1 in nodeLink.Node1.Links)
                                {
                                    if ((nodeLink1.Node1.LinkCountUnk == 7 || nodeLink1.Node1.LinkCountUnk == 5) && !BitUtil.IsBitSet(nodeLink1.Node1.Flags2, 2))
                                    {
                                        DoNodeStuff(nodeLink1.Node2, nodeLink1.Node1, node, nodeLink1);
                                        removedNodes++;
                                    }
                                }
                            }

                            if (nodeLink.Node2.LinkCountUnk != 7 && nodeLink.Node2.LinkCountUnk != 5 && !BitUtil.IsBitSet(nodeLink.Node2.Flags2, 2))
                            {
                                foreach (YndLink nodeLink2 in nodeLink.Node2.Links)
                                {
                                    if ((nodeLink2.Node2.LinkCountUnk == 7 || nodeLink2.Node2.LinkCountUnk == 5) && !BitUtil.IsBitSet(nodeLink2.Node1.Flags2, 2))
                                    {
                                        DoNodeStuff(nodeLink2.Node1, nodeLink2.Node2, node, nodeLink2);
                                        removedNodes++;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            WriteLine("Removed nodes : " + removedNodes);

            BuildNodes(YndFileList2);
            BuildNodesLinks(YndFileList2);

            WriteLine(YndFileList2.Count.ToString());

            foreach (KeyValuePair<int, YndFile> entry in YndFileList2)
            {
                YndFile ynd = entry.Value;
                byte[] newData = ynd.Save();

                if (ynd.NodeDictionary.Links != null)
                    WriteLine("Links " + ynd.NodeDictionary.Links.Length + " | " + (ynd.Links != null ? ynd.Links.Length.ToString() : "0"));
                if (ynd.NodeDictionary.LinksCount != null)
                    WriteLine("LinksCount " + ynd.NodeDictionary.LinksCount);
                if (ynd.NodeDictionary.Nodes != null)
                    WriteLine("Nodes " + ynd.NodeDictionary.Nodes.Length + " | " + ynd.Nodes.Length);
                if (ynd.NodeDictionary.NodesCount != null)
                    WriteLine("NodesCount " + ynd.NodeDictionary.NodesCount);
                if (ynd.NodeDictionary.NodesCountPed != null)
                    WriteLine("NodesCountPed " + ynd.NodeDictionary.NodesCountPed);
                if (ynd.NodeDictionary.NodesCountVehicle != null)
                    WriteLine("NodesCountVehicle " + ynd.NodeDictionary.NodesCountVehicle);
                if (ynd.NodeDictionary.NodesPointer != null)
                    WriteLine("NodesPointer " + ynd.NodeDictionary.NodesPointer);
                WriteLine("------------------------------");

                WriteLine("Successfully written " + ynd.AreaID + " node.");
                Console.WriteLine("Successfully written " + ynd.AreaID + " node.");
                File.WriteAllBytes(targetPath + "//nodes" + ynd.AreaID.ToString() + ".ynd", newData);
            }

            Console.Write("\nPress any key to exit...");
            File.WriteAllText("log.txt", logContent);
            Console.ReadKey(true);
        }
    }
}
	using System;
	using CodeWalker.GameFiles;
	using System.IO;
	using SharpDX;
	using System.Collections.Generic;
	using NodReader;
	using CodeWalker;

	namespace YNDMover
	{

	public partial class MainYND
	{
	private string basePath = "NODE_FOLDER";
	private string targetPath = "NODE_DESTINATION";

	private List<YndFile> AllYnds = new List<YndFile>();

	private static Dictionary<int, List<Node>> NodeList = new Dictionary<int, List<Node>>();
	private static Dictionary<int, NodeLink[]> LinkList = new Dictionary<int, NodeLink[]>();
	private static List<NodeData> NodeDataList = new List<NodeData>();

	private static List<YndFile> LegacyYndFileList = new List<YndFile>();
	private static Dictionary<int, YndFile> YndFileList = new Dictionary<int, YndFile>();
	private static Dictionary<int, YndFile> YndFileList2 = new Dictionary<int, YndFile>();

	private static List<NewLink> NewLinkList = new List<NewLink>();

	private static string logContent = "";

	private void WriteLine(string text)
	{
	logContent += text + "\n";
	}

	private void DoNodeStuff(YndNode uselessNode, YndNode centerNode, YndNode outerNode, YndLink link)
	{
	NewLink newLink = new NewLink();

	foreach (NodeData nodeData in NodeDataList)
	{
	if (nodeData.newNode.AreaID == uselessNode.AreaID && nodeData.newNode.NodeID == uselessNode.NodeID)
	{
	NodeList[nodeData.newNode.AreaID].Remove(nodeData.Node);
	}
	else if (nodeData.newNode == centerNode)
	{
	newLink.centerNode = nodeData.Node;
	}
	else if (nodeData.newNode == outerNode)
	{
	newLink.outerNode = nodeData.Node;
	}
	}

	newLink.link = link;
	NewLinkList.Add(newLink);
	}

	private static void Main()
	{
	MainYND mainYND = new MainYND();
	mainYND.Launch();
	}

	private void BuildNodes(Dictionary<int, YndFile> yndList)
	{
	NodeDataList.Clear();

	foreach (KeyValuePair<int, List<Node>> entry in NodeList)
	{
	YndFile ynd;
	if (!yndList.ContainsKey(entry.Key))
	{
	ynd = new YndFile();
	ynd.AreaID = (ushort)entry.Key;
	ynd.NodeDictionary = new NodeDictionary();

	yndList[entry.Key] = ynd;
	}
	else
	{
	ynd = yndList[entry.Key];
	}

	foreach (Node node in entry.Value)
	{
	YndNode newNode = ynd.AddNode();
	newNode.AreaID = (ushort)ynd.AreaID;
	newNode.SetPosition(new Vector3(node.PositionX / 4.0f, node.PositionY / 4.0f, node.PositionZ / 32.0f));

	var flag = node.LinkCountFlags.Value & 7;
	var flags5 = (uint)(flag);
	if (BitUtil.IsBitSet(node.Flags2, 6)) // Freeway
	{
	flags5 = BitUtil.UpdateBit(flags5, 0, BitUtil.IsBitSet(flags5, 0));
	flags5 = BitUtil.UpdateBit(flags5, 1, true);
	flags5 = BitUtil.UpdateBit(flags5, 2, true);
	}

	if (BitUtil.IsBitSet(node.Flags2, 2) && !BitUtil.IsBitSet(flags5, 0)) // Junction
	{
	flags5 = BitUtil.UpdateBit(flags5, 0, true);
	flags5 = BitUtil.UpdateBit(flags5, 1, BitUtil.IsBitSet(flags5, 1));
	flags5 = BitUtil.UpdateBit(flags5, 2, true);
	}

	newNode.Flags0 = node.Flags0;
	newNode.Flags1 = node.Flags1;
	newNode.Flags2 = node.Flags2;
	newNode.Flags3 = node.Flags3;
	newNode.Flags4 = node.Flags4;
	newNode.LinkCountUnk = (int)flags5;
	//Console.WriteLine(newNode.LinkCountUnk);

	bool IsPedNode = newNode.Flags4 > 100;
	if (IsPedNode)
	{
	ynd.NodeDictionary.NodesCountPed++;
	}
	else
	{
	ynd.NodeDictionary.NodesCountVehicle++;
	}

	NodeData nodeData = new NodeData();
	nodeData.Node = node;
	nodeData.newNode = newNode;
	nodeData.AreaID = newNode.AreaID;

	NodeDataList.Add(nodeData);
	}
	}
	}

	private void BuildNodesLinks(Dictionary<int, YndFile> yndList)
	{
	foreach (KeyValuePair<int, YndFile> entry in yndList)
	{
	YndFile ynd = entry.Value;
	foreach (YndNode yndNode in ynd.Nodes)
	{
	NodeData nodeData = new NodeData();
	foreach (NodeData iindoe in NodeDataList)
	{
	if (iindoe.newNode == yndNode)
	{
	nodeData = iindoe;
	break;
	}
	}

	int links = nodeData.Node.LinkCountFlags.Value >> 3;
	if (links != 0)
	{
	for (var i = 0; i < links; i++)
	{
	int linkArrayIndex = nodeData.Node.LinkID + i;
	NodeLink targetLink = LinkList[nodeData.Node.AreaID][linkArrayIndex];
	foreach (NodeData node2 in NodeDataList)
	{
	if (node2.Node.NodeID == targetLink.NodeID && node2.AreaID == targetLink.AreaID)
	{
	YndLink newLink = yndNode.AddLink(node2.newNode);

	newLink.Flags0 = targetLink.Flags0;
	newLink.Flags1 = targetLink.Flags1;
	newLink.Flags2 = targetLink.Flags2;

	newLink.UpdateLength();
	}
	}
	}
	}
	}
	}

	if (NewLinkList != null && NewLinkList.Count != 0)
	{
	foreach(NewLink newLink in NewLinkList)
	{
	YndNode centerNode = null;
	YndNode outerNode = null;

	foreach(NodeData node in NodeDataList)
	{
	if (node.Node.AreaID == newLink.centerNode.AreaID && node.Node.NodeID == newLink.centerNode.NodeID)
	{
	centerNode = node.newNode;
	}
	else if (node.Node.AreaID == newLink.outerNode.AreaID && node.Node.NodeID == newLink.outerNode.NodeID)
	{
	outerNode = node.newNode;
	}

	if (outerNode != null && centerNode != null) { break; }
	}

	if (outerNode != null && centerNode != null)
	{
	YndLink n1 = outerNode.AddLink(centerNode);
	n1.Flags0 = newLink.link.Flags0;
	n1.Flags1 = newLink.link.Flags1;
	n1.Flags2 = newLink.link.Flags2;

	YndLink n2 = centerNode.AddLink(outerNode);
	n2.Flags0 = newLink.link.Flags0;
	n2.Flags1 = newLink.link.Flags1;
	n2.Flags2 = newLink.link.Flags2;

	n2.UpdateLength();
	n1.UpdateLength();
	}
	else
	{
	WriteLine("ERROR.");
	}
	}
	}
	}

	void Launch()
	{
	if (basePath == null \|\| !Directory.Exists(basePath))
	{
	WriteLine("Wrong path");
	Console.ReadKey(true);
	return;
	}

	string[] yndFiles = Directory.GetFiles(basePath.Replace("\\", "//"), "*.ynd");
	if (yndFiles == null \|\| yndFiles.Length == 0)
	{
	WriteLine("0 ynd file in this folder.");
	Console.ReadKey(true);
	return;
	}

	foreach (string filePath in yndFiles)
	{
	string fileName = Path.GetFileNameWithoutExtension(filePath);
	if (true \|\| fileName == "nodes528")
	{

	YndFile ynd = new YndFile();
	byte[] data = File.ReadAllBytes(filePath);
	ynd.Load(data);

	string pathDir = Path.GetDirectoryName(filePath);
	string areaidstr = fileName.ToLowerInvariant().Replace("nodes", "");

	int areaid = 0;
	int.TryParse(areaidstr, out areaid);
	ynd.AreaID = areaid;

	LegacyYndFileList.Add(ynd);

	Console.WriteLine(ynd.AreaID.ToString());

	WriteLine("----------------" + ynd.AreaID.ToString() + "--------------");

	if (ynd.NodeDictionary.Links != null)
	WriteLine("Links " + ynd.NodeDictionary.Links.Length + " \| " + (ynd.Links != null ? ynd.Links.Length.ToString() : "0"));
	if (ynd.NodeDictionary.LinksCount != null)
	WriteLine("LinksCount " + ynd.NodeDictionary.LinksCount);
	if (ynd.NodeDictionary.Nodes != null)
	WriteLine("Nodes " + ynd.NodeDictionary.Nodes.Length + " \| " + ynd.Nodes.Length);
	if (ynd.NodeDictionary.NodesCount != null)
	WriteLine("NodesCount " + ynd.NodeDictionary.NodesCount);
	if (ynd.NodeDictionary.NodesCountPed != null)
	WriteLine("NodesCountPed " + ynd.NodeDictionary.NodesCountPed);
	if (ynd.NodeDictionary.NodesCountVehicle != null)
	WriteLine("NodesCountVehicle " + ynd.NodeDictionary.NodesCountVehicle);
	if (ynd.NodeDictionary.NodesPointer != null)
	WriteLine("NodesPointer " + ynd.NodeDictionary.NodesPointer);

	WriteLine("------------------------------");
	}
	}

	foreach(YndFile ynd in LegacyYndFileList)
	{
	NodeList[ynd.AreaID] = new List<Node>();
	foreach (Node node in ynd.NodeDictionary.Nodes)
	{
	//if (node.AreaID == ynd.AreaID)
	NodeList[ynd.AreaID].Add(node);
	}

	if (NodeList[ynd.AreaID] != null)
	{
	WriteLine("Total nodes " + NodeList[ynd.AreaID].Count + " in " + ynd.AreaID);
	if (ynd.Junctions != null)
	WriteLine("Total junctions " + ynd.Junctions.Length);
	}

	LinkList[ynd.AreaID] = ynd.NodeDictionary.Links;
	}

	BuildNodes(YndFileList);
	BuildNodesLinks(YndFileList);

	int removedNodes = 0;
	foreach (KeyValuePair<int, YndFile> entry in YndFileList)
	{
	YndFile ynd = entry.Value;

	foreach (YndNode node in ynd.Nodes)
	{
	if (node.Flags1 == 120 && node.LinkCount > 0)
	{
	foreach (YndLink nodeLink in node.Links)
	{
	if (nodeLink.Node1.LinkCountUnk != 7 && nodeLink.Node1.LinkCountUnk != 5 && !BitUtil.IsBitSet(nodeLink.Node1.Flags2, 2))
	{
	foreach (YndLink nodeLink1 in nodeLink.Node1.Links)
	{
	if ((nodeLink1.Node1.LinkCountUnk == 7 \|\| nodeLink1.Node1.LinkCountUnk == 5) && !BitUtil.IsBitSet(nodeLink1.Node1.Flags2, 2))
	{
	DoNodeStuff(nodeLink1.Node2, nodeLink1.Node1, node, nodeLink1);
	removedNodes++;
	}
	}
	}

	if (nodeLink.Node2.LinkCountUnk != 7 && nodeLink.Node2.LinkCountUnk != 5 && !BitUtil.IsBitSet(nodeLink.Node2.Flags2, 2))
	{
	foreach (YndLink nodeLink2 in nodeLink.Node2.Links)
	{
	if ((nodeLink2.Node2.LinkCountUnk == 7 \|\| nodeLink2.Node2.LinkCountUnk == 5) && !BitUtil.IsBitSet(nodeLink2.Node1.Flags2, 2))
	{
	DoNodeStuff(nodeLink2.Node1, nodeLink2.Node2, node, nodeLink2);
	removedNodes++;
	}
	}
	}
	}
	}
	}
	}

	WriteLine("Removed nodes : " + removedNodes);

	BuildNodes(YndFileList2);
	BuildNodesLinks(YndFileList2);

	WriteLine(YndFileList2.Count.ToString());

	foreach (KeyValuePair<int, YndFile> entry in YndFileList2)
	{
	YndFile ynd = entry.Value;
	byte[] newData = ynd.Save();

	if (ynd.NodeDictionary.Links != null)
	WriteLine("Links " + ynd.NodeDictionary.Links.Length + " \| " + (ynd.Links != null ? ynd.Links.Length.ToString() : "0"));
	if (ynd.NodeDictionary.LinksCount != null)
	WriteLine("LinksCount " + ynd.NodeDictionary.LinksCount);
	if (ynd.NodeDictionary.Nodes != null)
	WriteLine("Nodes " + ynd.NodeDictionary.Nodes.Length + " \| " + ynd.Nodes.Length);
	if (ynd.NodeDictionary.NodesCount != null)
	WriteLine("NodesCount " + ynd.NodeDictionary.NodesCount);
	if (ynd.NodeDictionary.NodesCountPed != null)
	WriteLine("NodesCountPed " + ynd.NodeDictionary.NodesCountPed);
	if (ynd.NodeDictionary.NodesCountVehicle != null)
	WriteLine("NodesCountVehicle " + ynd.NodeDictionary.NodesCountVehicle);
	if (ynd.NodeDictionary.NodesPointer != null)
	WriteLine("NodesPointer " + ynd.NodeDictionary.NodesPointer);
	WriteLine("------------------------------");

	WriteLine("Successfully written " + ynd.AreaID + " node.");
	Console.WriteLine("Successfully written " + ynd.AreaID + " node.");
	File.WriteAllBytes(targetPath + "//nodes" + ynd.AreaID.ToString() + ".ynd", newData);
	}

	Console.Write("\nPress any key to exit...");
	File.WriteAllText("log.txt", logContent);
	Console.ReadKey(true);
	}
	}
	}