General Improvements Thread

So for the map editor, I ended up making some very basic quality of life changes, while at the same time making some base changes to the Dictionary class in order to create a dictionary of points and strings in order to get the thing to serialize properly. While I wish I could take credit for making a serialized dictionary, I learned all about it here. It's definitely worth checking out.

Overall, though, figuring out how to export different tiles from the editor was... moderately difficult before I found the serializable dictionary. I'll walk you through what I ended up doing to get the whole process sorted out.

First off, I created the SerializableDictionary class I linked above. Then, I created a subclass with non-generic types within the file used to serialize the tiles themselves.

using UnityEngine;
using System.IO;
using System.Collections;
using System.Collections.Generic;

[System.Serializable]
public class TileSkins : SerializableDictionary<Vector3, string> { }

public class LevelData : ScriptableObject{

   public List<Vector3> tiles;
   public TileSkins tileSkins;
}

As you can see above, within the LevelData script I created a new class called TileSkins, which is a Dictionary of points and strings. This is mostly going to be used in the BoardCreator and Board classes.

Speaking of which, let's head on over to the BoardCreator and make some changes.

First thing's first, I updated the Save function as follows.

   public void Save()
{

       string filePath = Application.dataPath + "/Resources/Levels";

       if (!Directory.Exists(filePath))

           CreateSaveDirectory();

       LevelData board = ScriptableObject.CreateInstance<LevelData>();

       board.tiles = new List<Vector3>(tiles.Count);

       board.tileSkins = new TileSkins();



       foreach (Tile t in tiles.Values){

           Vector3 pos = new Vector3(t.pos.x, t.height, t.pos.y);

           board.tiles.Add(pos);



           string prefabName = t.name;

           prefabName = prefabName.Substring(0, prefabName.Length - 7);

           board.tileSkins.Add(pos, prefabName);

       }

       string fileName = string.Format("Assets/Resources/Levels/{1}.asset", filePath, levelName);

       AssetDatabase.CreateAsset(board, fileName);

   }


It's very similar to the code from the tutorial, the only difference is that I instantiate a new TileSkins dictionary, and then for every tile that I add to the Tiles list, I also add to the tileSkins dictionary. Because every prefab that I created with the board had the name GrassB(Clone), I truncated the prefab names by seven characters to remove that clone bit.

(I also added a serializeable field where I could input what I wanted to name the level when I save it, which is where levelName comes into play).

You'll know your serialization worked if you have your list of tiles with the name Tile Skins underneath it. 

   public void Load()
{

       Clear();

       if (levelData == null)

           return;



       foreach (Vector3 v in levelData.tiles)
{

           string prefabName;

           levelData.tileSkins.TryGetValue(v, out prefabName);

           GameObject variableForPrefab = (GameObject)Resources.Load("Prefabs/Blocks/" + prefabName, typeof(GameObject));

           GameObject instance = Instantiate(variableForPrefab) as GameObject;

           Tile t = instance.GetComponent<Tile>();

           t.Load(v);



           tiles.Add(t.pos, t);

       }

   }

And with that, we go into the Board class and modify our Load() function to account for our new TileSkins data.

   public void Load (LevelData data)
{

       _min = new Point(int.MaxValue, int.MaxValue);

       _max = new Point(int.MinValue, int.MinValue);



       for (int i = 0; i < data.tiles.Count; ++i)
{

           string prefabName;

           data.tileSkins.TryGetValue(data.tiles[i], out prefabName);

           GameObject variableForPrefab = (GameObject)Resources.Load("Prefabs/Blocks/" + prefabName, typeof(GameObject));

           GameObject instance = Instantiate(variableForPrefab) as GameObject;

           Tile t = instance.GetComponent<Tile>();

           t.Load(data.tiles[i]);



           tiles.Add(t.pos, t);



           _min.x = Mathf.Min(_min.x, t.pos.x);

           _min.y = Mathf.Min(_min.y, t.pos.y);

           _max.x = Mathf.Max(_max.x, t.pos.x);

           _max.y = Mathf.Max(_max.y, t.pos.y);

       }

   }
(I also removed the SerializedField for the tile prefab used in the game). I don't feel too good about using Resources.Load (I'll probably have to change that to an AssetPackage, as soon as I figure out how to do those), but right now it seems to get the job done just fine.

I mostly do this because I want to differentiate the tiles by more than just their texture. I might want to attach a script to the prefab that designates what kind of tile it is- that might affect movement, evasion, or allow me to introduce unique mechanics to a geomancer-like class. Don't quote me on that part, yet, because there's still a bunch of stuff I need to implement otherwise.

The game ends up looking something like this with my prefabs (apologies for the wonky resolution. I took the screenshot in the unity editor.)

This whole process ended up being the first thing I did since I finished the tutorial, and it was a bit of a doozy figuring it out. But in the end I feel... well, I'm sure the code could be better, but it's acceptable for now.

Arrrrrthritis, oh my god. You are amazing and a lifesaver. I was chewing my fingers off trying to sort this out. I have some other ideas to try, but this is brilliant. Well done!

You may need to re-read over his post to make sure you put things in the right place. The variables "_min" and "_max" are defined in the "Board" script, so if you copied his method somewhere else like the "BoardCreator" by mistake then you might get this problem.

I followed along a bit to see if it would work for me... the only note I missed at first was to add a serialized string "levelName" to the "BoardCreator", otherwise everything compiles fine for me. When you look at the finished result of a level data asset, it will look pretty much exactly like it did before, except that you will also see the label "Tile Skins" beneath the "Tiles" array. Note that it wont show the prefab used per tile location in the inspector, it simply shows that there is in fact a serialized object there.

Keep in mind that if you struggle with this too much, that there are plenty of other ways you could approach it. For example, you could make the LevelData to be a list of a new type of serialized struct that already holds the position as well as the prefab name in a single object. Something like this:


[System.Serializable]
public struct TileData {
public Vector3 position;
public string prefabName;
}


... and as an added bonus, you can actually see the prefab name in the inspector this way.

That is awesome, I am glad to help you achieve your goals!

Those sound like some fun challenges, I hope it goes well for you! One approach I had considered was to redesign the boards so that all the tiles (even gaps) are present, but perhaps you add components to the gap tiles that make sure units can't land on them (much like an occupied tile), but that flying and teleporting units can traverse past them. It would also solve the issue with the cursor since you can move it to any tile regardless of if it is occupied. Either way it sounds like you are making progress, so thats great!