public static bool IsActionListPrefab(ActionList _target)
{
if (UnityVersionHandler.IsPrefabFile(_target.gameObject) && _target.source == ActionListSource.InScene)
{
return(true);
}
return(false);
}
public static void PropertiesGUI(Cutscene _target)
{
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Cutscene properties", EditorStyles.boldLabel);
_target.source = (ActionListSource)EditorGUILayout.EnumPopup("Actions source:", _target.source);
if (_target.source == ActionListSource.AssetFile)
{
_target.assetFile = (ActionListAsset)EditorGUILayout.ObjectField("ActionList asset:", _target.assetFile, typeof(ActionListAsset), false);
_target.syncParamValues = EditorGUILayout.Toggle("Sync parameter values?", _target.syncParamValues);
}
_target.actionListType = (ActionListType)EditorGUILayout.EnumPopup("When running:", _target.actionListType);
if (_target.actionListType == ActionListType.PauseGameplay)
{
_target.isSkippable = EditorGUILayout.Toggle("Is skippable?", _target.isSkippable);
}
_target.triggerTime = EditorGUILayout.Slider("Start delay (s):", _target.triggerTime, 0f, 10f);
_target.autosaveAfter = EditorGUILayout.Toggle("Autosave after?", _target.autosaveAfter);
_target.tagID = ShowTagUI(_target.actions.ToArray(), _target.tagID);
if (_target.source == ActionListSource.InScene)
{
_target.useParameters = EditorGUILayout.Toggle("Use parameters?", _target.useParameters);
}
else if (_target.source == ActionListSource.AssetFile && _target.assetFile != null && !_target.syncParamValues && _target.assetFile.useParameters)
{
_target.useParameters = EditorGUILayout.Toggle("Set local parameter values?", _target.useParameters);
}
EditorGUILayout.EndVertical();
if (_target.useParameters)
{
if (_target.source == ActionListSource.InScene)
{
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Parameters", EditorStyles.boldLabel);
ActionListEditor.ShowParametersGUI(_target, null, _target.parameters);
EditorGUILayout.EndVertical();
}
else if (!_target.syncParamValues && _target.source == ActionListSource.AssetFile && _target.assetFile != null && _target.assetFile.useParameters)
{
bool isAsset = UnityVersionHandler.IsPrefabFile(_target.gameObject);
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Local parameter values", EditorStyles.boldLabel);
ActionListEditor.ShowLocalParametersGUI(_target.parameters, _target.assetFile.parameters, isAsset);
EditorGUILayout.EndVertical();
}
}
}
public static void PropertiesGUI(Cutscene _target)
{
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Cutscene properties", EditorStyles.boldLabel);
_target.source = (ActionListSource)CustomGUILayout.EnumPopup("Actions source:", _target.source, "", "Where the Actions are stored");
if (_target.source == ActionListSource.AssetFile)
{
_target.assetFile = (ActionListAsset)CustomGUILayout.ObjectField <ActionListAsset> ("ActionList asset:", _target.assetFile, false, "", "The ActionList asset that stores the Actions");
_target.syncParamValues = CustomGUILayout.Toggle("Sync parameter values?", _target.syncParamValues, "", "If True, the ActionList asset's parameter values will be shared amongst all linked ActionLists");
}
_target.actionListType = (ActionListType)CustomGUILayout.EnumPopup("When running:", _target.actionListType, "", "The effect that running the Actions has on the rest of the game");
if (_target.actionListType == ActionListType.PauseGameplay)
{
_target.isSkippable = CustomGUILayout.Toggle("Is skippable?", _target.isSkippable, "", "If True, the Actions will be skipped when the user presses the 'EndCutscene' Input button");
}
_target.triggerTime = CustomGUILayout.Slider("Start delay (s):", _target.triggerTime, 0f, 10f, "", "The delay, in seconds, before the Actions are run when the ActionList is triggered");
_target.autosaveAfter = CustomGUILayout.Toggle("Autosave after?", _target.autosaveAfter, "", "If True, the game will auto-save when the Actions have finished running");
_target.tagID = ShowTagUI(_target.actions.ToArray(), _target.tagID);
if (_target.source == ActionListSource.InScene)
{
_target.useParameters = CustomGUILayout.Toggle("Use parameters?", _target.useParameters, "", "If True, ActionParameters can be used to override values within the Action objects");
}
else if (_target.source == ActionListSource.AssetFile && _target.assetFile != null && !_target.syncParamValues && _target.assetFile.useParameters)
{
_target.useParameters = CustomGUILayout.Toggle("Set local parameter values?", _target.useParameters, "", "If True, parameter values set here will be assigned locally, and not on the ActionList asset");
}
EditorGUILayout.EndVertical();
if (_target.useParameters)
{
if (_target.source == ActionListSource.InScene)
{
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Parameters", EditorStyles.boldLabel);
ActionListEditor.ShowParametersGUI(_target, null, _target.parameters);
EditorGUILayout.EndVertical();
}
else if (!_target.syncParamValues && _target.source == ActionListSource.AssetFile && _target.assetFile != null && _target.assetFile.useParameters)
{
bool isAsset = UnityVersionHandler.IsPrefabFile(_target.gameObject);
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Local parameter values", EditorStyles.boldLabel);
ActionListEditor.ShowLocalParametersGUI(_target.parameters, _target.assetFile.GetParameters(), isAsset);
EditorGUILayout.EndVertical();
}
}
}
protected void SharedGUI()
{
ConstantID _target = (ConstantID)target;
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Constant ID number", EditorStyles.boldLabel);
_target.autoManual = (AutoManual)CustomGUILayout.EnumPopup("Set:", _target.autoManual, "", "Is the Constant ID set automatically or manually?");
_target.retainInPrefab = CustomGUILayout.Toggle("Retain in prefab?", _target.retainInPrefab, "", "If True, prefabs will share the same Constant ID as their scene-based counterparts");
bool ignoreDirty = false;
if (UnityVersionHandler.IsPrefabFile(_target.gameObject))
{
// Prefab
if (!_target.retainInPrefab && _target.constantID != 0)
{
_target.constantID = 0;
// Don't flag as dirty, otherwise get problems with scene instances
ignoreDirty = true;
}
else if (_target.retainInPrefab && _target.constantID == 0)
{
_target.SetNewID_Prefab();
}
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("ID:", "The recorded Constant ID number"), GUILayout.Width(50f));
if (_target.autoManual == AutoManual.Automatic)
{
EditorGUILayout.LabelField(_target.constantID.ToString());
}
else
{
_target.constantID = EditorGUILayout.DelayedIntField(_target.constantID);
}
if (GUILayout.Button("Copy number"))
{
EditorGUIUtility.systemCopyBuffer = _target.constantID.ToString();
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
if (!ignoreDirty)
{
UnityVersionHandler.CustomSetDirty(_target);
}
}
public static void PropertiesGUI(DialogueOption _target)
{
CustomGUILayout.BeginVertical();
EditorGUILayout.LabelField("Dialogue Option properties", EditorStyles.boldLabel);
_target.source = (ActionListSource)CustomGUILayout.EnumPopup("Actions source:", _target.source, "", "Where the Actions are stored");
if (_target.source == ActionListSource.AssetFile)
{
_target.assetFile = (ActionListAsset)CustomGUILayout.ObjectField <ActionListAsset> ("ActionList asset:", _target.assetFile, false, "", "The ActionList asset that stores the Actions");
_target.syncParamValues = CustomGUILayout.Toggle("Sync parameter values?", _target.syncParamValues, "", "If True, the ActionList asset's parameter values will be shared amongst all linked ActionLists");
}
if (_target.actionListType == ActionListType.PauseGameplay)
{
_target.isSkippable = CustomGUILayout.Toggle("Is skippable?", _target.isSkippable, "", "If True, the Actions will be skipped when the user presses the 'EndCutscene' Input button");
}
_target.tagID = ShowTagUI(_target.actions.ToArray(), _target.tagID);
if (_target.source == ActionListSource.InScene)
{
_target.useParameters = CustomGUILayout.Toggle("Use parameters?", _target.useParameters, "", "If True, ActionParameters can be used to override values within the Action objects");
}
else if (_target.source == ActionListSource.AssetFile && _target.assetFile != null && !_target.syncParamValues && _target.assetFile.useParameters)
{
_target.useParameters = CustomGUILayout.Toggle("Set local parameter values?", _target.useParameters, "", "If True, parameter values set here will be assigned locally, and not on the ActionList asset");
}
CustomGUILayout.EndVertical();
if (_target.useParameters)
{
if (_target.source == ActionListSource.InScene)
{
EditorGUILayout.Space();
CustomGUILayout.BeginVertical();
EditorGUILayout.LabelField("Parameters", EditorStyles.boldLabel);
ShowParametersGUI(_target, null, _target.parameters);
CustomGUILayout.EndVertical();
}
else if (!_target.syncParamValues && _target.source == ActionListSource.AssetFile && _target.assetFile != null && _target.assetFile.useParameters)
{
bool isAsset = UnityVersionHandler.IsPrefabFile(_target.gameObject);
EditorGUILayout.Space();
CustomGUILayout.BeginVertical();
EditorGUILayout.LabelField("Local parameter values", EditorStyles.boldLabel);
ShowLocalParametersGUI(_target.parameters, _target.assetFile.GetParameters(), isAsset);
CustomGUILayout.EndVertical();
}
}
}
public static void PropertiesGUI(DialogueOption _target)
{
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Dialogue Option properties", EditorStyles.boldLabel);
_target.source = (ActionListSource)EditorGUILayout.EnumPopup("Actions source:", _target.source);
if (_target.source == ActionListSource.AssetFile)
{
_target.assetFile = ActionListAssetMenu.AssetGUI("ActionList asset:", _target.assetFile);
_target.syncParamValues = EditorGUILayout.Toggle("Sync parameter values?", _target.syncParamValues);
}
if (_target.actionListType == ActionListType.PauseGameplay)
{
_target.isSkippable = EditorGUILayout.Toggle("Is skippable?", _target.isSkippable);
}
_target.tagID = ShowTagUI(_target.actions.ToArray(), _target.tagID);
if (_target.source == ActionListSource.InScene)
{
_target.useParameters = EditorGUILayout.Toggle("Use parameters?", _target.useParameters);
}
else if (_target.source == ActionListSource.AssetFile && _target.assetFile != null && !_target.syncParamValues && _target.assetFile.useParameters)
{
_target.useParameters = EditorGUILayout.Toggle("Set local parameter values?", _target.useParameters);
}
EditorGUILayout.EndVertical();
if (_target.useParameters)
{
if (_target.source == ActionListSource.InScene)
{
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Parameters", EditorStyles.boldLabel);
ShowParametersGUI(_target, null, _target.parameters);
EditorGUILayout.EndVertical();
}
else if (!_target.syncParamValues && _target.source == ActionListSource.AssetFile && _target.assetFile != null && _target.assetFile.useParameters)
{
bool isAsset = UnityVersionHandler.IsPrefabFile(_target.gameObject);
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Local parameter values", EditorStyles.boldLabel);
ShowLocalParametersGUI(_target.parameters, _target.assetFile.parameters, isAsset);
EditorGUILayout.EndVertical();
}
}
}
protected void Update()
{
if (gameObject.activeInHierarchy && !UnityVersionHandler.IsPrefabFile(gameObject) && !Application.isPlaying)
{
if (constantID == 0)
{
SetNewID();
}
if (isNewInstance)
{
isNewInstance = false;
CheckForDuplicateIDs();
}
}
}
/**
* Converts the NPC to a Player.
*/
public void ConvertToPlayer()
{
if (UnityVersionHandler.IsPrefabFile(gameObject))
{
UnityEditor.EditorUtility.DisplayDialog("Convert " + name + " to Player?", "Only scene objects can be converted. Place an instance of this prefab into your scene and try again.", "OK");
return;
}
if (UnityEditor.EditorUtility.DisplayDialog("Convert " + name + " to Player?", "This will convert the NPC into a Player. NPC-only data will lost in the process, and you should back up your project first. Continue?", "OK", "Cancel"))
{
AC.Char npcAsCharacter = (AC.Char) this;
string characterData = JsonUtility.ToJson(npcAsCharacter);
Player player = gameObject.AddComponent <Player>();
JsonUtility.FromJsonOverwrite(characterData, player);
DestroyImmediate(this);
}
}
protected void SharedGUI()
{
ConstantID _target = (ConstantID)target;
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Constant ID number", EditorStyles.boldLabel);
_target.autoManual = (AutoManual)EditorGUILayout.EnumPopup("Set:", _target.autoManual);
_target.retainInPrefab = EditorGUILayout.Toggle("Retain in prefab?", _target.retainInPrefab);
if (UnityVersionHandler.IsPrefabFile(_target.gameObject))
{
// Prefab
if (!_target.retainInPrefab && _target.constantID != 0)
{
_target.constantID = 0;
}
else if (_target.retainInPrefab && _target.constantID == 0)
{
_target.SetNewID_Prefab();
}
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("ID:", GUILayout.Width(50f));
if (_target.autoManual == AutoManual.Automatic)
{
EditorGUILayout.LabelField(_target.constantID.ToString());
}
else
{
_target.constantID = EditorGUILayout.IntField(_target.constantID);
}
if (GUILayout.Button("Copy number"))
{
EditorGUIUtility.systemCopyBuffer = _target.constantID.ToString();
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
UnityVersionHandler.CustomSetDirty(_target);
}
private void SetNewID(bool ignoreOthers = false)
{
// Share ID if another ID script already exists on object
ConstantID[] idScripts = GetComponents <ConstantID>();
foreach (ConstantID idScript in idScripts)
{
if (idScript != this && idScript.constantID != 0)
{
if (ignoreOthers && idScript.constantID == constantID)
{
continue;
}
constantID = idScript.constantID;
UnityVersionHandler.CustomSetDirty(this, true);
return;
}
}
if (UnityVersionHandler.IsPrefabFile(gameObject) &&
UnityVersionHandler.IsPrefabEditing(gameObject) &&
!retainInPrefab)
{
// Avoid setting ID to a prefab that shouldn't have one
return;
}
constantID = GetInstanceID();
if (constantID < 0)
{
constantID *= -1;
}
UnityVersionHandler.CustomSetDirty(this, true);
ACDebug.Log("Set new ID for " + this.GetType().ToString() + " to " + gameObject.name + ": " + constantID, gameObject);
}
private void OnGUI()
{
GUILayout.BeginVertical(CustomStyles.thinBox, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
GUILayout.Label(GetTitle(), CustomStyles.managerHeader);
if (GetTitle() != "")
{
EditorGUILayout.Separator();
GUILayout.Space(10f);
}
ShowPage();
GUILayout.Space(15f);
GUILayout.BeginHorizontal();
if (pageNumber < 1)
{
if (pageNumber < 0)
{
pageNumber = 0;
}
GUI.enabled = false;
}
if (pageNumber < numPages)
{
if (GUILayout.Button("Previous", EditorStyles.miniButtonLeft))
{
pageNumber--;
}
}
else
{
if (GUILayout.Button("Restart", EditorStyles.miniButtonLeft))
{
pageNumber = 0;
}
}
GUI.enabled = true;
if (pageNumber < numPages - 1)
{
if (pageNumber == 1)
{
if (!IsFirstPerson())
{
if (baseObject == null || UnityVersionHandler.IsPrefabFile(baseObject) || baseObject.GetComponent <AC.Char>() || !baseObject.activeInHierarchy)
{
GUI.enabled = false;
}
}
}
if (GUILayout.Button("Next", EditorStyles.miniButtonRight))
{
pageNumber++;
if (pageNumber == 2 && IsFirstPerson())
{
animationEngine = AnimationEngine.Mecanim;
pageNumber = 3;
}
if (pageNumber == 2)
{
if (baseObject != null && baseObject.GetComponentInChildren <Animation>())
{
animationEngine = AnimationEngine.Legacy;
}
else if (baseObject != null && (baseObject.GetComponentInChildren <SkinnedMeshRenderer>() || baseObject.GetComponentInChildren <MeshRenderer>()))
{
animationEngine = AnimationEngine.Mecanim;
}
else if (baseObject != null && baseObject.GetComponentInChildren <SpriteRenderer>())
{
animationEngine = AnimationEngine.SpritesUnity;
}
else if (baseObject != null && tk2DIntegration.Is2DtkSprite(baseObject))
{
animationEngine = AnimationEngine.Sprites2DToolkit;
}
else if (SceneSettings.CameraPerspective == CameraPerspective.TwoD)
{
animationEngine = AnimationEngine.SpritesUnity;
}
else
{
animationEngine = AnimationEngine.Mecanim;
}
}
}
GUI.enabled = true;
}
else
{
if (pageNumber == numPages)
{
GUI.enabled = false;
}
if (GUILayout.Button("Finish", EditorStyles.miniButtonRight))
{
pageNumber++;
Finish();
}
GUI.enabled = true;
}
GUILayout.EndHorizontal();
GUI.Label(pageRect, "Page " + (pageNumber + 1) + " of " + (numPages + 1));
GUILayout.FlexibleSpace();
EditorGUILayout.EndVertical();
}
private void ShowPage()
{
GUI.skin.label.wordWrap = true;
if (pageNumber == 0)
{
if (Resource.ACLogo != null)
{
GUI.DrawTexture(new Rect(82, 25, 256, 128), Resource.ACLogo);
}
GUILayout.Space(140f);
GUILayout.Label("This window can assist with the creation of a Player or NPC.");
GUILayout.Label("To begin, click 'Next'.");
}
else if (pageNumber == 1)
{
GUILayout.Label("Is this a Player or an NPC?");
charType = (CharType)EditorGUILayout.EnumPopup(charType);
if (charType == CharType.NPC)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label("The character's name:", GUILayout.Width(150f));
charName = GUILayout.TextField(charName);
EditorGUILayout.EndHorizontal();
}
else
{
if (AdvGame.GetReferences().settingsManager&& AdvGame.GetReferences().settingsManager.movementMethod == MovementMethod.FirstPerson)
{
EditorGUILayout.HelpBox("First-person Player prefabs require no base graphic, though one can be added after creation if desired.", MessageType.Info);
return;
}
}
GUILayout.Label("Assign your character's base GameObject (such as a Skinned Mesh Renderer or 'idle' sprite):");
baseObject = (GameObject)EditorGUILayout.ObjectField(baseObject, typeof(GameObject), true);
if (baseObject != null && !IsFirstPerson())
{
if (baseObject.GetComponent <AC.Char>())
{
EditorGUILayout.HelpBox("The wizard cannot modify an existing character!", MessageType.Warning);
}
else if (UnityVersionHandler.IsPrefabFile(baseObject) || !baseObject.activeInHierarchy)
{
EditorGUILayout.HelpBox("The object must be in the scene and enabled for the wizard to work.", MessageType.Warning);
}
}
}
else if (pageNumber == 2)
{
GUILayout.Label("How should '" + charType.ToString() + "' should be animated?");
animationEngine = (AnimationEngine)EditorGUILayout.EnumPopup(animationEngine);
if (animationEngine == AnimationEngine.Custom)
{
EditorGUILayout.HelpBox("This option is intended for characters that make use of a custom/third-party animation system that will require additional coding.", MessageType.Info);
}
else if (animationEngine == AnimationEngine.Legacy)
{
EditorGUILayout.HelpBox("Legacy animation is for 3D characters that do not require complex animation trees or multiple layers. Its easier to use than Mecanim, but not as powerful.", MessageType.Info);
}
else if (animationEngine == AnimationEngine.Mecanim)
{
EditorGUILayout.HelpBox("Mecanim animation is the standard option for 3D characters. You will need to define Mecanim parameters and transitions, but will have full control over how the character is animated.", MessageType.Info);
}
else if (animationEngine == AnimationEngine.Sprites2DToolkit)
{
EditorGUILayout.HelpBox("This option allows you to animate characters using the 3rd-party 2D Toolkit asset.", MessageType.Info);
if (!tk2DIntegration.IsDefinePresent())
{
EditorGUILayout.HelpBox("The 'tk2DIsPresent' preprocessor define must be declared in your game's Scripting Define Symbols, found in File -> Build -> Player settings.", MessageType.Warning);
}
}
else if (animationEngine == AnimationEngine.SpritesUnity)
{
EditorGUILayout.HelpBox("This option is the standard option for 2D characters. Animation clips are played automatically, without the need to define Mecanim parameters, but you will not be able to make e.g. smooth transitions between the different movement animations.", MessageType.Info);
}
else if (animationEngine == AnimationEngine.SpritesUnityComplex)
{
EditorGUILayout.HelpBox("This option is harder to use than 'Sprites Unity', but gives you more control over how your character animates - allowing you to control animations using Mecanim parameters and transitions.", MessageType.Info);
}
}
else if (pageNumber == 3)
{
EditorGUILayout.LabelField("Chosen animation engine: " + animationEngine.ToString(), EditorStyles.boldLabel);
if (!IsFirstPerson())
{
if (animationEngine == AnimationEngine.Custom)
{
EditorGUILayout.HelpBox("A subclass of 'AnimEngine' will be used to bridge AC with an external animation engine. The subclass script defined above must exist for the character to animate. Once created, enter its name in the box below:", MessageType.Info);
customAnimationClass = EditorGUILayout.TextField("Subclass script name:", customAnimationClass);
}
else if (animationEngine == AnimationEngine.Mecanim || animationEngine == AnimationEngine.SpritesUnityComplex || animationEngine == AnimationEngine.SpritesUnity)
{
if (baseObject.GetComponent <Animator>() == null)
{
EditorGUILayout.HelpBox("This chosen method will make use of an Animator Controller asset.\nOnce the wizard has finished, you will need to create such an asset and assign it in your character's 'Animator' component.", MessageType.Info);
}
else
{
EditorGUILayout.HelpBox("This chosen method will make use of an Animator component, and one has already been detected on the base object.\nThis will be assumed to be the Animator to animate the character with.", MessageType.Info);
}
}
if (animationEngine == AnimationEngine.Sprites2DToolkit || animationEngine == AnimationEngine.SpritesUnityComplex || animationEngine == AnimationEngine.SpritesUnity)
{
if (SceneSettings.CameraPerspective != CameraPerspective.TwoD)
{
EditorGUILayout.LabelField("It has been detected that you are attempting\nto create a 2D character in a 3D game.\nIs this correct?", GUILayout.Height(40f));
enforce3D = EditorGUILayout.Toggle("Yes!", enforce3D);
}
}
}
EditorGUILayout.HelpBox("Click 'Finish' below to create the character and complete the wizard.", MessageType.Info);
}
else if (pageNumber == 4)
{
GUILayout.Label("Congratulations, your " + charType.ToString() + " has been created! Check the '" + charType.ToString() + "' Inspector to set up animation and other properties, as well as modify any generated Colliders / Rigidbody components.");
if (charType == CharType.Player)
{
GUILayout.Space(5f);
GUILayout.Label("To register this is as the main player character, turn it into a prefab and assign it in your Settings Manager, underneath 'Player settings'.");
}
}
}
public static GUIData SetParametersGUI(List <ActionParameter> externalParameters, bool isAssetFile, GUIData guiData, List <ActionParameter> ownParameters = null)
{
guiData = SyncLists(externalParameters, guiData);
CustomGUILayout.BeginVertical();
for (int i = 0; i < externalParameters.Count; i++)
{
string label = externalParameters[i].label;
string tooltip = externalParameters[i].description;
int linkedID = (i < guiData.parameterIDs.Count)
? guiData.parameterIDs[i]
: -1;
guiData.fromParameters[i].parameterType = externalParameters[i].parameterType;
switch (externalParameters[i].parameterType)
{
case ParameterType.GameObject:
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.GameObject);
if (linkedID < 0)
{
if (isAssetFile)
{
guiData.fromParameters[i].gameObject = (GameObject)CustomGUILayout.ObjectField <GameObject> (label + ":", guiData.fromParameters[i].gameObject, true, string.Empty, tooltip);
if (guiData.fromParameters[i].gameObject)
{
if (!UnityVersionHandler.IsPrefabFile(guiData.fromParameters[i].gameObject))
{
guiData.fromParameters[i].intValue = Action.FieldToID(guiData.fromParameters[i].gameObject, guiData.fromParameters[i].intValue, false, isAssetFile);
guiData.fromParameters[i].gameObject = Action.IDToField(guiData.fromParameters[i].gameObject, guiData.fromParameters[i].intValue, true, false, isAssetFile);
}
else
{
// A prefab, ask if we want to affect the prefab or the scene-based instance?
guiData.fromParameters[i].gameObjectParameterReferences = (GameObjectParameterReferences)EditorGUILayout.EnumPopup("GameObject parameter:", guiData.fromParameters[i].gameObjectParameterReferences);
}
}
else
{
guiData.fromParameters[i].intValue = CustomGUILayout.IntField(label + " (ID #):", guiData.fromParameters[i].intValue, string.Empty, tooltip);
}
}
else
{
// Gameobject
guiData.fromParameters[i].gameObject = (GameObject)CustomGUILayout.ObjectField <GameObject> (label + ":", guiData.fromParameters[i].gameObject, true, string.Empty, tooltip);
guiData.fromParameters[i].intValue = 0;
if (guiData.fromParameters[i].gameObject && guiData.fromParameters[i].gameObject.GetComponent <ConstantID>() == null)
{
UnityVersionHandler.AddConstantIDToGameObject <ConstantID> (guiData.fromParameters[i].gameObject);
}
}
}
}
break;
case ParameterType.UnityObject:
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.UnityObject);
if (linkedID < 0)
{
guiData.fromParameters[i].objectValue = (Object)CustomGUILayout.ObjectField <Object> (label + ":", guiData.fromParameters[i].objectValue, true, string.Empty, tooltip);
}
}
break;
case ParameterType.GlobalVariable:
{
if (AdvGame.GetReferences() && AdvGame.GetReferences().variablesManager)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.GlobalVariable, -1, tooltip);
if (linkedID < 0)
{
VariablesManager variablesManager = AdvGame.GetReferences().variablesManager;
guiData.fromParameters[i].intValue = ActionRunActionList.ShowVarSelectorGUI(label + ":", variablesManager.vars, guiData.fromParameters[i].intValue, tooltip);
}
}
else
{
EditorGUILayout.HelpBox("A Variables Manager is required to pass Global Variables.", MessageType.Warning);
}
}
break;
case ParameterType.InventoryItem:
{
if (AdvGame.GetReferences() && AdvGame.GetReferences().inventoryManager)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.InventoryItem, -1, tooltip);
if (linkedID < 0)
{
InventoryManager inventoryManager = AdvGame.GetReferences().inventoryManager;
guiData.fromParameters[i].intValue = ActionRunActionList.ShowInvItemSelectorGUI(label + ":", inventoryManager.items, guiData.fromParameters[i].intValue, tooltip);
}
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager is required to pass Inventory items.", MessageType.Warning);
}
}
break;
case ParameterType.Document:
{
if (AdvGame.GetReferences() && AdvGame.GetReferences().inventoryManager)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Document, -1, tooltip);
if (linkedID < 0)
{
InventoryManager inventoryManager = AdvGame.GetReferences().inventoryManager;
guiData.fromParameters[i].intValue = ActionRunActionList.ShowDocumentSelectorGUI(label + ":", inventoryManager.documents, guiData.fromParameters[i].intValue, tooltip);
}
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager is required to pass Documents.", MessageType.Warning);
}
}
break;
case ParameterType.LocalVariable:
{
if (KickStarter.localVariables)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.LocalVariable, -1, tooltip);
if (linkedID < 0)
{
guiData.fromParameters[i].intValue = ActionRunActionList.ShowVarSelectorGUI(label + ":", KickStarter.localVariables.localVars, guiData.fromParameters[i].intValue, tooltip);
}
}
else
{
EditorGUILayout.HelpBox("A GameEngine prefab is required to pass Local Variables.", MessageType.Warning);
}
}
break;
case ParameterType.String:
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.String, -1, tooltip);
if (linkedID < 0)
{
guiData.fromParameters[i].stringValue = CustomGUILayout.TextArea(label, guiData.fromParameters[i].stringValue, string.Empty, tooltip);
}
}
break;
case ParameterType.Float:
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Float, -1, tooltip);
if (linkedID < 0)
{
guiData.fromParameters[i].floatValue = CustomGUILayout.FloatField(label + ":", guiData.fromParameters[i].floatValue, string.Empty, tooltip);
}
}
break;
case ParameterType.Integer:
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Integer, -1, tooltip);
if (linkedID < 0)
{
guiData.fromParameters[i].intValue = CustomGUILayout.IntField(label + ":", guiData.fromParameters[i].intValue, string.Empty, tooltip);
}
}
break;
case ParameterType.Vector3:
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Vector3, -1, tooltip);
if (linkedID < 0)
{
guiData.fromParameters[i].vector3Value = CustomGUILayout.Vector3Field(label + ":", guiData.fromParameters[i].vector3Value, string.Empty, tooltip);
}
}
break;
case ParameterType.Boolean:
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Boolean, -1, tooltip);
if (linkedID < 0)
{
BoolValue boolValue = BoolValue.False;
if (guiData.fromParameters[i].intValue == 1)
{
boolValue = BoolValue.True;
}
boolValue = (BoolValue)CustomGUILayout.EnumPopup(label + ":", boolValue, string.Empty, tooltip);
if (boolValue == BoolValue.True)
{
guiData.fromParameters[i].intValue = 1;
}
else
{
guiData.fromParameters[i].intValue = 0;
}
}
}
break;
case ParameterType.ComponentVariable:
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.ComponentVariable);
if (linkedID < 0)
{
guiData.fromParameters[i].variables = (Variables)EditorGUILayout.ObjectField("'" + label + "' component:", guiData.fromParameters[i].variables, typeof(Variables), true);
if (guiData.fromParameters[i].variables != null)
{
guiData.fromParameters[i].intValue = ActionRunActionList.ShowVarSelectorGUI(label + ":", guiData.fromParameters[i].variables.vars, guiData.fromParameters[i].intValue);
}
}
}
break;
default:
break;
}
if (i < guiData.parameterIDs.Count)
{
guiData.parameterIDs[i] = linkedID;
}
if (i < externalParameters.Count - 1)
{
EditorGUILayout.Space();
}
}
CustomGUILayout.EndVertical();
return(guiData);
}
/**
* <summary>Adds a ConstantID component to a GameObject, which can be a prefab or a scene-based object</summary>
* <param name = "gameObject">The GameObject to amend</param>
* <returns>The GameObject's component</returns>
*/
public static T AddConstantIDToGameObject <T> (GameObject gameObject, bool forcePrefab = false) where T : ConstantID
{
T existingComponent = gameObject.GetComponent <T>();
if (existingComponent != null)
{
if (existingComponent.constantID == 0)
{
#if NEW_PREFABS
if (IsPrefabFile(gameObject) && !IsPrefabEditing(gameObject))
{
string assetPath = AssetDatabase.GetAssetPath(gameObject);
GameObject instancedObject = PrefabUtility.LoadPrefabContents(assetPath);
instancedObject.GetComponent <ConstantID>().AssignInitialValue(true);
PrefabUtility.SaveAsPrefabAsset(instancedObject, assetPath);
PrefabUtility.UnloadPrefabContents(instancedObject);
}
else
{
existingComponent.AssignInitialValue(forcePrefab);
}
#else
existingComponent.AssignInitialValue(forcePrefab);
#endif
}
CustomSetDirty(gameObject, true);
if (IsPrefabFile(gameObject))
{
AssetDatabase.SaveAssets();
}
return(existingComponent);
}
#if NEW_PREFABS
if (UnityVersionHandler.IsPrefabFile(gameObject) && !IsPrefabEditing(gameObject))
{
string assetPath = AssetDatabase.GetAssetPath(gameObject);
GameObject instancedObject = PrefabUtility.LoadPrefabContents(assetPath);
existingComponent = instancedObject.AddComponent <T>();
existingComponent.AssignInitialValue(true);
foreach (ConstantID constantIDScript in instancedObject.GetComponents <ConstantID>())
{
if (!(constantIDScript is Remember) && !(constantIDScript is RememberTransform) && constantIDScript != existingComponent)
{
GameObject.DestroyImmediate(constantIDScript, true);
ACDebug.Log("Replaced " + gameObject.name + "'s 'ConstantID' component with '" + existingComponent.GetType().ToString() + "'", gameObject);
}
}
PrefabUtility.SaveAsPrefabAsset(instancedObject, assetPath);
PrefabUtility.UnloadPrefabContents(instancedObject);
CustomSetDirty(gameObject, true);
AssetDatabase.SaveAssets();
return(existingComponent);
}
#endif
existingComponent = gameObject.AddComponent <T>();
existingComponent.AssignInitialValue(forcePrefab);
foreach (ConstantID constantIDScript in gameObject.GetComponents <ConstantID>())
{
if (!(constantIDScript is Remember) && !(constantIDScript is RememberTransform) && constantIDScript != existingComponent)
{
GameObject.DestroyImmediate(constantIDScript, true);
ACDebug.Log("Replaced " + gameObject.name + "'s 'ConstantID' component with '" + existingComponent.GetType().ToString() + "'", gameObject);
}
}
CustomSetDirty(gameObject, true);
if (IsPrefabFile(gameObject))
{
AssetDatabase.SaveAssets();
}
return(existingComponent);
}
private void SetParametersGUI(List <ActionParameter> externalParameters, List <ActionParameter> ownParameters)
{
setParameters = EditorGUILayout.Toggle("Set parameters?", setParameters);
if (!setParameters)
{
return;
}
SyncLists(externalParameters, localParameters);
EditorGUILayout.BeginVertical("Button");
for (int i = 0; i < externalParameters.Count; i++)
{
string label = externalParameters[i].label;
int linkedID = parameterIDs[i];
localParameters[i].parameterType = externalParameters[i].parameterType;
if (externalParameters[i].parameterType == ParameterType.GameObject)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.GameObject);
if (linkedID < 0)
{
if (isAssetFile)
{
localParameters[i].gameObject = (GameObject)EditorGUILayout.ObjectField(label + ":", localParameters[i].gameObject, typeof(GameObject), true);
if (localParameters[i].gameObject != null)
{
if (!UnityVersionHandler.IsPrefabFile(localParameters[i].gameObject))
{
localParameters[i].intValue = FieldToID(localParameters[i].gameObject, localParameters[i].intValue);
localParameters[i].gameObject = IDToField(localParameters[i].gameObject, localParameters[i].intValue, true);
}
else
{
// A prefab, ask if we want to affect the prefab or the scene-based instance?
localParameters[i].gameObjectParameterReferences = (GameObjectParameterReferences)EditorGUILayout.EnumPopup("GameObject parameter:", localParameters[i].gameObjectParameterReferences);
}
}
else
{
localParameters[i].intValue = EditorGUILayout.IntField(label + " (ID #):", localParameters[i].intValue);
}
}
else
{
// Gameobject
localParameters[i].gameObject = (GameObject)EditorGUILayout.ObjectField(label + ":", localParameters[i].gameObject, typeof(GameObject), true);
localParameters[i].intValue = 0;
if (localParameters[i].gameObject != null && localParameters[i].gameObject.GetComponent <ConstantID>() == null)
{
UnityVersionHandler.AddConstantIDToGameObject <ConstantID> (localParameters[i].gameObject);
}
}
}
}
else if (externalParameters[i].parameterType == ParameterType.UnityObject)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.UnityObject);
if (linkedID < 0)
{
localParameters[i].objectValue = (Object)EditorGUILayout.ObjectField(label + ":", localParameters[i].objectValue, typeof(Object), true);
}
}
else if (externalParameters[i].parameterType == ParameterType.GlobalVariable)
{
if (AdvGame.GetReferences() && AdvGame.GetReferences().variablesManager)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.GlobalVariable);
if (linkedID < 0)
{
VariablesManager variablesManager = AdvGame.GetReferences().variablesManager;
localParameters[i].intValue = ShowVarSelectorGUI(label + ":", variablesManager.vars, localParameters[i].intValue);
}
}
else
{
EditorGUILayout.HelpBox("A Variables Manager is required to pass Global Variables.", MessageType.Warning);
}
}
else if (externalParameters[i].parameterType == ParameterType.InventoryItem)
{
if (AdvGame.GetReferences() && AdvGame.GetReferences().inventoryManager)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.InventoryItem);
if (linkedID < 0)
{
InventoryManager inventoryManager = AdvGame.GetReferences().inventoryManager;
localParameters[i].intValue = ShowInvItemSelectorGUI(label + ":", inventoryManager.items, localParameters[i].intValue);
}
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager is required to pass Inventory items.", MessageType.Warning);
}
}
else if (externalParameters[i].parameterType == ParameterType.LocalVariable)
{
if (KickStarter.localVariables)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.LocalVariable);
if (linkedID < 0)
{
localParameters[i].intValue = ShowVarSelectorGUI(label + ":", KickStarter.localVariables.localVars, localParameters[i].intValue);
}
}
else
{
EditorGUILayout.HelpBox("A GameEngine prefab is required to pass Local Variables.", MessageType.Warning);
}
}
else if (externalParameters[i].parameterType == ParameterType.String)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.String);
if (linkedID < 0)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(label + ":", GUILayout.Width(145f));
EditorStyles.textField.wordWrap = true;
localParameters[i].stringValue = EditorGUILayout.TextArea(localParameters[i].stringValue, GUILayout.MaxWidth(400f));
EditorGUILayout.EndHorizontal();
}
}
else if (externalParameters[i].parameterType == ParameterType.Float)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Float);
if (linkedID < 0)
{
localParameters[i].floatValue = EditorGUILayout.FloatField(label + ":", localParameters[i].floatValue);
}
}
else if (externalParameters[i].parameterType == ParameterType.Integer)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Integer);
if (linkedID < 0)
{
localParameters[i].intValue = EditorGUILayout.IntField(label + ":", localParameters[i].intValue);
}
}
else if (externalParameters[i].parameterType == ParameterType.Vector3)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Vector3);
if (linkedID < 0)
{
localParameters[i].vector3Value = EditorGUILayout.Vector3Field(label + ":", localParameters[i].vector3Value);
}
}
else if (externalParameters[i].parameterType == ParameterType.Boolean)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Boolean);
if (linkedID < 0)
{
BoolValue boolValue = BoolValue.False;
if (localParameters[i].intValue == 1)
{
boolValue = BoolValue.True;
}
boolValue = (BoolValue)EditorGUILayout.EnumPopup(label + ":", boolValue);
if (boolValue == BoolValue.True)
{
localParameters[i].intValue = 1;
}
else
{
localParameters[i].intValue = 0;
}
}
}
parameterIDs[i] = linkedID;
}
EditorGUILayout.EndVertical();
}
public override void OnInspectorGUI()
{
if (AdvGame.GetReferences() == null)
{
ACDebug.LogError("A References file is required - please use the Adventure Creator window to create one.");
EditorGUILayout.LabelField("No References file found!");
}
else
{
if (AdvGame.GetReferences().inventoryManager)
{
inventoryManager = AdvGame.GetReferences().inventoryManager;
}
if (AdvGame.GetReferences().cursorManager)
{
cursorManager = AdvGame.GetReferences().cursorManager;
}
if (AdvGame.GetReferences().settingsManager)
{
settingsManager = AdvGame.GetReferences().settingsManager;
}
if (Application.isPlaying)
{
if (settingsManager && _target.gameObject.layer != LayerMask.NameToLayer(settingsManager.hotspotLayer))
{
EditorGUILayout.HelpBox("Current state: OFF", MessageType.Info);
}
}
if (_target.lineID > -1)
{
EditorGUILayout.LabelField("Speech Manager ID:", _target.lineID.ToString());
}
_target.interactionSource = (AC.InteractionSource)CustomGUILayout.EnumPopup("Interaction source:", _target.interactionSource, "", "The source of the commands that are run when an option is chosen");
_target.hotspotName = CustomGUILayout.TextField("Label (if not name):", _target.hotspotName, "", "The display name, if not the GameObject's name");
bool isPronoun = !_target.canBeLowerCase;
isPronoun = CustomGUILayout.Toggle("Name is pronoun?", isPronoun, "", "If False, the name will be lower-cased when inside sentences.");
_target.canBeLowerCase = !isPronoun;
_target.highlight = (Highlight)CustomGUILayout.ObjectField <Highlight> ("Object to highlight:", _target.highlight, true, "", "The Highlight component that controls any highlighting effects associated with the Hotspot");
if (AdvGame.GetReferences().settingsManager != null && AdvGame.GetReferences().settingsManager.hotspotDrawing == ScreenWorld.WorldSpace)
{
_target.iconSortingLayer = CustomGUILayout.TextField("Icon sorting layer:", _target.iconSortingLayer, "", "The 'Sorting Layer' of the icon's SpriteRenderer");
_target.iconSortingOrder = CustomGUILayout.IntField("Icon sprite order:", _target.iconSortingOrder, "", "The 'Order in Layer' of the icon's SpriteRenderer");
}
EditorGUILayout.BeginHorizontal();
_target.centrePoint = (Transform)CustomGUILayout.ObjectField <Transform> ("Centre point (override):", _target.centrePoint, true, "", "A Transform that represents the centre of the Hotspot, if it is not physically at the same point as the Hotspot's GameObject itself");
if (_target.centrePoint == null)
{
if (GUILayout.Button("Create", autoWidth))
{
string prefabName = "Hotspot centre: " + _target.gameObject.name;
GameObject go = SceneManager.AddPrefab("Navigation", "HotspotCentre", true, false, false);
go.name = prefabName;
go.transform.position = _target.transform.position;
_target.centrePoint = go.transform;
go.transform.parent = _target.transform;
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
_target.walkToMarker = (Marker)CustomGUILayout.ObjectField <Marker> ("Walk-to Marker:", _target.walkToMarker, true, "", "The Marker that the player can optionally automatically walk to before an Interaction runs");
if (_target.walkToMarker == null)
{
if (GUILayout.Button("Create", autoWidth))
{
string prefabName = "Marker";
if (SceneSettings.IsUnity2D())
{
prefabName += "2D";
}
Marker newMarker = SceneManager.AddPrefab("Navigation", prefabName, true, false, true).GetComponent <Marker>();
newMarker.gameObject.name += (": " + _target.gameObject.name);
newMarker.transform.position = _target.transform.position;
_target.walkToMarker = newMarker;
if (UnityVersionHandler.IsPrefabFile(_target.gameObject))
{
newMarker.transform.parent = _target.transform;
}
}
}
EditorGUILayout.EndHorizontal();
_target.limitToCamera = (_Camera)CustomGUILayout.ObjectField <_Camera> ("Limit to camera:", _target.limitToCamera, true, "", "If assigned, then the Hotspot will only be interactive when the assigned _Camera is active");
EditorGUILayout.BeginHorizontal();
_target.interactiveBoundary = (InteractiveBoundary)CustomGUILayout.ObjectField <InteractiveBoundary> ("Interactive boundary:", _target.interactiveBoundary, true, "", "If assigned, then the Hotspot will only be interactive when the player is within this Trigger Collider's boundary");
if (_target.interactiveBoundary == null)
{
if (GUILayout.Button("Create", autoWidth))
{
string prefabName = "InteractiveBoundary";
if (SceneSettings.IsUnity2D())
{
prefabName += "2D";
}
InteractiveBoundary newInteractiveBoundary = SceneManager.AddPrefab("Logic", prefabName, true, false, true).GetComponent <InteractiveBoundary>();
newInteractiveBoundary.gameObject.name += (": " + _target.gameObject.name);
newInteractiveBoundary.transform.position = _target.transform.position;
_target.interactiveBoundary = newInteractiveBoundary;
if (UnityVersionHandler.IsPrefabFile(_target.gameObject))
{
newInteractiveBoundary.transform.parent = _target.transform;
}
else
{
UnityVersionHandler.PutInFolder(newInteractiveBoundary.gameObject, "_Hotspots");
}
}
}
EditorGUILayout.EndHorizontal();
_target.drawGizmos = CustomGUILayout.Toggle("Draw yellow cube?", _target.drawGizmos, "", "If True, then a Gizmo may be drawn in the Scene window at the Hotspots's position");
if (settingsManager != null && (settingsManager.interactionMethod == AC_InteractionMethod.ChooseHotspotThenInteraction || settingsManager.interactionMethod == AC_InteractionMethod.ChooseInteractionThenHotspot || settingsManager.interactionMethod == AC_InteractionMethod.CustomScript))
{
_target.oneClick = CustomGUILayout.Toggle("Single 'Use' Interaction?", _target.oneClick, "", "If True, then clicking the Hotspot will run the Hotspot's first interaction in useButtons, regardless of the Settings Manager's Interaction method");
if (_target.oneClick && settingsManager.interactionMethod == AC_InteractionMethod.CustomScript)
{
EditorGUILayout.HelpBox("The above property can be accessed by reading the Hotspot script's IsSingleInteraction() method.", MessageType.Info);
}
}
if (_target.oneClick || (settingsManager != null && settingsManager.interactionMethod == AC_InteractionMethod.ContextSensitive) || (settingsManager != null && settingsManager.interactionMethod == AC_InteractionMethod.ChooseHotspotThenInteraction && _target.oneClick))
{
if (settingsManager != null && settingsManager.interactionMethod == AC_InteractionMethod.CustomScript)
{
}
else
{
_target.doubleClickingHotspot = (DoubleClickingHotspot)CustomGUILayout.EnumPopup("Double-clicking:", _target.doubleClickingHotspot, "", "The effect that double-clicking on the Hotspot has");
}
}
if (settingsManager != null && settingsManager.playerFacesHotspots)
{
_target.playerTurnsHead = CustomGUILayout.Toggle("Players turn heads when active?", _target.playerTurnsHead, "", "If True, then the player will turn their head when the Hotspot is selected");
}
EditorGUILayout.Space();
UseInteractionGUI();
if (settingsManager == null || settingsManager.interactionMethod == AC_InteractionMethod.ContextSensitive || settingsManager.interactionMethod == AC_InteractionMethod.CustomScript)
{
EditorGUILayout.Space();
LookInteractionGUI();
}
EditorGUILayout.Space();
InvInteractionGUI();
if (KickStarter.cursorManager != null && KickStarter.cursorManager.AllowUnhandledIcons())
{
EditorGUILayout.Space();
UnhandledUseInteractionGUI();
}
EditorGUILayout.Space();
UnhandledInvInteractionGUI();
}
UnityVersionHandler.CustomSetDirty(_target);
}
protected void DrawSharedElements(ActionList _target)
{
if (UnityVersionHandler.IsPrefabFile(_target.gameObject) && _target.source == ActionListSource.InScene)
{
EditorGUILayout.HelpBox("Scene-based Actions can not live in prefabs - use ActionList assets instead.", MessageType.Info);
return;
}
int numActions = 0;
if (_target.source != ActionListSource.AssetFile)
{
numActions = _target.actions.Count;
if (numActions < 1)
{
numActions = 1;
AC.Action newAction = ActionList.GetDefaultAction();
_target.actions.Add(newAction);
}
}
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
if (_target.source == ActionListSource.AssetFile)
{
GUI.enabled = false;
}
if (GUILayout.Button("Expand all", EditorStyles.miniButtonLeft))
{
Undo.RecordObject(_target, "Expand actions");
foreach (AC.Action action in _target.actions)
{
action.isDisplayed = true;
}
}
if (GUILayout.Button("Collapse all", EditorStyles.miniButtonMid))
{
Undo.RecordObject(_target, "Collapse actions");
foreach (AC.Action action in _target.actions)
{
action.isDisplayed = false;
}
}
GUI.enabled = true;
if (GUILayout.Button("Action List Editor", EditorStyles.miniButtonMid))
{
if (_target.source == ActionListSource.AssetFile)
{
if (_target.assetFile != null)
{
ActionListEditorWindow.Init(_target.assetFile);
}
}
else
{
ActionListEditorWindow.Init(_target);
}
}
if (!Application.isPlaying)
{
GUI.enabled = false;
}
if (GUILayout.Button("Run now", EditorStyles.miniButtonRight))
{
_target.Interact();
}
GUI.enabled = true;
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
if (_target.source == ActionListSource.AssetFile)
{
return;
}
ActionListEditor.ResetList(_target);
if (actionsManager == null)
{
EditorGUILayout.HelpBox("An Actions Manager asset file must be assigned in the Game Editor Window", MessageType.Warning);
OnEnable();
return;
}
if (!actionsManager.displayActionsInInspector)
{
EditorGUILayout.HelpBox("As set by the Actions Manager, Actions are only displayed in the ActionList Editor window.", MessageType.Info);
return;
}
for (int i = 0; i < _target.actions.Count; i++)
{
if (_target.actions[i] == null)
{
ACDebug.LogWarning("An empty Action was found, and was deleted");
_target.actions.RemoveAt(i);
continue;
}
_target.actions[i].AssignParentList(_target);
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.BeginHorizontal();
int typeIndex = KickStarter.actionsManager.GetActionTypeIndex(_target.actions[i]);
string actionLabel = " (" + (i).ToString() + ") " + actionsManager.EnabledActions[typeIndex].GetFullTitle() + _target.actions[i].SetLabel();
actionLabel = actionLabel.Replace("\r\n", "");
actionLabel = actionLabel.Replace("\n", "");
actionLabel = actionLabel.Replace("\r", "");
if (actionLabel.Length > 40)
{
actionLabel = actionLabel.Substring(0, 40) + "..)";
}
_target.actions[i].isDisplayed = EditorGUILayout.Foldout(_target.actions[i].isDisplayed, actionLabel);
if (!_target.actions[i].isEnabled)
{
EditorGUILayout.LabelField("DISABLED", EditorStyles.boldLabel, GUILayout.MaxWidth(100f));
}
if (GUILayout.Button(Resource.CogIcon, GUILayout.Width(20f), GUILayout.Height(15f)))
{
ActionSideMenu(i);
}
_target.actions[i].isAssetFile = false;
EditorGUILayout.EndHorizontal();
if (_target.actions[i].isBreakPoint)
{
EditorGUILayout.HelpBox("Break point", MessageType.None);
}
if (_target.actions[i].isDisplayed)
{
GUI.enabled = _target.actions[i].isEnabled;
if (!actionsManager.DoesActionExist(_target.actions[i].GetType().ToString()))
{
EditorGUILayout.HelpBox("This Action type has been disabled in the Actions Manager", MessageType.Warning);
}
else
{
int newTypeIndex = ActionListEditor.ShowTypePopup(_target.actions[i], typeIndex);
if (newTypeIndex >= 0)
{
// Rebuild constructor if Subclass and type string do not match
ActionEnd _end = new ActionEnd();
_end.resultAction = _target.actions[i].endAction;
_end.skipAction = _target.actions[i].skipAction;
_end.linkedAsset = _target.actions[i].linkedAsset;
_end.linkedCutscene = _target.actions[i].linkedCutscene;
Undo.RecordObject(_target, "Change Action type");
_target.actions[i] = ActionListEditor.RebuildAction(_target.actions[i], newTypeIndex, _end.resultAction, _end.skipAction, _end.linkedAsset, _end.linkedCutscene);
}
if (_target.useParameters && _target.parameters != null && _target.parameters.Count > 0)
{
_target.actions[i].ShowGUI(_target.parameters);
}
else
{
_target.actions[i].ShowGUI(null);
}
}
}
if (_target.actions[i].endAction == AC.ResultAction.Skip || _target.actions[i].numSockets == 2 || _target.actions[i] is ActionCheckMultiple || _target.actions[i] is ActionParallel)
{
_target.actions[i].SkipActionGUI(_target.actions, _target.actions[i].isDisplayed);
}
GUI.enabled = true;
EditorGUILayout.EndVertical();
EditorGUILayout.Space();
}
if (GUILayout.Button("Add new action"))
{
Undo.RecordObject(_target, "Create action");
numActions += 1;
}
_target.actions = ActionListEditor.ResizeList(_target.actions, numActions);
}
public static GUIData SetParametersGUI(List <ActionParameter> externalParameters, bool isAssetFile, GUIData guiData, List <ActionParameter> ownParameters = null)
{
guiData = SyncLists(externalParameters, guiData);
EditorGUILayout.BeginVertical("Button");
for (int i = 0; i < externalParameters.Count; i++)
{
string label = externalParameters[i].label;
int linkedID = (i < guiData.parameterIDs.Count)
? guiData.parameterIDs[i]
: -1;
//guiData.fromParameters[i].ID = externalParameters[i].ID;
guiData.fromParameters[i].parameterType = externalParameters[i].parameterType;
if (externalParameters[i].parameterType == ParameterType.GameObject)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.GameObject);
if (linkedID < 0)
{
if (isAssetFile)
{
guiData.fromParameters[i].gameObject = (GameObject)EditorGUILayout.ObjectField(label + ":", guiData.fromParameters[i].gameObject, typeof(GameObject), true);
if (guiData.fromParameters[i].gameObject != null)
{
if (!UnityVersionHandler.IsPrefabFile(guiData.fromParameters[i].gameObject))
{
guiData.fromParameters[i].intValue = Action.FieldToID(guiData.fromParameters[i].gameObject, guiData.fromParameters[i].intValue, false, isAssetFile);
guiData.fromParameters[i].gameObject = Action.IDToField(guiData.fromParameters[i].gameObject, guiData.fromParameters[i].intValue, true, false, isAssetFile);
}
else
{
// A prefab, ask if we want to affect the prefab or the scene-based instance?
guiData.fromParameters[i].gameObjectParameterReferences = (GameObjectParameterReferences)EditorGUILayout.EnumPopup("GameObject parameter:", guiData.fromParameters[i].gameObjectParameterReferences);
}
}
else
{
guiData.fromParameters[i].intValue = EditorGUILayout.IntField(label + " (ID #):", guiData.fromParameters[i].intValue);
}
}
else
{
// Gameobject
guiData.fromParameters[i].gameObject = (GameObject)EditorGUILayout.ObjectField(label + ":", guiData.fromParameters[i].gameObject, typeof(GameObject), true);
guiData.fromParameters[i].intValue = 0;
if (guiData.fromParameters[i].gameObject != null && guiData.fromParameters[i].gameObject.GetComponent <ConstantID>() == null)
{
UnityVersionHandler.AddConstantIDToGameObject <ConstantID> (guiData.fromParameters[i].gameObject);
}
}
}
}
else if (externalParameters[i].parameterType == ParameterType.UnityObject)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.UnityObject);
if (linkedID < 0)
{
guiData.fromParameters[i].objectValue = (Object)EditorGUILayout.ObjectField(label + ":", guiData.fromParameters[i].objectValue, typeof(Object), true);
}
}
else if (externalParameters[i].parameterType == ParameterType.GlobalVariable)
{
if (AdvGame.GetReferences() && AdvGame.GetReferences().variablesManager)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.GlobalVariable);
if (linkedID < 0)
{
VariablesManager variablesManager = AdvGame.GetReferences().variablesManager;
guiData.fromParameters[i].intValue = ActionRunActionList.ShowVarSelectorGUI(label + ":", variablesManager.vars, guiData.fromParameters[i].intValue);
}
}
else
{
EditorGUILayout.HelpBox("A Variables Manager is required to pass Global Variables.", MessageType.Warning);
}
}
else if (externalParameters[i].parameterType == ParameterType.InventoryItem)
{
if (AdvGame.GetReferences() && AdvGame.GetReferences().inventoryManager)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.InventoryItem);
if (linkedID < 0)
{
InventoryManager inventoryManager = AdvGame.GetReferences().inventoryManager;
guiData.fromParameters[i].intValue = ActionRunActionList.ShowInvItemSelectorGUI(label + ":", inventoryManager.items, guiData.fromParameters[i].intValue);
}
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager is required to pass Inventory items.", MessageType.Warning);
}
}
else if (externalParameters[i].parameterType == ParameterType.Document)
{
if (AdvGame.GetReferences() && AdvGame.GetReferences().inventoryManager)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Document);
if (linkedID < 0)
{
InventoryManager inventoryManager = AdvGame.GetReferences().inventoryManager;
guiData.fromParameters[i].intValue = ActionRunActionList.ShowDocumentSelectorGUI(label + ":", inventoryManager.documents, guiData.fromParameters[i].intValue);
}
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager is required to pass Documents.", MessageType.Warning);
}
}
else if (externalParameters[i].parameterType == ParameterType.LocalVariable)
{
if (KickStarter.localVariables)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.LocalVariable);
if (linkedID < 0)
{
guiData.fromParameters[i].intValue = ActionRunActionList.ShowVarSelectorGUI(label + ":", KickStarter.localVariables.localVars, guiData.fromParameters[i].intValue);
}
}
else
{
EditorGUILayout.HelpBox("A GameEngine prefab is required to pass Local Variables.", MessageType.Warning);
}
}
else if (externalParameters[i].parameterType == ParameterType.String)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.String);
if (linkedID < 0)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(label + ":", GUILayout.Width(145f));
EditorStyles.textField.wordWrap = true;
guiData.fromParameters[i].stringValue = EditorGUILayout.TextArea(guiData.fromParameters[i].stringValue, GUILayout.MaxWidth(400f));
EditorGUILayout.EndHorizontal();
}
}
else if (externalParameters[i].parameterType == ParameterType.Float)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Float);
if (linkedID < 0)
{
guiData.fromParameters[i].floatValue = EditorGUILayout.FloatField(label + ":", guiData.fromParameters[i].floatValue);
}
}
else if (externalParameters[i].parameterType == ParameterType.Integer)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Integer);
if (linkedID < 0)
{
guiData.fromParameters[i].intValue = EditorGUILayout.IntField(label + ":", guiData.fromParameters[i].intValue);
}
}
else if (externalParameters[i].parameterType == ParameterType.Vector3)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Vector3);
if (linkedID < 0)
{
guiData.fromParameters[i].vector3Value = EditorGUILayout.Vector3Field(label + ":", guiData.fromParameters[i].vector3Value);
}
}
else if (externalParameters[i].parameterType == ParameterType.Boolean)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.Boolean);
if (linkedID < 0)
{
BoolValue boolValue = BoolValue.False;
if (guiData.fromParameters[i].intValue == 1)
{
boolValue = BoolValue.True;
}
boolValue = (BoolValue)EditorGUILayout.EnumPopup(label + ":", boolValue);
if (boolValue == BoolValue.True)
{
guiData.fromParameters[i].intValue = 1;
}
else
{
guiData.fromParameters[i].intValue = 0;
}
}
}
else if (externalParameters[i].parameterType == ParameterType.ComponentVariable)
{
linkedID = Action.ChooseParameterGUI(label + ":", ownParameters, linkedID, ParameterType.ComponentVariable);
if (linkedID < 0)
{
guiData.fromParameters[i].variables = (Variables)EditorGUILayout.ObjectField("'" + label + "' component:", guiData.fromParameters[i].variables, typeof(Variables), true);
if (guiData.fromParameters[i].variables != null)
{
guiData.fromParameters[i].intValue = ActionRunActionList.ShowVarSelectorGUI(label + ":", guiData.fromParameters[i].variables.vars, guiData.fromParameters[i].intValue);
}
}
}
if (i < guiData.parameterIDs.Count)
{
guiData.parameterIDs[i] = linkedID;
}
if (i < externalParameters.Count - 1)
{
EditorGUILayout.Space();
}
}
EditorGUILayout.EndVertical();
return(guiData);
}
public void ShowGUI(bool isAssetFile, bool onlyEditValues = false, bool readOnly = false)
{
if (Application.isPlaying || readOnly)
{
EditorGUILayout.LabelField("Type:", parameterType.ToString());
EditorGUILayout.LabelField("Current value:", "'" + GetLabel() + "'");
CustomGUILayout.TokenLabel("[param:" + ID.ToString() + "]");
}
else
{
if (onlyEditValues)
{
EditorGUILayout.LabelField("Type:", parameterType.ToString());
}
else
{
parameterType = (ParameterType)EditorGUILayout.EnumPopup("Type:", parameterType);
}
switch (parameterType)
{
case ParameterType.Boolean:
BoolValue boolValue = (intValue == 1) ? BoolValue.True : BoolValue.False;
boolValue = (BoolValue)EditorGUILayout.EnumPopup("Default value:", boolValue);
intValue = (boolValue == BoolValue.True) ? 1 : 0;
break;
case ParameterType.Integer:
intValue = EditorGUILayout.IntField("Default value:", intValue);
break;
case ParameterType.Float:
floatValue = EditorGUILayout.FloatField("Default value:", floatValue);
break;
case ParameterType.String:
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Default value:", GUILayout.Width(145f));
EditorStyles.textField.wordWrap = true;
stringValue = EditorGUILayout.TextArea(stringValue, GUILayout.MaxWidth(400f));
EditorGUILayout.EndHorizontal();
break;
case ParameterType.Vector3:
vector3Value = EditorGUILayout.Vector3Field("Default value:", vector3Value);
break;
case ParameterType.UnityObject:
objectValue = (Object)EditorGUILayout.ObjectField("Default value:", objectValue, typeof(Object), true);
break;
case ParameterType.Document:
if (AdvGame.GetReferences() && AdvGame.GetReferences().inventoryManager)
{
InventoryManager inventoryManager = AdvGame.GetReferences().inventoryManager;
intValue = ActionRunActionList.ShowDocumentSelectorGUI("Default value:", inventoryManager.documents, intValue);
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager is required.", MessageType.Warning);
}
break;
case ParameterType.InventoryItem:
if (AdvGame.GetReferences() && AdvGame.GetReferences().inventoryManager)
{
InventoryManager inventoryManager = AdvGame.GetReferences().inventoryManager;
intValue = ActionRunActionList.ShowInvItemSelectorGUI("Default value:", inventoryManager.items, intValue);
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager is required to pass Inventory items.", MessageType.Warning);
}
break;
case ParameterType.GlobalVariable:
if (AdvGame.GetReferences() && AdvGame.GetReferences().variablesManager)
{
VariablesManager variablesManager = AdvGame.GetReferences().variablesManager;
intValue = ActionRunActionList.ShowVarSelectorGUI("Default value:", variablesManager.vars, intValue);
}
else
{
EditorGUILayout.HelpBox("A Variables Manager is required to pass Global Variables.", MessageType.Warning);
}
break;
case ParameterType.LocalVariable:
if (isAssetFile)
{
intValue = 0;
EditorGUILayout.HelpBox("Local Variable parameters cannot have default values in ActionList Assets.", MessageType.Info);
}
else
{
if (KickStarter.localVariables)
{
intValue = ActionRunActionList.ShowVarSelectorGUI("Default value:", KickStarter.localVariables.localVars, intValue);
}
else
{
EditorGUILayout.HelpBox("A GameEngine prefab is required to pass Local Variables.", MessageType.Warning);
}
}
break;
case ParameterType.ComponentVariable:
if (isAssetFile)
{
variables = null;
intValue = 0;
EditorGUILayout.HelpBox("Component Variable parameters cannot have default values in ActionList Assets.", MessageType.Info);
}
else
{
variables = (Variables)EditorGUILayout.ObjectField("Variables component:", variables, typeof(Variables), true);
if (variables != null)
{
intValue = ActionRunActionList.ShowVarSelectorGUI("Default value:", variables.vars, intValue);
}
}
break;
case ParameterType.GameObject:
if (isAssetFile)
{
gameObject = (GameObject)EditorGUILayout.ObjectField("Default value:", gameObject, typeof(GameObject), true);
if (gameObject != null)
{
if (!UnityVersionHandler.IsPrefabFile(gameObject))
{
intValue = Action.FieldToID(gameObject, intValue, false, isAssetFile);
gameObject = Action.IDToField(gameObject, intValue, true, false, isAssetFile);
}
else
{
// A prefab, ask if we want to affect the prefab or the scene-based instance?
gameObjectParameterReferences = (GameObjectParameterReferences)EditorGUILayout.EnumPopup("GameObject parameter:", gameObjectParameterReferences);
}
}
else
{
intValue = EditorGUILayout.IntField("Default value (ID #):", intValue);
}
}
else
{
// Gameobject
gameObject = (GameObject)EditorGUILayout.ObjectField("Default value:", gameObject, typeof(GameObject), true);
intValue = 0;
if (gameObject != null && gameObject.GetComponent <ConstantID> () == null)
{
UnityVersionHandler.AddConstantIDToGameObject <ConstantID> (gameObject);
}
}
break;
default:
break;
}
CustomGUILayout.TokenLabel("[param:" + ID.ToString() + "]");
}
}
private void ShowPropertiesGUI(ActionList _target)
{
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("ActionList properties", EditorStyles.boldLabel);
_target.source = (ActionListSource)CustomGUILayout.EnumPopup("Actions source:", _target.source, "", "Where the Actions are stored");
if (_target.source == ActionListSource.AssetFile)
{
_target.assetFile = (ActionListAsset)CustomGUILayout.ObjectField <ActionListAsset> ("ActionList asset:", _target.assetFile, false, "", "The ActionList asset that stores the Actions");
if (_target.assetFile.NumParameters > 0)
{
_target.syncParamValues = CustomGUILayout.Toggle("Sync parameter values?", _target.syncParamValues, "", "If True, the ActionList asset's parameter values will be shared amongst all linked ActionLists");
}
}
_target.actionListType = (ActionListType)CustomGUILayout.EnumPopup("When running:", _target.actionListType, "", "The effect that running the Actions has on the rest of the game");
if (_target.actionListType == ActionListType.PauseGameplay)
{
_target.isSkippable = CustomGUILayout.Toggle("Is skippable?", _target.isSkippable, "", "If True, the Actions will be skipped when the user presses the 'EndCutscene' Input button");
}
_target.tagID = ShowTagUI(_target.actions.ToArray(), _target.tagID);
if (_target.source == ActionListSource.InScene)
{
_target.useParameters = CustomGUILayout.Toggle("Use parameters?", _target.useParameters, "", "If True, ActionParameters can be used to override values within the Action objects");
}
else if (_target.source == ActionListSource.AssetFile && _target.assetFile != null && !_target.syncParamValues && _target.assetFile.useParameters && !Application.isPlaying)
{
_target.useParameters = CustomGUILayout.Toggle("Set local parameter values?", _target.useParameters, "", "If True, parameter values set here will be assigned locally, and not on the ActionList asset");
}
EditorGUILayout.EndVertical();
if (_target.source == ActionListSource.InScene)
{
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Parameters", EditorStyles.boldLabel);
ShowParametersGUI(_target, null, _target.parameters);
EditorGUILayout.EndVertical();
}
else if (_target.source == ActionListSource.AssetFile && _target.assetFile != null && _target.assetFile.useParameters)
{
if (_target.syncParamValues)
{
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Parameters", EditorStyles.boldLabel);
ShowParametersGUI(null, _target.assetFile, _target.assetFile.GetParameters(), !Application.isPlaying);
EditorGUILayout.EndVertical();
}
else
{
if (_target.useParameters)
{
bool isAsset = UnityVersionHandler.IsPrefabFile(_target.gameObject);
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Local parameters", EditorStyles.boldLabel);
ShowLocalParametersGUI(_target.parameters, _target.assetFile.GetParameters(), isAsset);
EditorGUILayout.EndVertical();
}
else
{
// Use default from asset initially
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Parameters", EditorStyles.boldLabel);
if (Application.isPlaying)
{
ShowParametersGUI(_target, null, _target.parameters);
}
else
{
ShowParametersGUI(null, _target.assetFile, _target.assetFile.DefaultParameters, true);
}
EditorGUILayout.EndVertical();
}
}
}
}
