Showing posts with label Tutorial. Show all posts
Showing posts with label Tutorial. Show all posts

Thursday, March 29, 2012

Let me debug in your GUI


Here's a script I made to be able to see debug stuff while testing a game outside of the editor i.e. webplayer. It adds a button on the top right corner to turn on/off the debug window.

Should be pretty easy to use, just put it on some gameobject, and alter the "maxlines" value to fit your need.

using UnityEngine;
using System.Collections;

public class MyLog : MonoBehaviour
{
    static string myLog;
    static Queue myLogQueue = new Queue();
    public string output = "";
    public string stack = "";
    private bool hidden = true;
    private Vector2 scrollPos;
    public int maxLines = 30;

    void OnEnable()
    {
        Application.RegisterLogCallback(HandleLog);
    }

    void OnDisable()
    {
        Application.RegisterLogCallback(null);
    }

    void HandleLog(string logString, string stackTrace, LogType type)
    {
        output = logString;
        stack = stackTrace;
        string newString = "\n [" + type + "] : " + output;
        myLogQueue.Enqueue(newString);
        if (type == LogType.Exception)
        {
            newString = "\n" + stackTrace;
            myLogQueue.Enqueue(newString);
        }

        while (myLogQueue.Count > maxLines)
        {
            myLogQueue.Dequeue();
        }

        myLog = string.Empty;
        foreach (string s in myLogQueue)
        {
            myLog += s;
        }
    }

    void OnGUI()
    {
        if (!hidden)
        {
            GUI.TextArea(new Rect(0, 0, Screen.width / 3, Screen.height), myLog);
            if (GUI.Button(new Rect(Screen.width - 100, 10, 80, 20), "Hide"))
            {
                hide(true);
            }
        }
        else
        {
            if (GUI.Button(new Rect(Screen.width - 100, 10, 80, 20), "Show"))
            {
                hide(false);
            }
        }
    }

    public void hide(bool shouldHide)
    {
        hidden = shouldHide;
    }
}

Hope you like it. If you make any improvements, please share.

Wednesday, February 15, 2012

Automatically locate all unused unity assets

Did you ever work on a unity project where either you or a co-worker did not uphold complete and total order with regards to cleaning up the project folder. If you're one of those rare specimens that has never experienced a touch of kaos, don't read on!

On the other hand if you, as I, from time to time postpones the cleanup to another day, I've made a handy little editorwindow that should make the cleanup process a lot less tedious.

Basically it reads from the editor log after you have build a project, and then compares the included assets with all assets in your project. If an asset exist that is not used in the final build it is listed. It is also clickable so you can easily find it.

The unused assets are organized in 3 folders. "editor", "plugins" and "some other folder". This is helpful for me, as there is a lot in the "editor" folder that I use, but that is not used in final build.

It also lists which .dll's are included in build. If you need it, fine. If not, just delete that part.

DISCLAIMER: It does not locate unused assets in the "Ressources" folder, since everything in there should by default be included in the build. It's a tool to help locate the unused, but should be used with a bit of common sense.

[***UPDATE 2014***] By popular demand a GREATLY improved version of this tool has been released on the Unity Asset Store for 10 bucks. This old version is not stable as of Unity 4.6b20 and will not be updated

