To achieve this, we simply need to create a script (named ScriptingObjects) with some properties we want to serialize; then, we change its class inheritance from MonoBehaviour to ScriptableObject as follows:

using UnityEngine;

public class ScriptingObjects : ScriptableObject {

  public Vector2[] MyPositions;
}

Great! So we have some serializable data. However, to use it in the editor, we need to create an option in the editor to create and save these assets for us. Create a new script named PositionManager in the Editor under AssetsScripts and replace its contents with the following code:

using UnityEngine;
using UnityEditor;

public class PositionManager : MonoBehaviour
{
  //Define a menu option in the editor to create the new asset
  [MenuItem("Assets/Create/PositionManager")]
  public static void CreateAsset()
  {
    //Create a new instance of our scriptable object
    ScriptingObjects positionManager = ScriptableObject.CreateInstance<ScriptingObjects>();

    //Create a .asset file for our new object and save it
    AssetDatabase.CreateAsset(positionManager, "Assets/newPositionManager.asset");
    AssetDatabase.SaveAssets();

    //Now switch the inspector to our new object
    EditorUtility.FocusProjectWindow();
    Selection.activeObject = positionManager;
  }
}

There is a lot to explain, but it is all commented very well in short, as follows:

If you return to Unity now and right-click on the Asset folder (or click on the Create menu option in the Project view), you will see the new menu option you just created, as shown in the following screenshot:

After clicking on it, you will see your new asset in the Project view (in the location you saved it to, in this case, the root of the Asset folder) and the Inspector view for your item, as shown in the following screenshot:

If we rename our new serialized object, give it some values, and save the scene or project, we will see the following screenshot:

We go from the preceding screenshot to the following code stored in the .asset file (when opened from the .asset file generated in Unity from File Explorer):

%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &11400000
MonoBehaviour:
  m_ObjectHideFlags: 0
  m_PrefabParentObject: {fileID: 0}
  m_PrefabInternal: {fileID: 0}
  m_GameObject: {fileID: 0}
  m_Enabled: 1
  m_EditorHideFlags: 0
  m_Script: {fileID: 11500000, guid: fa9c23f7a21df484a96802b68617f3b6, type: 3}
  m_Name: MyPositions1
  m_EditorClassIdentifier: 
  MyPositions:
  - {x: 10, y: 10}
  - {x: 20, y: 20}
  - {x: 30, y: 30}
  - {x: 30, y: 30}
  - {x: 40, y: 40}

There is a fair amount of Unity information in the preceding code, but what is important is our serialized data at the bottom. So if we wish, we can edit this file outside of the editor and it will be reimported next time you open Unity.

Using the files in the editor is a very simple task. Simply create a property in any script using the type of your serialized asset and then assign a project asset in the editor.

For example, edit the MessagingManager script and add the following property:

public ScriptingObjects MyWaypoints;

Then, the script will be exposed in the Inspector pane and you can assign it normally, as shown in the following screenshot:

You will also be able to access the contents of the serialized object from that script as well.

Now, if you don't want to assign the asset through the editor, there is a way to just load the .asset file directly from the project.

Firstly, to do this, you will need to store your .asset files in a special folder named Resources in your Asset folder. You can read them there directly using Unity's own resource functions once.

As an example, open the PositionManager script and add the following function:

public static PositionManager ReadPositionsFromAsset(string Name)
{
  string path = "/";

  object o = Resources.Load(path + Name);
  PositionManager retrievedPositions = (PositionManager)o;
  return retrievedPositions;
}

This function, which is available from anywhere as it is static, will perform the following tasks:

So now you can call up the data contained within your .asset file anywhere in your game project.