Visual Studio Code in Unity
Getting VSC to work with (older versions of) Unity (and vice versa) is a little tricky. Unity isn't creating solution files by default, which VSC is needing to work properly.
Check out the official VSC documentation about that topic.
The integration on the VSCode Store Page. If possible, install first before creating any scripts. Also make sure you set the correct location of your VSC executeable.
Unity Snippets for VSCode
// <------------ Unity Snippets ------------->
// General
"SnippetTester": {
"prefix": "Snippet",
"body": [
"${1|Choice,Tester|} ${WORKSPACE_NAME}"
],
"description": "My little Snippet tester!\n"
},
"Debug: Log": {
"prefix": "Debug.Log",
"body": [
"Debug.${1|Log,LogWarning,LogError|}($\"<color=#${2:$RANDOM_HEX}>${TM_FILENAME_BASE}</color> ${0}\");"
],
"description": "Debug Logging\n"
},
"Debug: Editor Pause": {
"prefix": "EditorApplication.isPaused",
"body": [
"EditorApplication.isPaused = true;"
],
"description": "Debug Editor Pausing\n"
},
"Singleton Instance": {
"prefix": "Singleton Instance",
"body": [
"public static ${TM_FILENAME_BASE} Instance { get; private set; }",
"private void Awake()",
"{",
"\tif (Instance != null && Instance != this) Destroy(this);",
"\telse Instance = this;",
"}"
],
"description": "Unity Singleton pattern\n"
},
// Attibutes
"Attribute: Create Asset Menu": {
"prefix": "Create Asset Menu",
"body": [
"[CreateAssetMenu(menuName = \"${1:SubMenuName}/${2:Name}\")]"
],
"description": "Creates a custom menu entry for unity's create menu\n"
},
"Attribute: Header": {
"prefix": "Header Attribute",
"body": [
"[Header(\"${1:HeaderTitle}\")]"
],
"description": "Creates a Header label in Inspector\n"
},
"Attribute: HideInInspector": {
"prefix": "HideInInspector Attribute",
"body": [
"[HideInInspector]"
],
"description": "Hides the value in the Inspector\n"
},
"Attribute: HelpURL": {
"prefix": "Help URL",
"body": [
"[HelpURL(\"${1:http://manuals.clawjelly.net/Unity/UnityAttributes/}\")]"
],
"description": "Customizes the help target in Inspector\n"
},
"Attribute: InspectorName": {
"prefix": "Inspector Name",
"body": [
"[InspectorName(\"${1:My Custom Field Name}\")]"
],
"description": "Customizes the field name in Inspector\n"
},
"Attribute: Menu Item": {
"prefix": "Menu Item",
"body": [
"[MenuItem(\"${1:SubMenuName}/${2:Name}\")]"
],
"description": "Adds a custom menu to a field in Inspector\n"
},
"Attribute: Range": {
"prefix": "Range Slider",
"body": [
"[Range(${1:0f}, ${2:1f})]"
],
"description": "Displays a float as a slider in Inspector\n"
},
"Attribute: Space": {
"prefix": "Space Attribute",
"body": [
"[Space(${1:10})]"
],
"description": "Adds some space in the Inspector\n"
},
"Attribute: SerializeField": {
"prefix": "Serialize Field",
"body": [
"[SerializeField]"
],
"description": "Makes a private field visible\n"
},
"Attribute: System.Serializeable": {
"prefix": "Serialize Class",
"body": [
"[System.Serializable]"
],
"description": "Makes a class serializeable by Unity\n"
},
"Attribute: Tooltip": {
"prefix": "Tooltip",
"body": [
"[Tooltip(\"${1:Additional Info}\")]"
],
"description": "Adds a tooltip to the field in the inspector\n"
},
"Attribute: Require Component": {
"prefix": "Require Component",
"body": [
"[RequireComponent(typeof(${1:Rigidbody}))]"
],
"description": "Adds a component requirement\n"
},
// User Interfaces
"EditorGUILayout.LabelField": {
"prefix": "Label Field",
"body": [
"EditorGUILayout.LabelField(\"${1:My Label}\");${0}"
],
"description": "A label\n"
},
"EditorGUILayout.Toggle": {
"prefix": "Toggle",
"body": [
"${1:myBool} = EditorGUILayout.Toggle(\"${2:Is Active}\", ${1:myBool});${0}"
],
"description": "A bool representation\n"
},
"EditorGUILayout.Space": {
"prefix": "Space",
"body": [
"EditorGUILayout.Space();${0}"
],
"description": "Some space in the layout\n"
},
"EditorGUILayout.ObjectField": {
"prefix": "Object Field",
"body": [
"${1:objectName} = (${2:ObjectType})EditorGUILayout.ObjectField(${1:objectName}, typeof(${2:ObjectType}), true);${0}"
],
"description": "An object reference field\n"
},
"EditorGUILayout.IntField": {
"prefix": "Int Field",
"body": [
"${1:intName} = EditorGUILayout.IntField(\"${2:My Int Label}\", ${1:intName});${0}"
],
"description": "An integer field\n"
},
"GUILayout.Button": {
"prefix": "Button",
"body": [
"if (GUILayout.Button(\"${1:My Button}\"))",
"{",
"\t${TM_SELECTED_TEXT}${0}",
"\tGUIUtility.ExitGUI();",
"}"
],
"description": "A button\n"
},
"EditorGUILayout.BeginVertical": {
"prefix": "Begin Vertical",
"body": [
"EditorGUILayout.BeginVertical(EditorStyles.helpBox);",
"${TM_SELECTED_TEXT} ${0}",
"EditorGUILayout.EndVertical();",
],
"description": "A vertical GUI area\n"
},
"EditorGUILayout.BeginHorizontal": {
"prefix": "Begin Horizontal",
"body": [
"EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);",
"${TM_SELECTED_TEXT} ${0}",
"EditorGUILayout.EndHorizontal();",
],
"description": "A horizontal GUI area\n"
},
"EditorGUILayout.BeginFoldoutHeaderGroup": {
"prefix": "Begin Foldout Header Group",
"body": [
"${1:myBool} = EditorGUILayout.BeginFoldoutHeaderGroup(${1:myBool}, \"${2:My Foldout Group}\");",
"${TM_SELECTED_TEXT} ${0}",
"EditorGUILayout.EndFoldoutHeaderGroup();",
"",
],
"description": "A horizontal GUI area\n"
},
"EditorGUILayout.HelpBox": {
"prefix": "HelpBox",
"body": [
"EditorGUILayout.HelpBox(\"${1:My Help Message}\", MessageType.Info);${0}"
],
"description": "A help box with a little info sign\n"
},
"EditorUtility.OpenFilePanel": {
"prefix": "OpenFilePanel",
"body": [
"string ${1:jsonpath} = EditorUtility.OpenFilePanel(\"Open ${2:json} file\", \"\", \"${2:json}\");",
"if (${1:jsonpath}.Length != 0)",
"{",
"\t${0}",
"}"
],
"description": "The base for a open file dialogue\n"
},
"EditorUtility.SaveFilePanel": {
"prefix": "SaveFilePanel",
"body": [
"var jsonpath = EditorUtility.SaveFilePanel(",
"\t\"Save to JSON\",",
"\t\"\",",
"\t\"${1:filename}.json\",",
"\t\"json\");",
"if (jsonpath.Length == 0) return;"
],
"description": "The base for a save file dialogue\n"
},
// Various boilerplates
"StartCoroutine": {
"prefix": "StartCoroutine",
"description": "A coroutine is a unity function running over several frames.\n",
"body": [
"StartCoroutine(\"${1:CoroutineName}\");"
]
},
"Coroutine": {
"prefix": "Coroutine",
"description": "A coroutine is a unity function running over several frames.\n",
"body": [
"IEnumerator ${1:CoRoutine}(${2})",
"{",
"\t// wait for next frame:",
"\tyield return null;",
"\t// pause the coroutine for two seconds:",
"\tyield return new WaitForSeconds(2);",
"\t// end coroutine:",
"\tyield break;",
"}"
]
},
"Editor Region": {
"prefix": "Editor Description String",
"body": [
"#region EditorOnly",
"#if UNITY_EDITOR",
"[HideInInspector]",
"public string Description = \"${1:My description}\";",
"#endif",
"#endregion"
],
"description": "Creates a description string for the editor\n"
},
"Using Unity": {
"prefix": "using unity",
"description": "Standard imports for Unity\n",
"body": [
"using System;",
"using System.Collections;",
"using System.Collections.Generic;",
"using UnityEngine;",
"using UnityEditor;",
"${0}"
]
},
"Monobehaviour Class": {
"prefix": "MonoBehaviour Class",
"description": "Boiler plate for a MonoBehaviour class",
"body": [
"public class ${TM_FILENAME_BASE} : MonoBehaviour",
"{",
"\tvoid Start()",
"\t{",
"\t",
"\t}",
"\t",
"\tvoid Update()",
"\t{",
"\t\t${0}",
"\t}",
"}"
]
},
"Scriptable Object": {
"prefix": "Scriptable Object",
"description": "Full boilerplate for a scriptable object\n",
"body": [
"[CreateAssetMenu(fileName = \"${1:MyASset}\", menuName = \"${2:MyAssetFolder}\")]",
"public class $TM_FILENAME_BASE : ScriptableObject",
"{",
"\t$0",
"}"
]
},
"Property Drawer": {
"prefix": "Property Drawer",
"description": "Boiler plate for a property drawer\n",
"body": [
"[CustomPropertyDrawer(typeof(${TM_FILENAME_BASE/Drawer//}))]",
"public class $TM_FILENAME_BASE : PropertyDrawer",
"{",
"\tpublic override void OnGUI(Rect position, SerializedProperty property, GUIContent label)",
"\t{",
"\t\tEditorGUI.BeginProperty(position, label, property);",
"",
"\t\t${0}",
"",
"\t\tEditorGUI.EndProperty();",
"\t}",
"}"
]
},
"Custom Editor": {
"prefix": "Custom Editor",
"description": "Unity Custom Unity Editor\n",
"body": [
"[CustomEditor(typeof(${TM_FILENAME_BASE/Editor//}))]",
"public class ${TM_FILENAME_BASE} : Editor",
"{",
"\tpublic override void OnInspectorGUI()",
"\t{",
"\t\t${TM_FILENAME_BASE/Editor//} ${TM_FILENAME_BASE/(.*)Editor/${1:/camelcase}/} = (${TM_FILENAME_BASE/Editor//}) target;",
"\t\tbase.DrawDefaultInspector();",
"\t\tif (!EditorApplication.isPlaying) return;",
"\t\t// Runtime only UI",
"\t\tEditorGUILayout.Space();",
"\t\tEditorGUILayout.BeginVertical(EditorStyles.helpBox);",
"\t\tEditorGUILayout.LabelField(\"${1:My Label}\");",
"\t\tif (GUILayout.Button(\"${2:My Button}\"))",
"\t\t{",
"\t\t\t${0}",
"\t\t\tGUIUtility.ExitGUI();",
"\t\t}",
"\t\tEditorGUILayout.EndVertical();",
"\t}",
"}"
]
},
"Editor Window": {
"prefix": "Editor Window",
"description": "Unity Editor Window\n",
"body": [
"public class ${TM_FILENAME_BASE} : EditorWindow",
"{",
"\t[MenuItem(\"Window/${WORKSPACE_NAME}/${TM_FILENAME_BASE/EditorWindow//}\")]",
"\tpublic static void ShowWindow()",
"\t{",
"\t\tEditorWindow.GetWindow(typeof(${TM_FILENAME_BASE}));",
"\t}",
"",
"\tvoid OnGUI()",
"\t{",
"\t\t${0}",
"\t}",
"}"
]
},
"OnDrawGizmos": {
"prefix": "OnDrawGizmos",
"description": "OnDrawGizmos Boilererplate\n",
"body": [
"#region EditorOnly",
"#if UNITY_EDITOR",
"void ${1|OnDrawGizmosSelected,OnDrawGizmos|}() ",
"{",
"\t${0}",
"}",
"#endif",
"#endregion",
]
},
"Draw Sphere Gizmo": {
"prefix": "Draw Sphere Gizmo",
"description": "Draw a sphere gizmo Boilererplate\n",
"body": [
"Gizmos.DrawSphere(transform.position, 1);",
]
},
"Write Dictionary To Markdown File": {
"prefix": "Markdown Dictionary",
"description": "Generate boilerplate for a dictionary markdown file\n",
"body": [
"List<string> lines = new List<string>();",
"lines.Add(\"# ${1:Table Title}\");",
"lines.Add(\"| Key | Count |\");",
"lines.Add(\"|-----|-------|\");",
"foreach (var keyValuePair in ${2:dictionary})",
"{",
"\tlines.Add($\"|{keyValuePair.Key.ToString()}|{keyValuePair.Value.ToString()}|\")",
"}",
"File.WriteAllLines(\"${3:filename}.md\", lines);"
]
},
"Newtonsoft JSON Using": {
"prefix": "using JSON Newtonsoft",
"description": "The using statement necessary for Newtonsoft JSON",
"body": [
"using System.IO;",
"using Newtonsoft.Json;"
]
},
"Read structure from JSON file": {
"prefix": "Read JSON Data",
"description": "Boilererplate: Reads a structure from a JSON file.\nNeeds this line: using Newtonsoft.Json;",
"body": [
"using (StreamReader file = File.OpenText(${1:jsonPath}))",
"{",
"\tJsonSerializer serializer = new JsonSerializer();",
"\t${2:List<string>} ${3:myList} = (${2:List<string>})serializer.Deserialize(file, typeof(${2:List<string>}));",
"}",
]
},
"Write structure to JSON file": {
"prefix": "Write JSON Data",
"description": "Boilererplate: Write a structure to a JSON file.\nNeeds this line: using Newtonsoft.Json;",
"body": [
"JsonSerializer serializer = new JsonSerializer();",
"serializer.NullValueHandling = NullValueHandling.Ignore;",
"serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;",
"serializer.Formatting = Formatting.Indented;",
"using (StreamWriter sw = new StreamWriter(jsonpath))",
" using (JsonWriter writer = new JsonTextWriter(sw))",
" serializer.Serialize(writer, myDataStructure);"
]
}