Place the following in the "editor" folder:
 using UnityEngine;  
 using UnityEditor;  
 using System.Collections;  
 using System.Collections.Generic;  
   
 public class CleanUpWindow : EditorWindow  
 {  
   bool groupEnabled = false;  
   List<string> usedAssets = new List<string>();  
   List<string> includedDependencies = new List<string>();  
   private Vector2 scrollPos;  
   private List<Object> unUsed;  
   private Dictionary<string, List<Object>> unUsedArranged;  
   private bool needToBuild = false;  

// Add menu named "CleanUpWindow" to the Window menu  
   [MenuItem("Window/CleanUpWindow")]  
   static void Init()  
   {  
     // Get existing open window or if none, make a new one:  
     CleanUpWindow window = (CleanUpWindow)EditorWindow.GetWindow(typeof(CleanUpWindow));
window.Show();  
   }  
   
   void OnGUI()  
   {  
     if (needToBuild)  
     {  
       GUI.color = Color.red;  
       GUILayout.Label("Are you sure you remembered to build project? Because you really need to...", EditorStyles.boldLabel);  
     }  
     GUI.color = Color.white;  
   
     if (GUILayout.Button("Load EditorLog"))  
     {  
       loadEditorLog();  
     }  
   
       
     if(!needToBuild)  
     {  
       EditorGUILayout.BeginHorizontal();  
       EditorGUILayout.BeginVertical();  
       if (groupEnabled)  
       {  
         GUILayout.Label("DEPENDENCIES");  
         for (int i = 0; i < includedDependencies.Count; i++)  
         {  
           EditorGUILayout.LabelField(i.ToString(), includedDependencies[i]);  
         }  
       }  
       EditorGUILayout.EndVertical();  
       scrollPos = EditorGUILayout.BeginScrollView(scrollPos);  
       EditorGUILayout.BeginVertical();  
   
       if (groupEnabled)  
       {  
         if (unUsedArranged != null)  
         {  
           foreach (KeyValuePair<string, List<Object>> objList in unUsedArranged)  
           {  
             if (objList.Value.Count >= 1)  
             {  
               GUILayout.Label(objList.Key.ToUpper());  
               for (int i = 0; i < objList.Value.Count; i++)  
               {  
                 EditorGUILayout.ObjectField(objList.Value[i], typeof(Object), false);  
               }  
             }  
           }  
         }  
       }  
       EditorGUILayout.EndVertical();  
       EditorGUILayout.EndScrollView();  
       EditorGUILayout.EndHorizontal();  
     }  
       
   }  
   
   private void loadEditorLog()  
   {  
     UsedAssets.GetLists(ref usedAssets, ref includedDependencies);  
   
     if (usedAssets.Count == 0)  
     {  
       needToBuild = true;  
     }  
     else  
     {  
       compareAssetList(UsedAssets.GetAllAssets());  
       groupEnabled = true;  
       needToBuild = false;  
     }  
   }  
   
   private void compareAssetList(string[] assetList)  
   {  
       
     unUsed = new List<Object>();  
   
     unUsedArranged = new Dictionary<string, List<Object>>();  
     unUsedArranged.Add("plugins", new List<Object>());  
     unUsedArranged.Add("editor", new List<Object>());  
     unUsedArranged.Add("some other folder", new List<Object>());  
   
     for (int i = 0; i < assetList.Length; i++)  
     {   
       if(!usedAssets.Contains(assetList[i]))  
       {  
           
         Object objToFind = AssetDatabase.LoadAssetAtPath(assetList[i], typeof(Object));  
         unUsed.Add(objToFind);  
         if (objToFind != null)
         {
             unUsedArranged[getArrangedPos(objToFind)].Add(objToFind);  
         }
       }  
     }  
   }  
   
   private string getArrangedPos(Object value)  
   {  
     string path = AssetDatabase.GetAssetPath(value).ToLower();  
   
     if (path.Contains("/plugins/"))  
     {  
       return "plugins";  
     }  
     else if (path.Contains("/editor/"))  
     {  
       return "editor";  
     }  
     else  
     {  
       return "some other folder";  
     }  
   }  
 }  
You,ll need this too:
using UnityEngine;
using UnityEditor;
using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;

