[Release]Pathfinder Open Source

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Windows.Forms;

namespace Pathfinder_Editor_Project
{
    public class MapDestination
    {
        #region Public Variables
        public MapData[] Data;
        #endregion

        #region Private Variables
        ///////////////////////
        // Private Variables //
        ///////////////////////
        private int[] encryptionKeys;
        private const int NameLength = 255;
        private const int DescriptionLength = 257;
        private const int PathLength = 532;
        #endregion

            public MapDestination()
            {
                //Initialisation Code for MapData structure

                //Setup the encryption key array
                encryptionKeys = new int[27] 
                { 0xA1, 0xEF, 0xC4, 0xA7, 0xA1, 0xEF, 0xD3, 0xF2, 0xA1, 0xEF, 0xCD, 0xBB, 0xA1, 0xEF, 0xC6,
                    0xC6, 0xA1, 0xEF, 0x31, 0x30, 0x30, 0xA1, 0xEF, 0xCD, 0xF2, 0xA1, 0xEF };



            }

            public void LoadFile(string FileName)
            {
                //Loads input file for the pathfinder to create mapdata

                //Declare Variables
                FileStream fs;
                BinaryReader br;
                int pathCount;
                int keyIndex = 0; //Used to track what encryption key is to be used.

                //Check file exists
                if (!File.Exists(FileName))
                {throw new Exception("File not found! (" + FileName + ")");}

                //Create filestream
                fs = new FileStream(FileName,FileMode.Open);

                //Create Binary Reader
                br = new BinaryReader(fs);

                //Get the path count
                pathCount = br.ReadInt32();

                //Check length of file
                if (fs.Length < pathCount * PathLength + 4)
                {throw new Exception("File not large enough!");}

                //Setup MapData array
                Data = new MapData[pathCount];

                //Loopthrough and get all the data from the file.
                for (int pathIndex = 0; pathIndex < pathCount; pathIndex++)
                {
                    //Check if the keyindex is at it's limit
                    if (keyIndex == encryptionKeys.Length)
                    { keyIndex = 0; }

                    //Initialise the Path's Name and Description
                    Data[pathIndex].Name = string.Empty;
                    Data[pathIndex].Description = string.Empty;

                    //Get all the characters of the name and decrypt it
                    //using the current encryption key
                    for (int charIndex = 0; charIndex < NameLength; charIndex++)
                    {
                        Data[pathIndex].Name +=
                            Convert.ToChar(
                                br.ReadByte() ^ encryptionKeys[keyIndex]);
                    }

                    //Get all the characters of the description and decrypt it
                    //using the current encryption key
                    for (int charIndex = 0; charIndex < DescriptionLength; charIndex++)
                    {
                        Data[pathIndex].Description +=
                            Convert.ToChar(
                                br.ReadByte() ^ encryptionKeys[keyIndex]);
                    }

                    //Get the first byte of the MenuID and decrypt it using the current encryption key
                    Data[pathIndex].MenuID = br.ReadByte() ^ encryptionKeys[keyIndex];
                    //Get the remaining 3 bytes using any special rules required depending on current encryption key
                    if (keyIndex >= 18 && keyIndex <= 20)
                    {
                        Data[pathIndex].MenuID += br.ReadByte() * 256;
                        Data[pathIndex].MenuID += br.ReadByte() * 65536;
                        Data[pathIndex].MenuID += br.ReadByte() * 16777216;
                    }
                    else
                    {
                        Data[pathIndex].MenuID += (br.ReadByte() ^ 0xFF) * 256;
                        Data[pathIndex].MenuID += (br.ReadByte() ^ 0xFF) * 65536;
                        Data[pathIndex].MenuID += (br.ReadByte() ^ 0xFF) * 16777216;
                    }

                    //Get the first byte of the X position and decrypt it using the current encryption key
                    Data[pathIndex].PosX = br.ReadByte() ^ encryptionKeys[keyIndex];
                    //Get the remaining 3 bytes using any special rules required depending on current encryption key
                    if (keyIndex >= 18 && keyIndex <= 20)
                    {
                        Data[pathIndex].PosX += br.ReadByte() * 256;
                        Data[pathIndex].PosX += br.ReadByte() * 65536;
                        Data[pathIndex].PosX += br.ReadByte() * 16777216;
                    }
                    else
                    {
                        Data[pathIndex].PosX += (br.ReadByte() ^ 0xFF) * 256;
                        Data[pathIndex].PosX += (br.ReadByte() ^ 0xFF) * 65536;
                        Data[pathIndex].PosX += (br.ReadByte() ^ 0xFF) * 16777216;
                    }

                    //Get the first byte of the Y position and decrypt it using the current encryption key
                    Data[pathIndex].PosY = br.ReadByte() ^ encryptionKeys[keyIndex];
                    //Get the remaining 3 bytes using any special rules required depending on current encryption key
                    if (keyIndex >= 18 && keyIndex <= 20)
                    {
                        Data[pathIndex].PosY += br.ReadByte() * 256;
                        Data[pathIndex].PosY += br.ReadByte() * 65536;
                        Data[pathIndex].PosY += br.ReadByte() * 16777216;
                    }
                    else
                    {
                        Data[pathIndex].PosY += (br.ReadByte() ^ 0xFF) * 256;
                        Data[pathIndex].PosY += (br.ReadByte() ^ 0xFF) * 65536;
                        Data[pathIndex].PosY += (br.ReadByte() ^ 0xFF) * 16777216;
                    }

                    //Get the first byte of the parent ID and decrypt it using the current encryption key
                    Data[pathIndex].ParentID = br.ReadByte() ^ encryptionKeys[keyIndex];
                    //Get the remaining 3 bytes using any special rules required depending on current encryption key
                    if (keyIndex >= 18 && keyIndex <= 20)
                    {
                        Data[pathIndex].ParentID += br.ReadByte() * 256;
                        Data[pathIndex].ParentID += br.ReadByte() * 65536;
                        Data[pathIndex].ParentID += br.ReadByte() * 16777216;
                    }
                    else
                    {
                        Data[pathIndex].ParentID += (br.ReadByte() ^ 0xFF) * 256;
                        Data[pathIndex].ParentID += (br.ReadByte() ^ 0xFF) * 65536;
                        Data[pathIndex].ParentID += (br.ReadByte() ^ 0xFF) * 16777216;
                    }

                    //Get the first byte of the map ID and decrypt it using the current encryption key
                    Data[pathIndex].MapID = br.ReadByte() ^ encryptionKeys[keyIndex];
                    //Get the remaining 3 bytes using any special rules required depending on current encryption key
                    if (keyIndex >= 18 && keyIndex <= 20)
                    {
                        Data[pathIndex].MapID += br.ReadByte() * 256;
                        Data[pathIndex].MapID += br.ReadByte() * 65536;
                        Data[pathIndex].MapID += br.ReadByte() * 16777216;
                    }
                    else
                    {
                        Data[pathIndex].MapID += (br.ReadByte() ^ 0xFF) * 256;
                        Data[pathIndex].MapID += (br.ReadByte() ^ 0xFF) * 65536;
                        Data[pathIndex].MapID += (br.ReadByte() ^ 0xFF) * 16777216;
                    }

                    //Add one to the keyIndex
                    keyIndex++;

                }

                //Close the file
                fs.Close();
            }

