How are video game levels created?<\/h2>\n\n\n\n
There are several important parts of a video game, ranging from sound to the player character itself. Arguably the most important aspect is the level, which is essentially the world the player inhabits. Without levels, all the other components of a game won’t be put to any use and only serve as fun coding projects rather than a piece of a game. Levels come in all shapes, sizes, and formats with some games having multiple smaller levels and others taking place in one giant level. A level can serve a wide variety of purposes, such as teaching a new game mechanic or presenting an important plot point in your story.<\/p>\n\n\n\n
How do these levels get created? After designing the world your user will interact with, it becomes time to open up the level editor. Here you’ll edit the terrain of the world, place enemies, and scatter items. Of course, many game engines come with a level editor out of the box. So why would you want to make your own? One of the biggest reasons is to allow the user to create their own levels, allowing them to get creative with your game as well as have near endless amounts of content to enjoy in your game. Some games, such as Super Mario Maker, base their entire existence around this idea.<\/p>\n\n\n\n
As a developer, you may find that the level editor that comes with a game engine doesn’t quite give what you want, or perhaps it gives you too much. You might also be a part of a larger team, and your teammates could use a level editor that makes their jobs easier. It’s also possible that just you and a friend are working on this project, but you still need something to lighten the workload or at least make development easier. From the perspective of the developer, there can be any number of reasons to have a custom level editor for your project. After all, why not have better tools in the proverbial tool shed?<\/p>\n\n\n\n
How to build a level editor in Unity<\/h2>\n\n\n\n
Level editors are not easy to make. There are several pieces to a level editor and, as you can imagine, plenty of code to write. It will already take lots of time to put together; thus, the setup portion will be skipped in favour of jumping straight to the code. However, there’s no reason to leave you with nothing to start with. A link will be provided to download the project with all assets (other than the scripts) and with the primary Unity scene prepared ahead of time. Also, another link will take you to the complete project source.<\/p>\n\n\n\n
Normally these articles start the project from scratch, but in this case, you’ll use a pre-existing project. To open this project, first open Unity as usual and click Open <\/em>in the upper right. <\/em>After this, navigate to the folder containing the project. If the folder is associated with a Unity project, the Select Folder <\/em>button will appear. <\/em>Click this button, and the project will begin loading. Keep in mind that you may have to enter into another folder before finding the correct directory that Unity can open.<\/p>\n\n\n\n If downloading the project without the code, you’ll need to create five scripts inside the Unity Project. The names of these scripts are listed in the figure below:<\/p>\n\n\n\n Level Editor \u2013 no code:<\/p>\n\n\n\n Level Editor \u2013 complete:<\/p>\n\n\n\n First, here\u2019s a breakdown of what all these scripts do. EditorObject<\/em> and LevelEditor <\/em>will be handling the level data. The EditorObject <\/em>script will contain data for an individual object while the LevelEditor <\/em>will hold the data for the entire level. When saving a level, any object with EditorObject <\/em>attached will be noted in LevelEditor, <\/em>and its data will be saved to a json file. ManagerScript <\/em>will be the central hub of the editor, handling tasks like UI functions, level saving, and checking for certain objects. CameraMove <\/em>and MouseScript <\/em>are for user input, specifically placing or destroying objects and changing the camera view.<\/p>\n\n\n\n Starting with EditorObject<\/em>, this script will contain the data of the various objects the user places within the level. It is still a component though, and thus will need The code will look like Figure 2:<\/p>\n\n\n\n LevelEditor <\/em>has one job \u2013 to hold all the data gathered from objects with The two scripts responsible for handling level data are finished, which leaves the rest of the level editor to program. At the start, you have a variable with the Three of the four private variables are all created for input, as you’ll see later on. The last variable, So far, the script will look like what’s shown in figure 4.<\/p>\n\n\n\n The Assuming they aren’t, the camera will move according to the player’s input. This will be where These variables will change as the player presses the keys bound to You’ll notice that This concludes the Much like how CameraMove <\/em>controls what the user does with the camera, MouseScript <\/em>will dictate the functionality of the user’s mouse input. In particular, MouseScript <\/em>will allow the creation of objects, have an image of your current object to follow the mouse, and selecting which object to rotate.<\/p>\n\n\n\n To start, From the beginning, two enums are created called Anyone using your level editor will need a way to know what object they’re about to place. By manipulating this object’s Moving along to the You’ll also need a way to change the look of the mouse object based on whether you can place an item in your level or not. Unity’s Materials <\/em>will be utilized here to give a visual indication that an object can be placed. To accomplish this, a Should the The next step involves object manipulation. Unity will need to know what to do when the user clicks the mouse button. In addition, it will need to know what conditions are required to create, rotate, or destroy an object.<\/p>\n\n\n\n Once the user presses the left mouse button, a series of checks begin. Unity’s At this point, the The one editor object that changes things up during creation is the player object. In this case, the only other step that’s being added is a One last function remains before the completion of This completes MouseScript<\/em>, which means only one script remains for the level editor to have all the code needed. All those error messages wondering what those variables within ManagerScript <\/em>are about to be resolved.<\/p>\n\n\n\n As this is the script that will read and write your level data to and from a json file, you’ll need to start by adding Once again certain variables are made public but kept hidden in the Unity editor itself. Then several public variables are declared, all of which will be filled from the Unity Editor. In the end, a few booleans are declared that will let Unity know when certain menus are in view. The last variable, Here you may go ahead and either comment out or delete First, a listener will be made and applied to the event All of the preparations for ManagerScript <\/em>are finished now. From the Menus are the bread and butter of any level editor, so it only makes sense to get the code for menus ready early on. A good place to start is with the menus appearing on screen. You’ll want a way to open and close menus for the user to make the desired room on their screen. The following functions will first check if the menu is currently positioned within the user’s screen or not. Depending on the answer, it will \u2018slide\u2019 the menu into the screen or out of the screen by setting a trigger in the respective menu’s Animation <\/em>component.<\/p>\n\n\n\n Note also that these functions are made public. This is done in order to set the This extra line is simply setting Next up is the object selection functions. On the left side of the level editor is a menu with four buttons. Selecting any of these buttons sets the object to be placed as whichever object corresponds with that button. For example, clicking on the button with the cube in it sets the object to place as a cube object.<\/p>\n\n\n\n In each function, you begin by setting Why the distinction? Ordinarily, your object selection methods might look like That’s one major menu done, but there’s still the other part of what is being referred to as the \u2018options\u2019 menu. The save and load buttons are complete, but the remaining buttons currently do nothing. Once again, three separate functions will be used, each doing similar tasks with some slight differences.<\/p>\n\n\n\n With each function, you first set what manipulation option the player is using. From there you enable or disable the mouse object’s mesh renderer followed by activating or deactivating the rotation slider. This concludes the main menu functionality of the level editor, leaving only the save and load methods. Now the fun begins as you write code to save your level data to a json file stored within a folder that you request Unity to make. To start, you’ll need to gather up all objects with the Next, comes the directory and file creation. Unity has built-in json functionality that makes reading and writing a json file considerably easier on you as the developer. This function, called A quick check is performed to make sure a file of the same name already exists. If it does, then it is deleted and simply replaced with the new file. You use Saving your data is now possible in your level editor. The complete function is shown in the figure below if you wish to check your code.<\/p>\n\n\n\n Naturally, someone may wish to make adjustments to their created level later on. A similar menu to the save menu is created for that purpose. The actual functionality of loading a level is effectively doing From here you first check to see if the file exists. If not, you’ll display a message stating that the file could not be found. Otherwise, you’ll once again gather all the current objects with ![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image.jpeg\")
Figure 1: List of scripts<\/p>\n\n\n\nThe Code<\/h2>\n\n\n\n
The EditorObject<\/h3>\n\n\n\n
using UnityEngine<\/code> to inherit from MonoBehaviour<\/code> so it can be attached to objects. As a result, you won’t be able to serialize the class entirely. Instead, you can create a public struct within the class called Data<\/code> and serialize that (make sure you have using System<\/code> at the top). Before creating the struct, remove the Start<\/code> and Update<\/code> functions, then make an enum called ObjectType<\/code> and list Cylinder<\/code>, <\/em>Cube<\/code>, <\/em>Sphere<\/code>, <\/em>and Player<\/code> within the enum. Inside the struct are three public variables: a Vector3 named pos<\/code>, Quaternion called rot<\/code>, and an ObjectType<\/code> specified as objectType<\/code>. The first two variables will store the position and rotation of an object, while objectType<\/code> will hold what kind of object this is attached to whether it be a cube or the player. Finally, a new public Data <\/em>object is declared that you simply call data<\/code>.<\/p>\n\n\n\nusing System;\nusing UnityEngine;\npublic class EditorObject : MonoBehaviour\n{\n public enum ObjectType { Cylinder, Cube, Sphere, Player};\n [Serializable]\n public struct Data\n {\n public Vector3 pos;\n public Quaternion rot;\n public ObjectType objectType;\n }\n public Data data;\n}<\/pre>\n\n\n\n![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-1.jpeg\")
Figure 2: EditorObject <\/em>complete script<\/p>\n\n\n\nThe LevelEditor<\/h3>\n\n\n\n
EditorObject<\/code> attached. This script will not be attached to any object and therefore does not need to inherit from MonoBehaviour<\/code>. This also means the only two using statements you’ll need are System.Collections.Generic<\/code> and System. <\/code>Serialize the class, then define a public list with the type of EditorObject.Data<\/code>. Name this list editorObjects<\/code>, <\/em>and the LevelEditor<\/code> script will be finished.<\/p>\n\n\n\nusing System.Collections.Generic;\nusing System;\n[Serializable]\npublic class LevelEditor \n{\n public List<EditorObject.Data> editorObjects;\n}<\/pre>\n\n\n\n![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-2.jpeg\")
Figure 3: LevelEditor <\/em>complete script<\/p>\n\n\n\nCameraMove<\/h3>\n\n\n\n
CameraMove<\/code> is a good place to begin as it has the least happening within it. You’ll need to have using UnityEngine<\/code> and using UnityEngine.UI<\/code> at the top to do everything required in this script. Next comes the variable declaration inside the class as follows:<\/p>\n\n\n\npublic Slider cameraSpeedSlide;\npublic ManagerScript ms;\nprivate float xAxis;\nprivate float yAxis;\nprivate float zoom;\nprivate Camera cam;<\/pre>\n\n\n\n
Slider<\/code> type called cameraSpeedSlide<\/code>. When looking at the editor, you should notice a UI object with the text \u2018Camera Speed\u2019 above it. This is the slider that CameraMove <\/em>will be using. Most level editors have functionality that allows the user to adjust the speed of the camera, and this level editor will be no exception. By moving the slider, you can adjust how fast or slow the camera moves when pressing the movement keys or zooming the camera in and out. Next comes ms<\/code>, which simply contains a reference to ManagerScript<\/code>. This is only needed to check if certain menus are open and the ManagerScript<\/code> is the one that will know this information.<\/p>\n\n\n\ncam<\/code>, <\/em>will store the object’s Camera<\/code> component and manipulate certain values from there. Speaking of cam<\/code>, <\/em>that brings you to the next step in the code. In the Start<\/code> function, you’ll want to have cam<\/code> get the aforementioned Camera<\/code> component.<\/p>\n\n\n\ncam = GetComponent<Camera>();<\/pre>\n\n\n\n
![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-3.jpeg\")
Figure 4: Variables and Start <\/em>function for CameraMove.<\/em><\/p>\n\n\n\nUpdate<\/code> function is all that remains for this script to be completed. First, it will check with the ManagerScript<\/code> if a save or load menu has been opened.<\/p>\n\n\n\nif (ms.saveLoadMenuOpen == false)\n{\n}<\/pre>\n\n\n\nxAxis<\/code>, <\/em>yAxis<\/code>, <\/em>and zoom<\/code> come in.<\/p>\n\n\n\nxAxis = Input.GetAxis(\"Horizontal\");\nyAxis = Input.GetAxis(\"Vertical\");\nzoom = Input.GetAxis(\"Mouse ScrollWheel\") * 10;<\/pre>\n\n\n\n
Horizontal<\/code>, <\/em>Vertical<\/code>, <\/em>and Mouse ScrollWheel<\/code>. In this case that would mean whenever the player presses any of the arrow keys or, you guessed it, scrolls the mouse wheel.<\/p>\n\n\n\ntransform.Translate(new Vector3(xAxis * \n -cameraSpeedSlide.value, yAxis * -cameraSpeedSlide.value, 0.0f));\ntransform.position = new Vector3(\n\tMathf.Clamp(transform.position.x, -20, 20),\n\tMathf.Clamp(transform.position.y, 20, 20),\n\tMathf.Clamp(transform.position.z, -20, 20));\nif (zoom < 0 && cam.orthographicSize >= -25)\n\tcam.orthographicSize -= zoom * -cameraSpeedSlide.value;\nif (zoom > 0 && cam.orthographicSize <= -5)\n\tcam.orthographicSize += zoom * cameraSpeedSlide.value;<\/pre>\n\n\n\n
cameraSpeedSlide<\/code> is starting to see some use here. By pressing any of the movement keys, the camera will move based on which key is pressed multiplied by the value in the slider. The same thing is done when zooming the camera in or out later on. In addition, Clamp<\/code> is being used to limit how far the camera can go. This is done to prevent said camera moving away from the area where the level editing happens. Similarly, the camera will only be zoomed in or out based on cam's<\/code> orthographicSize<\/code> variable.<\/p>\n\n\n\n![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-4.jpeg\")
Figure 5: Update <\/em>function in CameraMove<\/em>.<\/p>\n\n\n\nCameraMove<\/code> script, but you’ll notice that the first if<\/code> statement has an error. Of course, without doing anything with ManagerScript<\/code> Visual Studio would naturally not know what the saveLoadMenuOpen<\/code> boolean is. You can ignore this for the time being. For now, it’s time to focus attention on the MouseScript<\/em>.<\/p>\n\n\n\nMouseScript<\/h3>\n\n\n\n
using UnityEngine.EventSystems<\/code> will need to be declared at the top. This script will be checking if the mouse is currently over any UI elements and will use EventSystem<\/code> to do this. Checking this is important as you wouldn’t want users to accidentally place an object when they were trying to select a menu item instead. Once added, the next step is to declare variables inside the class.<\/p>\n\n\n\npublic enum LevelManipulation { Create, Rotate, Destroy };\npublic enum ItemList { Cylinder, Cube, Sphere, Player };\n[HideInInspector]\npublic ItemList itemOption = ItemList.Cylinder;\n[HideInInspector]\npublic LevelManipulation manipulateOption = LevelManipulation.Create;\n[HideInInspector]\npublic MeshRenderer mr;\n[HideInInspector]\npublic GameObject rotObject;\npublic Material goodPlace;\npublic Material badPlace;\npublic GameObject Player;\npublic ManagerScript ms;\nprivate Vector3 mousePos;\nprivate bool colliding;\nprivate Ray ray;\nprivate RaycastHit hit;<\/pre>\n\n\n\nLevelManipulation<\/code> and ItemList<\/code>. Within these two enums are the list of ways to manipulate objects and the possible objects to create respectively. A handful of variables are then declared that are public but have HideInInspector<\/code> above them. These variables will be used by another script, but they don’t need to be seen in the Unity editor. Variable declaration continues as normal from there with some public variables that will be given values in the editor and private variables that pertain to this script only. Finally, in the Start<\/code> function, you add the following:<\/p>\n\n\n\nmr = GetComponent<MeshRenderer>();<\/pre>\n\n\n\n
MeshRenderer<\/code>, <\/em>you can change the current mesh that is following your mouse, thus letting you know which object is currently set to be placed.<\/p>\n\n\n\n![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-5.jpeg\")
Figure 6: MouseScript <\/em>variables and Start <\/em>function.<\/p>\n\n\n\nUpdate<\/code> function, the first thing to do is allow this object to follow the mouse cursor. First, the current mouse coordinates will be set to mousePos<\/code> followed by converting those screen coordinates to a position in the game world. Like with CameraMove<\/code>, <\/em>Clamp<\/code> will also be used to limit where this object can go.<\/p>\n\n\n\nmousePos = Input.mousePosition;\nmousePos = Camera.main.ScreenToWorldPoint(mousePos);\ntransform.position = new Vector3(\n\tMathf.Clamp(mousePos.x, -20, 20),\n\t0.75f,\n\tMathf.Clamp(mousePos.z, -20, 20));<\/pre>\n\n\n\n
raycast<\/code> will be sent out checking for collision with any objects on the ninth layer. Why the ninth layer specifically? It’s because when creating objects in a level editor you want to distinguish the player created objects from any objects that might already be present in the current level such as the floor or walls. This is being done by creating a new layer in Unity called SpawnedObjects<\/code> and assigning player created objects to this layer. Much like how you’d look for something in an array, you specify which layer you wish to check by index.<\/p>\n\n\n\nray = Camera.main.ScreenPointToRay(Input.mousePosition);\nif (Physics.Raycast(ray, out hit))\n{\n\tif (hit.collider.gameObject.layer == 9)\n\t{\n\t\tcolliding = true;\n\t\tmr.material = badPlace;\n\t}\n\telse\n\t{\n\t\tcolliding = false;\n\t\tmr.material = goodPlace;\n\t}\n}<\/pre>\n\n\n\nraycast<\/code> detect an object in this layer, the material of the mouse object will be set to the material called badPlace<\/code>. In other words, the colour of the object will change to red. Once the mouse leaves the colliding object, it will set the material to goodPlace<\/code>, back to green, to let the user know that they can create an item in that space.<\/p>\n\n\n\n![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-6.jpeg\")
Figure 7: Beginning of MouseScript’s Update <\/em>function.<\/em><\/p>\n\n\n\nif (Input.GetMouseButtonDown(0))\n{\n\tif (!EventSystem.current.IsPointerOverGameObject())\n\t{\n\t\tif (colliding == false && manipulateOption == \n LevelManipulation.Create)\n\t\t\tCreateObject();\n\t\telse if (colliding == true && manipulateOption == \n LevelManipulation.Rotate)\n\t\t\tSetRotateObject();\n\t\telse if (colliding == true && manipulateOption == \n LevelManipulation.Destroy)\n\t\t{\n\t\t if (hit.collider.gameObject.name.Contains(\n \"PlayerModel\"))\n\t\t\t\tms.playerPlaced = false;\n\t\t\tDestroy(hit.collider.gameObject);\n\t\t}\n\t}\n}<\/pre>\n\n\n\nEventSystem<\/code> comes in to play first by confirming that the mouse cursor is not over any UI elements. Assuming this is true then you first check if the there is any collision. If there isn’t, be sure also to check that the user is looking to create an object. Should there be a collision, you will want to be sure the player isn’t selecting an object to rotate or destroy. When it comes to destroying an object, you’ll want to see if the user is destroying an object that has \u2018PlayerModel\u2019 in its name. The rules of this level editor dictate that the user cannot place more than one player object. If that player object is destroyed, Unity will need to know that the user is permitted to place a player object the next time they desire to.<\/p>\n\n\n\nStart<\/code> and Update<\/code> functions are finished, and all that remains are the user defined functions, namely CreateObject<\/code> and RotateObject<\/code>. The average user will spend more time placing objects than changing their rotation, so CreateObject<\/code> would be a good place to begin. As the name implies, it will create an object at the mouse cursor’s location. Which object it places is dependent on which item is currently selected from ItemList<\/code>. This is also where the EditorObject<\/code> script will start to see some use. Once an object is placed, EditorObject<\/code> will be attached to the newly created object as a script component and assigned some data.<\/p>\n\n\n\nvoid CreateObject()\n{\n\tGameObject newObj;\n\tif (itemOption == ItemList.Cylinder)\n\t{\n\t newObj = GameObject.CreatePrimitive(PrimitiveType.Cylinder);\n\t newObj.transform.position = transform.position;\n\t newObj.layer = 9;\n\t EditorObject eo = newObj.AddComponent<EditorObject>();\n\t eo.data.pos = newObj.transform.position;\n\t eo.data.rot = newObj.transform.rotation;\n\t eo.data.objectType = EditorObject.ObjectType.Cylinder;\n\t}\n\telse if (itemOption == ItemList.Cube)\n\t{\n\t newObj = GameObject.CreatePrimitive(PrimitiveType.Cube);\n\t newObj.transform.position = transform.position;\n\t newObj.layer = 9;\n\t EditorObject eo = newObj.AddComponent<EditorObject>();\n\t eo.data.pos = newObj.transform.position;\n\t eo.data.rot = newObj.transform.rotation;\n\t eo.data.objectType = EditorObject.ObjectType.Cube;\n\t}\n\telse if (itemOption == ItemList.Sphere)\n\t{\n\t newObj = GameObject.CreatePrimitive(PrimitiveType.Sphere);\n\t newObj.transform.position = transform.position;\n\t newObj.layer = 9;\n\t EditorObject eo = newObj.AddComponent<EditorObject>();\n\t eo.data.pos = newObj.transform.position;\n\t eo.data.rot = newObj.transform.rotation;\n\t eo.data.objectType = EditorObject.ObjectType.Sphere;\n\t}\n\telse if (itemOption == ItemList.Player)\n\t{\n\t if (ms.playerPlaced == false)\n\t {\n\t newObj = Instantiate(Player, \n transform.position, Quaternion.identity);\n\t newObj.layer = 9;\n\t newObj.AddComponent<CapsuleCollider>();\n\t newObj.GetComponent<CapsuleCollider>().center = \n new Vector3(0, 1, 0);\n\t newObj.GetComponent<CapsuleCollider>().height = 2;\n\t ms.playerPlaced = true;\n\t EditorObject eo = newObj.AddComponent<EditorObject>();\n\t eo.data.pos = newObj.transform.position;\n\t eo.data.rot = newObj.transform.rotation;\n\t eo.data.objectType = EditorObject.ObjectType.Player;\n\t }\n\t}\n}<\/pre>\n\n\n\nCapsuleCollider<\/code> component will be attached along with an EditorObject<\/code> component. In addition, since a prefab is being created for the player Instantiate<\/code> is used as opposed to CreatePrimitive<\/code>. It also makes sure to check if a player object has already been placed. Assuming it hasn’t, the object is created normally.<\/p>\n\n\n\nMouseScript<\/code>, <\/em>and it’s a short one. This function will set the object that is selected to be rotated. It uses information gathered from a raycast<\/code> to set rotObject<\/code> to the current object the mouse is over.<\/p>\n\n\n\nvoid SetRotateObject()\n{\n\trotObject = hit.collider.gameObject;\n\tms.rotSlider.value = rotObject.transform.rotation.y;\n}\n<\/pre>\n\n\n\nThe ManagerScript<\/h3>\n\n\n\n
using System.IO<\/code>. You’ll also want using UnityEngine.UI<\/code> in there as well since various UI elements will be needed here. Then you will need to declare several variables:<\/p>\n\n\n\n[HideInInspector]\npublic bool playerPlaced = false;\n[HideInInspector]\npublic bool saveLoadMenuOpen = false;\npublic Animator itemUIAnimation;\npublic Animator optionUIAnimation;\npublic Animator saveUIAnimation;\npublic Animator loadUIAnimation;\npublic MeshFilter mouseObject;\npublic MouseScript user;\npublic Mesh playerMarker;\npublic Slider rotSlider;\npublic GameObject rotUI;\npublic InputField levelNameSave;\npublic InputField levelNameLoad;\npublic Text levelMessage;\npublic Animator messageAnim;\nprivate bool itemPositionIn = true;\nprivate bool optionPositionIn = true;\nprivate bool saveLoadPositionIn = false;\nprivate LevelEditor level;<\/pre>\n\n\n\n
level<\/code>, is essentially our level data. When it comes time to save the level, this will be used to gather a list of player created objects and serialize their information into a json file.<\/p>\n\n\n\nUpdate<\/code> as it will not be used in this script. After this, go ahead and enter the following code for Start<\/code>:<\/p>\n\n\n\nrotSlider.onValueChanged.AddListener(delegate { \n RotationValueChange(); });\nCreateEditor();<\/pre>\n\n\n\nonValueChanged<\/code> from rotSlider<\/code>. This means that whenever the value of rotSlider<\/code> has changed, the function RotationValueChange<\/code> will be called, rotating the object selected. After this CreateEditor<\/code> is called which creates a new LevelEditor<\/code> and declares a new list of EditorObject.Data<\/code> before returning level<\/code>.<\/p>\n\n\n\nLevelEditor CreateEditor()\n{\n\tlevel = new LevelEditor();\n\tlevel.editorObjects = new List<EditorObject.Data>();\n\treturn level;\n}\nvoid RotationValueChange()\n{\n\tuser.rotObject.transform.localEulerAngles = \n new Vector3(0, rotSlider.value, 0);\n\tuser.rotObject.GetComponent<EditorObject>().data.rot = \n user.rotObject.transform.rotation;\n}<\/pre>\n\n\n\nStart<\/code> function down, the script should look similar to figure 8.<\/p>\n\n\n\n![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-7.jpeg\")
Figure 8: Start, CreateEditor, and RotationValueChanged methods.<\/p>\n\n\n\npublic void SlideItemMenu()\n{\n\tif (itemPositionIn == false)\n\t{\n\t\titemUIAnimation.SetTrigger(\"ItemMenuIn\");\n\t\titemPositionIn = true;\n\t}\n\telse\n\t{\n\t\titemUIAnimation.SetTrigger(\"ItemMenuOut\");\n\t\titemPositionIn = false;\n\t}\n}\npublic void SlideOptionMenu()\n{\n\tif (optionPositionIn == false)\n\t{\n\t\toptionUIAnimation.SetTrigger(\"OptionMenuIn\");\n\t\toptionPositionIn = true;\n\t}\n\telse\n\t{\n\t\toptionUIAnimation.SetTrigger(\"OptionMenuOut\");\n\t\toptionPositionIn = false;\n\t}\n}<\/pre>\n\n\n\nOnClicked<\/code> event to the function from within the Unity Editor. Next comes the save and load menus which operate very similarly to the previous menu functions but with an extra command.<\/p>\n\n\n\npublic void ChooseSave()\n{\n\tif (saveLoadPositionIn == false)\n\t{\n\t\tsaveUIAnimation.SetTrigger(\"SaveLoadIn\");\n\t\tsaveLoadPositionIn = true;\n\t\tsaveLoadMenuOpen = true;\n\t}\n\telse\n\t{\n\t\tsaveUIAnimation.SetTrigger(\"SaveLoadOut\");\n\t\tsaveLoadPositionIn = false;\n\t\tsaveLoadMenuOpen = false;\n\t}\n}\npublic void ChooseLoad()\n{\n\tif (saveLoadPositionIn == false)\n\t{\n\t\tloadUIAnimation.SetTrigger(\"SaveLoadIn\");\n\t\tsaveLoadPositionIn = true;\n\t\tsaveLoadMenuOpen = true;\n\t}\n\telse\n\t{\n\t\tloadUIAnimation.SetTrigger(\"SaveLoadOut\");\n\t\tsaveLoadPositionIn = false;\n\t\tsaveLoadMenuOpen = false;\n\t}\n}<\/pre>\n\n\n\nsaveLoadMenuOpen<\/code> to true or false, depending on the circumstances. Recall from the CameraMove<\/code> script the boolean that checks if the save or load menu is open. In that script, the check is performed to avoid camera movement while the menu is open.<\/p>\n\n\n\n![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-8.jpeg\")
Figure 9: SlideOptionMenu <\/em>and ChooseSave<\/em>, two of the four menu functions.<\/p>\n\n\n\npublic void ChooseCylinder()\n{\n\tuser.itemOption = MouseScript.ItemList.Cylinder;\n\tGameObject cylinder = \n GameObject.CreatePrimitive(PrimitiveType.Cylinder);\n\tmouseObject.mesh = \n cylinder.GetComponent<MeshFilter>().mesh;\n\tDestroy(cylinder);\n}\n \npublic void ChooseCube()\n{\n\tuser.itemOption = MouseScript.ItemList.Cube;\n\tGameObject cube = \n GameObject.CreatePrimitive(PrimitiveType.Cube);\n\tmouseObject.mesh = cube.GetComponent<MeshFilter>().mesh;\n\tDestroy(cube);\n}\npublic void ChooseSphere()\n{\n\tuser.itemOption = MouseScript.ItemList.Sphere;\n\tGameObject sphere = \n GameObject.CreatePrimitive(PrimitiveType.Sphere);\n\tmouseObject.mesh = sphere.GetComponent<MeshFilter>().mesh;\n\tDestroy(sphere);\n}\npublic void ChoosePlayerStart()\n{\n\tuser.itemOption = MouseScript.ItemList.Player;\n\tmouseObject.mesh = playerMarker;\n}<\/pre>\n\n\n\nuser.itemOption<\/code> (the itemOption<\/code> variable in MouseScript<\/em>) to the corresponding object. From there, you change the mesh of the mouse object by quickly creating an object in the world and setting mouseObject.mesh<\/code> to the mesh of the created object. Once this is done, the newly created object is immediately destroyed. ChoosePlayerStart<\/code> mixes things up by instead taking the mesh from playerMarker<\/code>, a variable created early on that stores the player mesh.<\/p>\n\n\n\nChoosePlayerStart<\/code>, <\/em>but in this example, the user created objects are all basic geometric shapes like cubes. To save on variable declarations, the script instead uses CreatePrimitive<\/code> to make the mesh needed for the mouse. You can, of course, make variables holding these different meshes if you so desire. From there you can make all methods functionally identical or perhaps use a different method altogether. CreatePrimitive<\/code> was used to keep the code simple and easier to follow.<\/p>\n\n\n\n![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-9.jpeg\")
Figure 10: All object selection functions.<\/p>\n\n\n\npublic void ChooseCreate()\n{\n\tuser.manipulateOption = MouseScript.LevelManipulation.Create;\n\tuser.mr.enabled = true;\n\trotUI.SetActive(false); \n}\npublic void ChooseRotate()\n{\n\tuser.manipulateOption = MouseScript.LevelManipulation.Rotate;\n\tuser.mr.enabled = false;\n\trotUI.SetActive(true);\n}\npublic void ChooseDestroy()\n{\n\tuser.manipulateOption = MouseScript.LevelManipulation.Destroy;\n\tuser.mr.enabled = false;\n\trotUI.SetActive(false);\n}<\/pre>\n\n\n\nEditorObject<\/code> component, which of course signifies objects that were user-generated. Once you have your array of objects, you’ll need to add the data from these objects to the list created in level<\/code>.<\/p>\n\n\n\npublic void SaveLevel()\n{\n\tEditorObject[] foundObjects = FindObjectsOfType<EditorObject>();\n\tforeach (EditorObject obj in foundObjects)\n\t\tlevel.editorObjects.Add(obj.data); \n}<\/pre>\n\n\n\nJsonUtility.ToJson<\/code>, will be used to create the json file. Next, a folder is specified by getting the data path of the project, followed by adding the directory LevelData<\/code>. A default filename is created followed by checking to see if the user entered anything in the level name field in the editor. Assuming they have, the json file is given that name. The existence of the LevelData<\/code> directory is confirmed, and finally, the file path is set by using Path.Combine<\/code> which completes all the prep work before saving the file.<\/p>\n\n\n\nstring json = JsonUtility.ToJson(level);\nstring folder = Application.dataPath + \"\/LevelData\/\";\nstring levelFile = \"\";\nif (levelNameSave.text == \"\")\n\tlevelFile = \"new_level.json\";\nelse\n\tlevelFile = levelNameSave.text + \".json\";\nif (!Directory.Exists(folder))\n\tDirectory.CreateDirectory(folder);\nstring path = Path.Combine(folder, levelFile);<\/pre>\n\n\n\n
File.WriteAllText<\/code> to save the file to the path specified, and the level file is created. Remove the save menu from there, clear out the input field and remove the focus from it, and send a message to the user letting them know their level was saved successfully.<\/p>\n\n\n\nif (File.Exists(path))\n\tFile.Delete(path);\nFile.WriteAllText(path, json); \nsaveUIAnimation.SetTrigger(\"SaveLoadOut\");\nsaveLoadPositionIn = false;\nsaveLoadMenuOpen = false;\nlevelNameSave.text = \"\";\nlevelNameSave.DeactivateInputField();\nlevelMessage.text = levelFile + \" saved to LevelData folder.\";\nmessageAnim.Play(\"MessageFade\", 0, 0);<\/pre>\n\n\n\n
![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2019\/06\/word-image-10.jpeg\")
Figure 11: The complete SaveLevel <\/em>function.<\/p>\n\n\n\nSaveLevel<\/code> in reverse. You’ll still begin by specifying the file path to be used when searching for a level to load.<\/p>\n\n\n\npublic void LoadLevel()\n{\n\tstring folder = Application.dataPath + \"\/LevelData\/\";\n\tstring levelFile = \"\";\n\tif (levelNameLoad.text == \"\")\n\t\tlevelFile = \"new_level.json\";\n\telse\n\t\tlevelFile = levelNameLoad.text + \".json\";\n\t\n\tstring path = Path.Combine(folder, levelFile);\n}<\/pre>\n\n\n\n