public class UsedAssets
{
    public static string[] GetAllAssets()
    {
        string[] tmpAssets1 = Directory.GetFiles(Application.dataPath, "*.*", SearchOption.AllDirectories);
        string[] tmpAssets2 = Array.FindAll(tmpAssets1, name => !name.EndsWith(".meta"));
        string[] allAssets;

        allAssets = Array.FindAll(tmpAssets2, name => !name.EndsWith(".unity"));

        for (int i = 0; i < allAssets.Length; i++)
        {
            allAssets[i] = allAssets[i].Substring(allAssets[i].IndexOf("/Assets") + 1);
            allAssets[i] = allAssets[i].Replace(@"\", "/");
        }

        return allAssets;
    }

    public static void GetLists(ref List<string> assetResult, ref List<string> dependencyResult)
    {
        assetResult.Clear();
        dependencyResult.Clear();

        string LocalAppData = string.Empty;
        string UnityEditorLogfile = string.Empty;

        if (Application.platform == RuntimePlatform.WindowsEditor)
        {
            LocalAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
            UnityEditorLogfile = LocalAppData + "\\Unity\\Editor\\Editor.log";
        }
        else if (Application.platform == RuntimePlatform.OSXEditor)
        {
            LocalAppData = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
            UnityEditorLogfile = LocalAppData + "/Library/Logs/Unity/Editor.log";
        }
        
        try
        {
            // Have to use FileStream to get around sharing violations!
            FileStream FS = new FileStream(UnityEditorLogfile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            StreamReader SR = new StreamReader(FS);

            
            string line;
            while (!SR.EndOfStream && !(line = SR.ReadLine()).Contains("Mono dependencies included in the build"));
            while (!SR.EndOfStream && (line = SR.ReadLine()) != "")
            {
                dependencyResult.Add(line);
            }
            while (!SR.EndOfStream && !(line = SR.ReadLine()).Contains("Used Assets,"));
            while (!SR.EndOfStream && (line = SR.ReadLine()) != "")
            {
               
                line = line.Substring(line.IndexOf("% ") + 2);
                assetResult.Add(line);
            }
        }
        catch (Exception E)
        {
            Debug.LogError("Error: " + E);
        }
    }
}
Note that script files might not be shown as unused since the unity build includes then.
Here's an example: Unity Package

Saturday, February 4, 2012

Batch replace gameobjects in Unity

When creating Harry the Fairy, we often found ourselves having to replace hundreds of prefab instances so I created this little script. It replaces a number of gameobjects with another and gives you the possibility to save all the transform values i.e. position, rotation and scale.

C# Script must be placed in "editor" folder.
using UnityEngine;
using UnityEditor;
using System.Collections;

public class ReplaceGameObjects : ScriptableWizard
{
    public bool copyValues = true;
    public GameObject NewType;
    public GameObject[] OldObjects;

    [MenuItem("Custom/Replace GameObjects")]


    static void CreateWizard()
    {
        ScriptableWizard.DisplayWizard("Replace GameObjects", typeof(ReplaceGameObjects), "Replace");
    }

    void OnWizardCreate()
    {
        foreach (GameObject go in OldObjects)
        {
            GameObject newObject;
            newObject = (GameObject)EditorUtility.InstantiatePrefab(NewType);
            newObject.transform.position = go.transform.position;
            newObject.transform.rotation = go.transform.rotation;
            newObject.transform.parent = go.transform.parent;

            DestroyImmediate(go);

        }

    }
}

Here's a visual walkthrough:

Go into Custom ->Replace Gameobjects


Select any number of gameobjects and drag them into "Old Objects".
Then, from the project pane, drag the gameobject that you want to replace with into "New Type".


Press "Replace"


Enjoy :)

/Kristian
And credits to Michael L. Croswell

Monday, January 23, 2012

Reducing build size in Unity games

Creating games with Unity, having a large number of custom levels, while trying to get under that App Store and Android Market limit of 20mb? This is a problem we've faced a few times, and finally i've gotten around to look into creating a method to minimize the size of the final build by serializing the scenes and just instantiating prefabs at level load. We are currently working on a game which will more than likely have 100+ levels, and this method will help us cut down drastically on the final build size. The game has a one-button type gameplay and currently has the very ingenious working title “Rollers”.

The current version limits itself to instantiating prefabs that does not differ from the blueprint, although it should be a rather simple fix to do that, I just don't need it myself :)

You need to use JSONFX to complete this tutorial

In this example I have a number of worlds, each with a number of levels.


Each of these levels contains a number of walls (All instances of a wall prefab with the tag “Wall”)



Additionally the level has a gameobject called info with the following monobehaviour attached: Basically the only this here is we have the ability to mark each level with a specific world, not at all necessary for everybody, but I need it :)
using UnityEngine;
using System.Collections;

public class LevelInfo : MonoBehaviour
{
    public GameEnum.WorldEnum World;
}

public class GameEnum
{
    public enum WorldEnum
    {
        World1,
        World2,
        World3
    }

    public enum PrefabEnum
    {
        PrefabWalls
    }
}

The following script must be placed in a Assets/Editor folder, and adds a menuitem under Tools/CustomHelpers. It runs through the currently open scene, locates all prefabs with tag “Wall” and serializes the scene to a textasset which is placed in a corresponding folder.
using UnityEditor;
using UnityEngine;
using System.Collections.Generic;
using System.IO;

public class SerializeScene : ScriptableWizard
{
    public string Folder = "Levels";
    string assetPath;

    [UnityEditor.MenuItem("Tools/CustomHelpers/Serialize Scene")]
    static void SerializeOpenScene()
    {
        SerializeScene ss = (SerializeScene)ScriptableWizard.DisplayWizard("Serialize Scene", typeof(SerializeScene));
    }

    void OnWizardCreate()
    {
        //Find Levelinfo and extract info on which world the level belongs to
        LevelInfo li = FindObjectOfType(typeof(LevelInfo)) as LevelInfo;
        GameEnum.WorldEnum world = li.World;

        // Get the path we'll use to write our assets:
        assetPath = Application.dataPath + "/Resources/" + Folder + "/" + world.ToString() + "/";
        Debug.Log("Save at " + assetPath);

        // Create the folder that will hold our assets:
        Directory.CreateDirectory(assetPath);

        FindAssets();

        // Make sure the new assets are (re-)imported:
        AssetDatabase.Refresh();

    }

