public bool LoadPersistentData(IMyTerminalBlock store)
{
    string error = PersistentDataLoader.LoadData(store.CustomData, out persistentData);

    if (error != "")
    {
        Warn("Error loading persistent data: " + error);
        return false;
    }
    else
    {
        currentRoute = persistentData.Route;
        return true;
    }
}

public void SavePersistentData(IMyTerminalBlock store)
{
    persistentData.Route = currentRoute;

    store.CustomData = PersistentDataLoader.SaveData(persistentData, store.CustomData);
}

public class Route
{
    public struct Waypoint
    {
        public Vector3D Position;

        public Waypoint(Vector3D position, int waitTime)
        {
            Position = position;
        }
    }

    List<Waypoint> m_waypoints;

    public Route()
    {
        m_waypoints = new List<Waypoint>();
    }

    public void AddWaypoint(Vector3D point)
    {
        m_waypoints.Add(new Waypoint(point));
    }

    public void ClearWaypoints()
    {
        m_waypoints.Clear();
    }

    public List<string> SaveToLines()
    {
        var lines = new List<string>();
        foreach (var waypoint in m_waypoints)
        {
            lines.Add(waypoint.Position.X + "," +
                        waypoint.Position.Y + "," +
                        waypoint.Position.Z + "," +
                        waypoint.WaitTime);
        }
        return lines;
    }

    public void LoadFromLines(List<string> lines)
    {
        // clear current waypoints
        ClearWaypoints();

        //  add new waypoints
        foreach (var line in lines)
        {
            // validate and add waypoint
            var data = line.Split(',');
            double x, y, z;
            int waitTime;
            if (data.Count() == 4 &&
                double.TryParse(data[0], out x) &&
                double.TryParse(data[1], out y) &&
                double.TryParse(data[2], out z))
            {
                AddWaypoint(new Vector3D(x, y, z));
            }
        }
    }
}


public struct PersistentData
{
    public Route Route;
}

public static class PersistentDataLoader
{
    static string dataBeginMarker = "PERSISTENT_DATA_BEGIN";
    static string dataEndMarker = "PERSISTENT_DATA_END";
    static string waypointMarker = "waypoint:";

    enum ErrorTypes
    {
        NoError,
        DataParseError,
        NoDataFoundError,
        DataDidNotBeginError,
        UnknownError
    }

    // creates the string conversion of a PersistentData struct and inserts it into custom data
    public static string SaveData(PersistentData pData, string text)
    {
        // first, get converted data
        var cData = SaveData(pData);

        // if no text, just save right here
        if (text == "")
        {
            return cData;
        }

        // if there is text, break out any existing PersistentData
        var lines = System.Text.RegularExpressions.Regex.Split(text, "\r\n|\r|\n");
        var newLines = new List<string>();
        var sb = new StringBuilder();
        if (lines.Count() < 500)
        {
            // look for beginning of data persistence
            bool hasStarted = false;
            foreach (var line in lines)
            {
                if (hasStarted)
                {
                    if (line == dataEndMarker)
                    {
                        hasStarted = false;
                    }
                }
                else if (line == dataBeginMarker)
                {
                    hasStarted = true;
                }
                else
                {
                    newLines.Add(line);
                }
            }

            for (int i = 0; i < newLines.Count(); i++)
            {
                if (i == newLines.Count() - 1)
                {
                    sb.Append(newLines[i]);
                }
                else
                {
                    sb.AppendLine(newLines[i]);
                }
            }
        }
        else
        {
            sb.Append(text);
        }

        sb.Append(cData);

        return sb.ToString();
    }

    // returns the string conversion of a PersistentData struct
    public static string SaveData(PersistentData pData)
    {
        // begin line strings
        var lines = new List<string>();
        lines.Add(dataBeginMarker);

        // save waypoints info
        var waypoints = pData.Route.SaveToLines();
        foreach (var waypoint in waypoints)
        {
            lines.Add(waypointMarker + waypoint);
        }

        // add ending
        lines.Add(dataEndMarker);

        // send back string to append to custom data
        var sb = new StringBuilder();
        foreach (var line in lines)
        {
            sb.AppendLine(line);
        }
        return sb.ToString();
    }

    // loads data from a custom data string into an existing PersistentData struct
    public static string LoadData(string text, out PersistentData pData)
    {
        // prepare struct for use by guaranteeing all fields are filled out
        pData.Route = new Route();

        string error = "";
        var data = new List<string>();

        if (text == "")
        {
            var sb = new StringBuilder();
            sb.AppendLine(dataBeginMarker);
            sb.Append(dataEndMarker);
            text = sb.ToString();
        }

        // split into lines
        var lines = System.Text.RegularExpressions.Regex.Split(text, "\r\n|\r|\n");

        // don't mess it all up!!!
        if (lines.Count() > 500)
            return GetErrorMessage(ErrorTypes.DataParseError);

        // look for beginning of data persistence
        bool hasStarted = false;
        foreach (var line in lines)
        {
            if (hasStarted)
            {
                if (line == dataEndMarker)
                {
                    break;
                }
                else
                {
                    data.Add(line);
                }
            }
            else if (line == dataBeginMarker)
            {
                hasStarted = true;
            }
        }

        // load version
        pData.Route = new Route();

        // prepare data that must be finalized post-search
        var waypointLines = new List<string>();

        // load general data
        foreach (var line in data)
        {
            // load waypoints
            if (line.StartsWith(waypointMarker))
            {
                waypointLines.Add(line.Substring(waypointMarker.Count()));
            }
        }

        // finalize data where necessary
        pData.Route.LoadFromLines(waypointLines);

        // no errors occurred!
        return "";
    }

    static string GetErrorMessage(string type, string details = "")
    {
        string errorMessage = type;
        if (details != "")
        {
            errorMessage += " { " + details + " }";
        }
        return errorMessage;
    }

    static string GetErrorMessage(ErrorTypes type, string details = "")
    {
        switch (type)
        {
            case ErrorTypes.NoError: return GetErrorMessage("", details);
            case ErrorTypes.DataParseError: return GetErrorMessage("An error occurred while parsing the custom data.", details);
            case ErrorTypes.NoDataFoundError: return GetErrorMessage("No data was given.", details);
            case ErrorTypes.DataDidNotBeginError: return GetErrorMessage("Could not find the beginning of the data.", details);
            default: return GetErrorMessage("Unknown error.", details);
        }
    }
}