            public string[] GetNameList()
            {
                //Declare Variables
                string[] result = new string[Data.Length];
                int nullIndex;

                for (int pathIndex = 0; pathIndex < Data.Length; pathIndex++)
                {
                    //Get the index of the first null byte
                    nullIndex = Data[pathIndex].Name.IndexOf(Convert.ToChar(0x00));

                    //If the null index is greater than 0 then modify the result otherwise use the original
                    if (nullIndex > 0)
                    {
                        //Get only the data that contains a character
                        result[pathIndex] = Data[pathIndex].Name.Substring(0, nullIndex);
                    }
                    else
                    {
                        result[pathIndex] = Data[pathIndex].Name;
                    }

                    
                }

                return result;
            }

            public int[] GetMapList()
            {
                //Declare Variables
                int[] result = new int[Data.Length];

                for (int pathIndex = 0; pathIndex < Data.Length; pathIndex++)
                {
                        result[pathIndex] = Data[pathIndex].MapID;
                }

                return result;
            }

            public struct MapData
        {
            //Declare Variables
            #region Public Variables
            //////////////////////
            // Public Variables //
            //////////////////////
            public string Name;
            public string Description;
            public int MenuID;
            public int PosX;
            public int PosY;
            public int ParentID;
            public int MapID;
            public int ID;
            #endregion
        };

    }
}