    private void FindAssets()
    {
        List<GameObject> objList = new List<GameObject>();

        LevelData newLevel = new LevelData();

        //Trim string to leave out folder information
        newLevel.Name = trimStringToSceneName(EditorApplication.currentScene);

        //Walls
        GameObject[] walls = GameObject.FindGameObjectsWithTag("Wall");
        Debug.Log("We found " + walls.Length + " walls");

        addObjects(walls, GameEnum.PrefabEnum.PrefabWalls, ref newLevel);

        string newObject = JsonFx.Json.JsonWriter.Serialize(newLevel);

        FileStream fs = new FileStream(assetPath + newLevel.Name + ".txt", FileMode.OpenOrCreate, FileAccess.Write);
        StreamWriter sw = new StreamWriter(fs);
        sw.Write(newObject);
        sw.Close();
        fs.Close();

    }

    private void addObjects(GameObject[] objList, GameEnum.PrefabEnum prefabEnum, ref LevelData level)
    {
        for (int i = 0; i < objList.Length; ++i)
        {
            //Only look for instances of prefabs
            if (PrefabType.PrefabInstance == EditorUtility.GetPrefabType(objList[i]))
            {
                GameObject root = EditorUtility.FindPrefabRoot(objList[i]);

                //Only add to list if its the root to make sure the same object is not added several times
                if (root == objList[i])
                {
                    Debug.Log("It's the Root");
                    level.AddNewPrefab(objList[i], prefabEnum);
                }
                else
                {
                    Debug.Log("It's not the root, so we dont add it to list");
                }
            }
            else
            {
                Debug.Log("NOT A PREFAB");
            }
        }
    }

    private string trimStringToSceneName(string path)
    {
        string sceneName = string.Empty;

        //Removing all but levelname + ".unity"
        string tmpString = path.Remove(0, path.Length - 13);

        //removing ".unity"
        sceneName = tmpString.Substring(0, tmpString.Length - 6);

        return sceneName;
    }
}

You will need these classes as well:
using System.Collections.Generic;
using UnityEngine;

public class LevelData
{
    public string Name;
    public List<SpawnType> ObjectsToSpawn = new List<SpawnType>();

    public void AddNewPrefab(GameObject newObj, GameEnum.PrefabEnum prefabEnum)
    {
        Vector3 pos = newObj.transform.position;
        ObjectsToSpawn.Add(new SpawnType(prefabEnum, pos));
    }
}

public class SpawnType
{
    public GameEnum.PrefabEnum PrefabType;

    public float PosX;
    public float PosY;
    public float PosZ;

    public SpawnType()
    {
    }

    public SpawnType(GameEnum.PrefabEnum prefabEnum, Vector3 _transformVector)
    {
        PrefabType = prefabEnum;
        PosX = _transformVector.x;
        PosY = _transformVector.y;
        PosZ = _transformVector.z;
    }


    public Vector3 GetVector3()
    {
        return new Vector3(PosX, PosY, PosZ);
    }

}


Ok, so now we're able to serialize a scene, saving the type and location of prefabs, and tag it with the corresponding world. Now we need a scene which is able to deserialize the textassets and instantiate the prefabs. Create a new scene called LevelLoader, create an empty gameobject, name it “Loader” and give it the following LevelLoader script.



using UnityEngine;
using System.Collections;

public class LevelLoader : MonoBehaviour
{
    public TextAsset LevelToLoad;
    private LevelData levelData;
    // Use this for initialization
    void Start()
    {

        levelData = JsonFx.Json.JsonReader.Deserialize<LevelData>(LevelToLoad.text);
        Debug.Log("leveldata loaded from textasset and deserialized");

        initiateLevel();
    }

    private void initiateLevel()
    {
        GameObject wallParent = new GameObject();
        Transform walltransform = wallParent.transform;
        wallParent.name = "Walls";

        foreach (SpawnType go in levelData.ObjectsToSpawn)
        {
            //You need to have you Prefabs placed in a "Prefabs" folder
            string resourcePos = "Prefabs/" + go.PrefabType.ToString();
            Object objLoaded = Resources.Load(resourcePos);
            Vector3 pos = go.GetVector3();

            GameObject newObj = Instantiate(objLoaded, pos, Quaternion.identity) as GameObject;
            newObj.transform.parent = walltransform;
        }
    }
}
The above code creates an empty gameobject called walls to use as a parent for all the instantiated prefab, feel free to make this more dynamic. I'll do it myself at a later stage but for the time being it suits my needs. This should allow you to instantiate any number of levels by serializing them and then just include a single scene in your final build that can deserialize it and spawn the relevant gameobjects. Screenshot of the Leveloader scene with the instantiated prefabs:


Hope you found this helpful, although it's mainly a proof of concept. I'll make it more dynamic when I get around to it.

Here's an example: Unity Package