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 ShowGUI(List <ActionParameter> parameters)
{
qteType = (QTEType)EditorGUILayout.EnumPopup("QTE type:", qteType);
string _label = string.Empty;
if (qteType == QTEType.ThumbstickRotation)
{
inputNameParameterID = Action.ChooseParameterGUI("Horizontal input name:", parameters, inputNameParameterID, ParameterType.String);
if (inputNameParameterID < 0)
{
inputName = EditorGUILayout.TextField("Horizontal input name:", inputName);
}
verticalInputNameParameterID = Action.ChooseParameterGUI("Vertical input name:", parameters, verticalInputNameParameterID, ParameterType.String);
if (verticalInputNameParameterID < 0)
{
verticalInputName = EditorGUILayout.TextField("Vertical input name:", verticalInputName);
}
targetRotationsParameterID = Action.ChooseParameterGUI("# of rotations:", parameters, targetRotationsParameterID, ParameterType.Float);
if (targetRotationsParameterID < 0)
{
targetRotations = EditorGUILayout.Slider("# of rotations:", targetRotations, 0.25f, 10f);
}
rotationIsClockwise = EditorGUILayout.Toggle("Clockwise rotation?", rotationIsClockwise);
_label = "Wrong direction fails?";
}
else
{
_label = (qteType == QTEType.SingleAxis) ? "axis" : "button";
inputNameParameterID = Action.ChooseParameterGUI("Input " + _label + " name:", parameters, inputNameParameterID, ParameterType.String);
if (inputNameParameterID < 0)
{
inputName = EditorGUILayout.TextField("Input " + _label + " name:", inputName);
}
if (qteType == QTEType.SingleAxis)
{
axisThreshold = EditorGUILayout.Slider("Axis threshold:", axisThreshold, -1f, 1f);
if (axisThreshold >= 0f)
{
_label = "Negative axis fails?";
}
else if (axisThreshold < 0f)
{
_label = "Positive axis fails?";
}
if (Mathf.Approximately(axisThreshold, 0f))
{
EditorGUILayout.HelpBox("The 'Axis threshold' cannot be zero.", MessageType.Warning);
}
else if (axisThreshold > 0f)
{
EditorGUILayout.HelpBox("The QTE will be succesful when the input value is greater than the 'Axis threshold'.", MessageType.Info);
}
else if (axisThreshold < 0f)
{
EditorGUILayout.HelpBox("The QTE will be succesful when the input value is less than than the 'Axis threshold'.", MessageType.Info);
}
}
else
{
_label = "Wrong button fails?";
if (KickStarter.settingsManager != null && KickStarter.settingsManager.inputMethod == InputMethod.TouchScreen)
{
EditorGUILayout.HelpBox("If the input name field is left blank, then all screen taps will be valid.", MessageType.Info);
}
}
}
wrongKeyFails = EditorGUILayout.Toggle(_label, wrongKeyFails);
durationParameterID = Action.ChooseParameterGUI("Duration (s):", parameters, durationParameterID, ParameterType.Float);
if (durationParameterID < 0)
{
duration = EditorGUILayout.FloatField("Duration (s):", duration);
if (duration < 0f)
{
duration = 0f;
}
}
if (qteType == QTEType.ButtonMash)
{
targetPresses = EditorGUILayout.IntField("Target # of presses:", targetPresses);
doCooldown = EditorGUILayout.Toggle("Cooldown effect?", doCooldown);
if (doCooldown)
{
if (durationParameterID < 0)
{
cooldownTime = EditorGUILayout.Slider("Cooldown time (s):", cooldownTime, 0f, duration);
}
else
{
cooldownTime = EditorGUILayout.FloatField("Cooldown time (s):", cooldownTime);
if (cooldownTime < 0f)
{
cooldownTime = 0f;
}
}
}
}
else if (qteType == QTEType.HoldKey)
{
holdDuration = EditorGUILayout.Slider("Required duration (s):", holdDuration, 0f, 10f);
}
menuNameParameterID = Action.ChooseParameterGUI("Menu to display (optional):", parameters, menuNameParameterID, ParameterType.String);
if (menuNameParameterID < 0)
{
menuName = EditorGUILayout.TextField("Menu to display (optional):", menuName);
}
animateUI = EditorGUILayout.Toggle("Animate UI?", animateUI);
if (animateUI)
{
if (qteType == QTEType.SingleKeypress || qteType == QTEType.SingleAxis)
{
EditorGUILayout.HelpBox("The Menu's Canvas must have an Animator with 2 States: Win, Lose.", MessageType.Info);
}
else if (qteType == QTEType.ButtonMash)
{
EditorGUILayout.HelpBox("The Menu's Canvas must have an Animator with 3 States: Hit, Win, Lose.", MessageType.Info);
}
else if (qteType == QTEType.HoldKey)
{
EditorGUILayout.HelpBox("The Menu's Canvas must have an Animator with 2 States: Win, Lose, and 1 Trigger: Held.", MessageType.Info);
}
}
}
override public void ShowGUI(List <ActionParameter> parameters)
{
if (KickStarter.sceneSettings == null)
{
return;
}
sceneSetting = (SceneSetting)EditorGUILayout.EnumPopup("Scene setting to change:", sceneSetting);
if (sceneSetting == SceneSetting.DefaultNavMesh)
{
if (KickStarter.sceneSettings.navigationMethod == AC_NavigationMethod.meshCollider || KickStarter.sceneSettings.navigationMethod == AC_NavigationMethod.PolygonCollider)
{
if (KickStarter.sceneSettings.navigationMethod == AC_NavigationMethod.PolygonCollider)
{
changeNavMeshMethod = (ChangeNavMeshMethod)EditorGUILayout.EnumPopup("Change NavMesh method:", changeNavMeshMethod);
}
if (KickStarter.sceneSettings.navigationMethod == AC_NavigationMethod.meshCollider || changeNavMeshMethod == ChangeNavMeshMethod.ChangeNavMesh)
{
parameterID = Action.ChooseParameterGUI("New NavMesh:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
newNavMesh = null;
}
else
{
newNavMesh = (NavigationMesh)EditorGUILayout.ObjectField("New NavMesh:", newNavMesh, typeof(NavigationMesh), true);
constantID = FieldToID <NavigationMesh> (newNavMesh, constantID);
newNavMesh = IDToField <NavigationMesh> (newNavMesh, constantID, false);
}
}
else if (changeNavMeshMethod == ChangeNavMeshMethod.ChangeNumberOfHoles)
{
holeAction = (InvAction)EditorGUILayout.EnumPopup("Add or remove hole:", holeAction);
string _label = "Hole to add:";
if (holeAction == InvAction.Remove)
{
_label = "Hole to remove:";
}
parameterID = Action.ChooseParameterGUI(_label, parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
hole = null;
}
else
{
hole = (PolygonCollider2D)EditorGUILayout.ObjectField(_label, hole, typeof(PolygonCollider2D), true);
constantID = FieldToID <PolygonCollider2D> (hole, constantID);
hole = IDToField <PolygonCollider2D> (hole, constantID, false);
}
}
}
else
{
EditorGUILayout.HelpBox("This action is not compatible with the Unity Navigation pathfinding method, as set in the Scene Manager.", MessageType.Warning);
}
}
else if (sceneSetting == SceneSetting.DefaultPlayerStart)
{
parameterID = Action.ChooseParameterGUI("New default PlayerStart:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
playerStart = null;
}
else
{
playerStart = (PlayerStart)EditorGUILayout.ObjectField("New default PlayerStart:", playerStart, typeof(PlayerStart), true);
constantID = FieldToID <PlayerStart> (playerStart, constantID);
playerStart = IDToField <PlayerStart> (playerStart, constantID, false);
}
}
else if (sceneSetting == SceneSetting.SortingMap)
{
parameterID = Action.ChooseParameterGUI("New SortingMap:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
sortingMap = null;
}
else
{
sortingMap = (SortingMap)EditorGUILayout.ObjectField("New SortingMap:", sortingMap, typeof(SortingMap), true);
constantID = FieldToID <SortingMap> (sortingMap, constantID);
sortingMap = IDToField <SortingMap> (sortingMap, constantID, false);
}
}
else if (sceneSetting == SceneSetting.OnLoadCutscene)
{
parameterID = Action.ChooseParameterGUI("New OnLoad cutscene:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
cutscene = null;
}
else
{
cutscene = (Cutscene)EditorGUILayout.ObjectField("New OnLoad custscne:", cutscene, typeof(Cutscene), true);
constantID = FieldToID <Cutscene> (cutscene, constantID);
cutscene = IDToField <Cutscene> (cutscene, constantID, false);
}
}
else if (sceneSetting == SceneSetting.OnStartCutscene)
{
parameterID = Action.ChooseParameterGUI("New OnStart cutscene:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
cutscene = null;
}
else
{
cutscene = (Cutscene)EditorGUILayout.ObjectField("New OnStart cutscene:", cutscene, typeof(Cutscene), true);
constantID = FieldToID <Cutscene> (cutscene, constantID);
cutscene = IDToField <Cutscene> (cutscene, constantID, false);
}
}
AfterRunningOption();
}
override public void ShowGUI(List <ActionParameter> parameters)
{
isPlayer = EditorGUILayout.Toggle("Affect Player?", isPlayer);
if (!isPlayer)
{
charToMoveParameterID = Action.ChooseParameterGUI("Character to turn:", parameters, charToMoveParameterID, ParameterType.GameObject);
if (charToMoveParameterID >= 0)
{
charToMoveID = 0;
charToMove = null;
}
else
{
charToMove = (Char)EditorGUILayout.ObjectField("Character to turn:", charToMove, typeof(Char), true);
charToMoveID = FieldToID <Char> (charToMove, charToMoveID);
charToMove = IDToField <Char> (charToMove, charToMoveID, false);
}
facePlayer = EditorGUILayout.Toggle("Face player?", facePlayer);
}
else
{
facePlayer = false;
SettingsManager settingsManager = AdvGame.GetReferences().settingsManager;
if (faceType == CharFaceType.Body && settingsManager && settingsManager.IsInFirstPerson())
{
lookUpDown = EditorGUILayout.Toggle("FPS head tilt?", lookUpDown);
}
}
faceType = (CharFaceType)EditorGUILayout.EnumPopup("Face with:", faceType);
if (faceType == CharFaceType.Head)
{
stopLooking = EditorGUILayout.Toggle("Stop looking?", stopLooking);
}
if (facePlayer || (faceType == CharFaceType.Head && stopLooking))
{
}
else
{
faceObjectParameterID = Action.ChooseParameterGUI("Object to face:", parameters, faceObjectParameterID, ParameterType.GameObject);
if (faceObjectParameterID >= 0)
{
faceObjectID = 0;
faceObject = null;
}
else
{
faceObject = (GameObject)EditorGUILayout.ObjectField("Object to face:", faceObject, typeof(GameObject), true);
faceObjectID = FieldToID(faceObject, faceObjectID);
faceObject = IDToField(faceObject, faceObjectID, false);
}
}
if (faceType == CharFaceType.Body)
{
copyRotation = EditorGUILayout.Toggle("Use object's rotation?", copyRotation);
}
isInstant = EditorGUILayout.Toggle("Is instant?", isInstant);
if (!isInstant)
{
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
}
AfterRunningOption();
}
override public void ShowGUI(List <ActionParameter> parameters)
{
if (AdvGame.GetReferences().inventoryManager)
{
inventoryManager = AdvGame.GetReferences().inventoryManager;
}
if (inventoryManager)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
if (invParameterID == -1)
{
invNumber = -1;
}
if (inventoryManager.items.Count > 0)
{
foreach (InvItem _item in inventoryManager.items)
{
labelList.Add(_item.label);
// If an item has been removed, make sure selected variable is still valid
if (_item.id == invID)
{
invNumber = i;
}
i++;
}
if (invNumber == -1)
{
// Wasn't found (item was possibly deleted), so revert to zero
ACDebug.LogWarning("Previously chosen item no longer exists!");
invNumber = 0;
invID = 0;
}
useActive = EditorGUILayout.Toggle("Affect active container?", useActive);
if (!useActive)
{
parameterID = Action.ChooseParameterGUI("Container:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
container = null;
}
else
{
container = (Container)EditorGUILayout.ObjectField("Container:", container, typeof(Container), true);
constantID = FieldToID <Container> (container, constantID);
container = IDToField <Container> (container, constantID, false);
}
}
//
invParameterID = Action.ChooseParameterGUI("Item to check:", parameters, invParameterID, ParameterType.InventoryItem);
if (invParameterID >= 0)
{
invNumber = Mathf.Min(invNumber, inventoryManager.items.Count - 1);
invID = -1;
}
else
{
invNumber = EditorGUILayout.Popup("Item to check:", invNumber, labelList.ToArray());
invID = inventoryManager.items[invNumber].id;
}
//
if (inventoryManager.items[invNumber].canCarryMultiple)
{
doCount = EditorGUILayout.Toggle("Query count?", doCount);
if (doCount)
{
EditorGUILayout.BeginHorizontal("");
EditorGUILayout.LabelField("Count is:", GUILayout.MaxWidth(70));
intCondition = (IntCondition)EditorGUILayout.EnumPopup(intCondition);
intValue = EditorGUILayout.IntField(intValue);
if (intValue < 1)
{
intValue = 1;
}
EditorGUILayout.EndHorizontal();
}
}
else
{
doCount = false;
}
}
else
{
EditorGUILayout.LabelField("No inventory items exist!");
invID = -1;
invNumber = -1;
}
}
}
override public void ShowGUI(List <ActionParameter> parameters)
{
if (inventoryManager == null && AdvGame.GetReferences().inventoryManager)
{
inventoryManager = AdvGame.GetReferences().inventoryManager;
}
if (settingsManager == null && AdvGame.GetReferences().settingsManager)
{
settingsManager = AdvGame.GetReferences().settingsManager;
}
invCheckType = (InvCheckType)EditorGUILayout.EnumPopup("Check to make:", invCheckType);
if (invCheckType == InvCheckType.NumberOfItemsCarrying)
{
intCondition = (IntCondition)EditorGUILayout.EnumPopup("Count is:", intCondition);
intValueParameterID = Action.ChooseParameterGUI(intCondition.ToString() + ":", parameters, intValueParameterID, ParameterType.Integer);
if (intValueParameterID < 0)
{
intValue = EditorGUILayout.IntField(intCondition.ToString() + ":", intValue);
}
if (inventoryManager != null && inventoryManager.bins != null && inventoryManager.bins.Count > 0)
{
checkNumberInCategory = EditorGUILayout.Toggle("Check specific category?", checkNumberInCategory);
if (checkNumberInCategory)
{
int categoryIndex = 0;
string[] popupList = new string[inventoryManager.bins.Count];
for (int i = 0; i < inventoryManager.bins.Count; i++)
{
popupList[i] = inventoryManager.bins[i].label;
if (inventoryManager.bins[i].id == categoryIDToCheck)
{
categoryIndex = i;
}
}
categoryIndex = EditorGUILayout.Popup("Limit to category:", categoryIndex, popupList);
categoryIDToCheck = inventoryManager.bins[categoryIndex].id;
}
}
SetPlayerGUI();
return;
}
if (inventoryManager)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
if (parameterID == -1)
{
invNumber = -1;
}
if (inventoryManager.items.Count > 0)
{
foreach (InvItem _item in inventoryManager.items)
{
labelList.Add(_item.label);
// If an item has been removed, make sure selected variable is still valid
if (_item.id == invID)
{
invNumber = i;
}
i++;
}
if (invNumber == -1)
{
// Wasn't found (item was possibly deleted), so revert to zero
ACDebug.LogWarning("Previously chosen item no longer exists!");
invNumber = 0;
invID = 0;
}
//
parameterID = Action.ChooseParameterGUI("Inventory item:", parameters, parameterID, ParameterType.InventoryItem);
if (parameterID >= 0)
{
invNumber = Mathf.Min(invNumber, inventoryManager.items.Count - 1);
invID = -1;
}
else
{
invNumber = EditorGUILayout.Popup("Inventory item:", invNumber, labelList.ToArray());
invID = inventoryManager.items[invNumber].id;
}
//
if (inventoryManager.items[invNumber].canCarryMultiple)
{
doCount = EditorGUILayout.Toggle("Query count?", doCount);
if (doCount)
{
intCondition = (IntCondition)EditorGUILayout.EnumPopup("Count is:", intCondition);
intValueParameterID = Action.ChooseParameterGUI(intCondition.ToString() + ":", parameters, intValueParameterID, ParameterType.Integer);
if (intValueParameterID < 0)
{
intValue = EditorGUILayout.IntField(intCondition.ToString() + ":", intValue);
if (intValue < 1)
{
intValue = 1;
}
}
}
}
else
{
doCount = false;
}
SetPlayerGUI();
}
else
{
EditorGUILayout.LabelField("No inventory items exist!");
invID = -1;
invNumber = -1;
}
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager must be assigned for this Action to work", MessageType.Warning);
}
}
public override void ShowGUI(List <ActionParameter> parameters)
{
if (KickStarter.settingsManager != null)
{
if (KickStarter.settingsManager.playerSwitching == PlayerSwitching.DoNotAllow)
{
EditorGUILayout.HelpBox("This Action requires Player Switching to be allowed, as set in the Settings Manager.", MessageType.Info);
return;
}
if (KickStarter.settingsManager.players.Count == 0)
{
EditorGUILayout.HelpBox("No players are defined in the Settings Manager.", MessageType.Warning);
return;
}
playerIDParameterID = Action.ChooseParameterGUI("New Player ID:", parameters, playerIDParameterID, ParameterType.Integer);
if (playerIDParameterID == -1)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
int playerNumber = -1;
foreach (PlayerPrefab playerPrefab in KickStarter.settingsManager.players)
{
if (playerPrefab.playerOb != null)
{
labelList.Add(playerPrefab.playerOb.name);
}
else
{
labelList.Add("(Undefined prefab)");
}
// If a player has been removed, make sure selected player is still valid
if (playerPrefab.ID == playerID)
{
playerNumber = i;
}
i++;
}
if (playerNumber == -1)
{
// Wasn't found (item was possibly deleted), so revert to zero
if (playerID > 0)
{
LogWarning("Previously chosen Player no longer exists!");
}
playerNumber = 0;
playerID = 0;
}
playerNumber = EditorGUILayout.Popup("Player:", playerNumber, labelList.ToArray());
playerID = KickStarter.settingsManager.players[playerNumber].ID;
}
moveToCurrentScene = EditorGUILayout.Toggle("Move to current scene?", moveToCurrentScene);
if (moveToCurrentScene)
{
teleportPlayerStartMethod = (TeleportPlayerStartMethod)EditorGUILayout.EnumPopup("PlayerStart:", teleportPlayerStartMethod);
if (teleportPlayerStartMethod == TeleportPlayerStartMethod.EnteredHere)
{
newTransformParameterID = Action.ChooseParameterGUI("New PlayerStart:", parameters, newTransformParameterID, ParameterType.GameObject);
if (newTransformParameterID >= 0)
{
newTransformConstantID = 0;
newTransform = null;
}
else
{
newTransform = (PlayerStart)EditorGUILayout.ObjectField("New PlayerStart:", newTransform, typeof(PlayerStart), true);
newTransformConstantID = FieldToID(newTransform, newTransformConstantID);
newTransform = IDToField(newTransform, newTransformConstantID, true);
}
}
}
else
{
chooseSceneBy = (ChooseSceneBy)EditorGUILayout.EnumPopup("Choose scene by:", chooseSceneBy);
switch (chooseSceneBy)
{
case ChooseSceneBy.Number:
newSceneIndex = EditorGUILayout.IntField("New scene index:", newSceneIndex);
break;
case ChooseSceneBy.Name:
newSceneName = EditorGUILayout.TextField("New scene name:", newSceneName);
break;
default:
break;
}
teleportPlayerStartMethod = (TeleportPlayerStartMethod)EditorGUILayout.EnumPopup("PlayerStart:", teleportPlayerStartMethod);
if (teleportPlayerStartMethod == TeleportPlayerStartMethod.EnteredHere)
{
newTransformParameterID = -1;
newTransform = (PlayerStart)EditorGUILayout.ObjectField("New PlayerStart:", newTransform, typeof(PlayerStart), true);
newTransformConstantID = FieldToID(newTransform, newTransformConstantID, true);
newTransform = IDToField(newTransform, newTransformConstantID, true);
}
}
}
else
{
EditorGUILayout.HelpBox("No Settings Manager assigned!", MessageType.Warning);
}
AfterRunningOption();
}
public override void ActionCharAnimGUI(ActionCharAnim action, List <ActionParameter> parameters = null)
{
#if UNITY_EDITOR
action.method = (ActionCharAnim.AnimMethodChar)EditorGUILayout.EnumPopup("Method:", action.method);
if (action.method == ActionCharAnim.AnimMethodChar.PlayCustom)
{
action.clip2DParameterID = Action.ChooseParameterGUI("Clip:", parameters, action.clip2DParameterID, ParameterType.String);
if (action.clip2DParameterID < 0)
{
action.clip2D = EditorGUILayout.TextField("Clip:", action.clip2D);
}
action.includeDirection = EditorGUILayout.Toggle("Add directional suffix?", action.includeDirection);
if (action.animChar && action.animChar.talkingAnimation == TalkingAnimation.Standard && action.animChar.separateTalkingLayer)
{
action.hideHead = EditorGUILayout.Toggle("Hide head?", action.hideHead);
if (action.hideHead)
{
EditorGUILayout.HelpBox("The head layer will play '" + hideHeadClip + "' for the duration.", MessageType.Info);
}
}
action.layerInt = EditorGUILayout.IntField("Mecanim layer:", action.layerInt);
action.fadeTime = EditorGUILayout.Slider("Transition time:", action.fadeTime, 0f, 1f);
action.willWait = EditorGUILayout.Toggle("Wait until finish?", action.willWait);
if (action.willWait)
{
action.idleAfter = EditorGUILayout.Toggle("Return to idle after?", action.idleAfter);
}
}
else if (action.method == ActionCharAnim.AnimMethodChar.StopCustom)
{
EditorGUILayout.HelpBox("This Action does not work for Sprite-based characters.", MessageType.Info);
}
else if (action.method == ActionCharAnim.AnimMethodChar.SetStandard)
{
action.standard = (AnimStandard)EditorGUILayout.EnumPopup("Change:", action.standard);
action.clip2DParameterID = Action.ChooseParameterGUI("Clip:", parameters, action.clip2DParameterID, ParameterType.String);
if (action.clip2DParameterID < 0)
{
action.clip2D = EditorGUILayout.TextField("Clip:", action.clip2D);
}
if (action.standard == AnimStandard.Walk || action.standard == AnimStandard.Run)
{
action.changeSound = EditorGUILayout.Toggle("Change sound?", action.changeSound);
if (action.changeSound)
{
action.newSoundParameterID = Action.ChooseParameterGUI("New sound:", parameters, action.newSoundParameterID, ParameterType.UnityObject);
if (action.newSoundParameterID < 0)
{
action.newSound = (AudioClip)EditorGUILayout.ObjectField("New sound:", action.newSound, typeof(AudioClip), false);
}
}
action.changeSpeed = EditorGUILayout.Toggle("Change speed?", action.changeSpeed);
if (action.changeSpeed)
{
action.newSpeedParameterID = Action.ChooseParameterGUI("New speed:", parameters, action.newSpeedParameterID, ParameterType.Float);
if (action.newSpeedParameterID < 0)
{
action.newSpeed = EditorGUILayout.FloatField("New speed:", action.newSpeed);
}
}
}
}
else if (action.method == ActionCharAnim.AnimMethodChar.ResetToIdle)
{
action.idleAfterCustom = EditorGUILayout.Toggle("Wait for animation to finish?", action.idleAfterCustom);
}
if (GUI.changed && action != null)
{
EditorUtility.SetDirty(action);
}
#endif
}
override public void ShowGUI(List <ActionParameter> parameters)
{
movieClipType = (MovieClipType)EditorGUILayout.EnumPopup("Play clip:", movieClipType);
if (movieClipType == MovieClipType.VideoPlayer)
{
#if UNITY_5_6_OR_NEWER && !UNITY_SWITCH
videoPlayerParameterID = Action.ChooseParameterGUI("Video player:", parameters, videoPlayerParameterID, ParameterType.GameObject);
if (videoPlayerParameterID >= 0)
{
videoPlayerConstantID = 0;
videoPlayer = null;
}
else
{
videoPlayer = (VideoPlayer)EditorGUILayout.ObjectField("Video player:", videoPlayer, typeof(VideoPlayer), true);
videoPlayerConstantID = FieldToID <VideoPlayer> (videoPlayer, videoPlayerConstantID);
videoPlayer = IDToField <VideoPlayer> (videoPlayer, videoPlayerConstantID, false);
}
movieMaterialMethod = (MovieMaterialMethod)EditorGUILayout.EnumPopup("Method:", movieMaterialMethod);
if (movieMaterialMethod == MovieMaterialMethod.PlayMovie)
{
#if UNITY_WEBGL
movieURLParameterID = Action.ChooseParameterGUI("Movie URL:", parameters, movieURLParameterID, ParameterType.String);
if (movieURLParameterID < 0)
{
movieURL = EditorGUILayout.TextField("Movie URL:", movieURL);
}
#else
newClip = (VideoClip)EditorGUILayout.ObjectField("New Clip (optional):", newClip, typeof(VideoClip), true);
#endif
prepareOnly = EditorGUILayout.Toggle("Prepare only?", prepareOnly);
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
if (willWait && !prepareOnly)
{
pauseWithGame = EditorGUILayout.Toggle("Pause when game does?", pauseWithGame);
canSkip = EditorGUILayout.Toggle("Player can skip?", canSkip);
if (canSkip)
{
skipKey = EditorGUILayout.TextField("Skip with Input Button:", skipKey);
}
}
}
#elif UNITY_SWITCH
EditorGUILayout.HelpBox("This option not available on Switch.", MessageType.Info);
#else
EditorGUILayout.HelpBox("This option is only available when using Unity 5.6 or later.", MessageType.Info);
#endif
AfterRunningOption();
return;
}
#if (UNITY_IOS || UNITY_ANDROID || UNITY_WP8 || UNITY_TVOS)
if (movieClipType == MovieClipType.OnMaterial)
{
EditorGUILayout.HelpBox("This option is not available on the current platform.", MessageType.Info);
}
else
{
filePath = EditorGUILayout.TextField("Path to clip file:", filePath);
canSkip = EditorGUILayout.Toggle("Player can skip?", canSkip);
EditorGUILayout.HelpBox("The clip must be placed in a folder named 'StreamingAssets'.", MessageType.Info);
}
#elif UNITY_STANDALONE && (UNITY_5 || UNITY_2017_1_OR_NEWER || UNITY_PRO_LICENSE) && !UNITY_2017_2_OR_NEWER
movieClipParameterID = Action.ChooseParameterGUI("Movie clip:", parameters, movieClipParameterID, ParameterType.UnityObject);
if (movieClipParameterID < 0)
{
movieClip = (MovieTexture)EditorGUILayout.ObjectField("Movie clip:", movieClip, typeof(MovieTexture), false);
}
if (movieClipType == MovieClipType.OnMaterial)
{
movieMaterialMethod = (MovieMaterialMethod)EditorGUILayout.EnumPopup("Method:", movieMaterialMethod);
string label = "Material to play on:";
if (movieMaterialMethod == MovieMaterialMethod.PauseMovie)
{
label = "Material to pause:";
}
else if (movieMaterialMethod == MovieMaterialMethod.StopMovie)
{
label = "Material to stop:";
}
materialParameterID = Action.ChooseParameterGUI(label, parameters, materialParameterID, ParameterType.UnityObject);
if (materialParameterID < 0)
{
material = (Material)EditorGUILayout.ObjectField(label, material, typeof(Material), true);
}
}
if (movieClipType == MovieClipType.OnMaterial && movieMaterialMethod != MovieMaterialMethod.PlayMovie)
{
}
else
{
includeAudio = EditorGUILayout.Toggle("Include audio?", includeAudio);
if (includeAudio)
{
sound = (Sound)EditorGUILayout.ObjectField("'Sound' to play audio:", sound, typeof(Sound), true);
soundID = FieldToID(sound, soundID);
sound = IDToField(sound, soundID, false);
}
if (movieClipType == MovieClipType.OnMaterial && movieMaterialMethod == MovieMaterialMethod.PlayMovie)
{
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
}
if (movieClipType == MovieClipType.FullScreen || willWait)
{
canSkip = EditorGUILayout.Toggle("Player can skip?", canSkip);
if (canSkip)
{
skipKey = EditorGUILayout.TextField("Skip with Input Button:", skipKey);
}
}
}
#else
EditorGUILayout.HelpBox("On standalone, this Action is only available in Unity 5 or Unity Pro.", MessageType.Warning);
#endif
AfterRunningOption();
}
public override void ActionCharAnimGUI(ActionCharAnim action, List <ActionParameter> parameters = null)
{
#if UNITY_EDITOR
action.method = (ActionCharAnim.AnimMethodChar)EditorGUILayout.EnumPopup("Method:", action.method);
if (action.method == ActionCharAnim.AnimMethodChar.PlayCustom)
{
action.clip2DParameterID = Action.ChooseParameterGUI("Clip:", parameters, action.clip2DParameterID, ParameterType.String);
if (action.clip2DParameterID < 0)
{
action.clip2D = EditorGUILayout.TextField("Clip:", action.clip2D);
}
action.includeDirection = EditorGUILayout.Toggle("Add directional suffix?", action.includeDirection);
action.playMode = (AnimPlayMode)EditorGUILayout.EnumPopup("Play mode:", action.playMode);
if (action.playMode == AnimPlayMode.Loop)
{
action.willWait = false;
}
else
{
action.willWait = EditorGUILayout.Toggle("Wait until finish?", action.willWait);
}
action.layer = AnimLayer.Base;
}
else if (action.method == ActionCharAnim.AnimMethodChar.StopCustom)
{
EditorGUILayout.HelpBox("This Action does not work for Sprite-based characters.", MessageType.Info);
}
else if (action.method == ActionCharAnim.AnimMethodChar.SetStandard)
{
action.clip2DParameterID = Action.ChooseParameterGUI("Clip:", parameters, action.clip2DParameterID, ParameterType.String);
if (action.clip2DParameterID < 0)
{
action.clip2D = EditorGUILayout.TextField("Clip:", action.clip2D);
}
action.standard = (AnimStandard)EditorGUILayout.EnumPopup("Change:", action.standard);
if (action.standard == AnimStandard.Walk || action.standard == AnimStandard.Run)
{
action.changeSound = EditorGUILayout.Toggle("Change sound?", action.changeSound);
if (action.changeSound)
{
action.newSoundParameterID = Action.ChooseParameterGUI("New sound:", parameters, action.newSoundParameterID, ParameterType.UnityObject);
if (action.newSoundParameterID < 0)
{
action.newSound = (AudioClip)EditorGUILayout.ObjectField("New sound:", action.newSound, typeof(AudioClip), false);
}
}
action.changeSpeed = EditorGUILayout.Toggle("Change speed?", action.changeSpeed);
if (action.changeSpeed)
{
action.newSpeed = EditorGUILayout.FloatField("New speed:", action.newSpeed);
}
}
}
if (GUI.changed)
{
EditorUtility.SetDirty(action);
}
#endif
}
public override void ShowGUI(List <ActionParameter> parameters)
{
#if (UNITY_IOS || UNITY_ANDROID || UNITY_WP8 || UNITY_TVOS)
movieClipType = (MovieClipType)EditorGUILayout.EnumPopup("Play clip:", movieClipType);
#else
movieClipType = MovieClipType.VideoPlayer;
#endif
if (movieClipType == MovieClipType.VideoPlayer)
{
#if ALLOW_VIDEO
videoPlayerParameterID = Action.ChooseParameterGUI("Video player:", parameters, videoPlayerParameterID, ParameterType.GameObject);
if (videoPlayerParameterID >= 0)
{
videoPlayerConstantID = 0;
videoPlayer = null;
}
else
{
videoPlayer = (VideoPlayer)EditorGUILayout.ObjectField("Video player:", videoPlayer, typeof(VideoPlayer), true);
videoPlayerConstantID = FieldToID <VideoPlayer> (videoPlayer, videoPlayerConstantID);
videoPlayer = IDToField <VideoPlayer> (videoPlayer, videoPlayerConstantID, false);
}
movieMaterialMethod = (MovieMaterialMethod)EditorGUILayout.EnumPopup("Method:", movieMaterialMethod);
if (movieMaterialMethod == MovieMaterialMethod.PlayMovie)
{
#if UNITY_WEBGL
movieURLParameterID = Action.ChooseParameterGUI("Movie URL:", parameters, movieURLParameterID, ParameterType.String);
if (movieURLParameterID < 0)
{
movieURL = EditorGUILayout.TextField("Movie URL:", movieURL);
}
#else
newClip = (VideoClip)EditorGUILayout.ObjectField("New Clip (optional):", newClip, typeof(VideoClip), true);
#endif
prepareOnly = EditorGUILayout.Toggle("Prepare only?", prepareOnly);
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
if (willWait && !prepareOnly)
{
pauseWithGame = EditorGUILayout.Toggle("Pause when game does?", pauseWithGame);
canSkip = EditorGUILayout.Toggle("Player can skip?", canSkip);
if (canSkip)
{
skipKey = EditorGUILayout.TextField("Skip with Input Button:", skipKey);
}
}
}
#elif UNITY_SWITCH
EditorGUILayout.HelpBox("This option not available on Switch.", MessageType.Info);
#else
EditorGUILayout.HelpBox("This option is only available when using Unity 5.6 or later.", MessageType.Info);
#endif
AfterRunningOption();
return;
}
#if (UNITY_IOS || UNITY_ANDROID || UNITY_WP8 || UNITY_TVOS)
if (movieClipType == MovieClipType.OnMaterial)
{
EditorGUILayout.HelpBox("This option is not available on the current platform.", MessageType.Info);
}
else
{
filePath = EditorGUILayout.TextField("Path to clip file:", filePath);
canSkip = EditorGUILayout.Toggle("Player can skip?", canSkip);
EditorGUILayout.HelpBox("The clip must be placed in a folder named 'StreamingAssets'.", MessageType.Info);
}
#endif
AfterRunningOption();
}
override public void ShowGUI(List <ActionParameter> parameters)
{
bool showWaitOption = false;
returnToLast = EditorGUILayout.Toggle("Return to last gameplay?", returnToLast);
if (!returnToLast)
{
parameterID = Action.ChooseParameterGUI("New camera:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
linkedCamera = null;
}
else
{
linkedCamera = (_Camera)EditorGUILayout.ObjectField("New camera:", linkedCamera, typeof(_Camera), true);
constantID = FieldToID <_Camera> (linkedCamera, constantID);
linkedCamera = IDToField <_Camera> (linkedCamera, constantID, true);
}
if (linkedCamera && linkedCamera is GameCameraAnimated)
{
GameCameraAnimated animatedCamera = (GameCameraAnimated)linkedCamera;
if (animatedCamera.animatedCameraType == AnimatedCameraType.PlayWhenActive && transitionTime <= 0f)
{
showWaitOption = true;
}
}
}
if (linkedCamera is GameCamera25D && !returnToLast)
{
transitionTime = 0f;
}
else
{
transitionTimeParameterID = Action.ChooseParameterGUI("Transition time (s):", parameters, transitionTimeParameterID, ParameterType.Float);
if (transitionTimeParameterID < 0)
{
transitionTime = EditorGUILayout.FloatField("Transition time (s):", transitionTime);
}
if (transitionTime > 0f)
{
moveMethod = (MoveMethod)EditorGUILayout.EnumPopup("Move method:", moveMethod);
showWaitOption = true;
if (moveMethod == MoveMethod.CustomCurve)
{
timeCurve = EditorGUILayout.CurveField("Time curve:", timeCurve);
}
retainPreviousSpeed = EditorGUILayout.Toggle("Smooth transition out?", retainPreviousSpeed);
}
}
if (showWaitOption)
{
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
}
AfterRunningOption();
}
private int ShowVarGUI(List <ActionParameter> parameters, List <GVar> _vars, int ID, bool changeID)
{
VariableType showType = VariableType.Boolean;
if (changeID)
{
if (_vars != null && _vars.Count > 0)
{
ID = ShowVarSelectorGUI(_vars, ID, "Variable:");
variableNumber = Mathf.Min(variableNumber, _vars.Count - 1);
getVarMethod = (GetVarMethod)EditorGUILayout.EnumPopup("Compare with:", getVarMethod);
showType = _vars[variableNumber].type;
}
else
{
EditorGUILayout.HelpBox("No variables exist!", MessageType.Info);
ID = -1;
variableNumber = -1;
return(ID);
}
placeholderType = showType;
}
else
{
showType = placeholderType;
}
switch (showType)
{
case VariableType.Boolean:
boolCondition = (BoolCondition)EditorGUILayout.EnumPopup("Condition:", boolCondition);
if (getVarMethod == GetVarMethod.EnteredValue)
{
checkParameterID = Action.ChooseParameterGUI("Boolean:", parameters, checkParameterID, ParameterType.Boolean);
if (checkParameterID < 0)
{
boolValue = (BoolValue)EditorGUILayout.EnumPopup("Boolean:", boolValue);
}
}
break;
case VariableType.Integer:
intCondition = (IntCondition)EditorGUILayout.EnumPopup("Condition:", intCondition);
if (getVarMethod == GetVarMethod.EnteredValue)
{
checkParameterID = Action.ChooseParameterGUI("Integer:", parameters, checkParameterID, ParameterType.Integer);
if (checkParameterID < 0)
{
intValue = EditorGUILayout.IntField("Integer:", intValue);
}
}
break;
case VariableType.Float:
intCondition = (IntCondition)EditorGUILayout.EnumPopup("Condition:", intCondition);
if (getVarMethod == GetVarMethod.EnteredValue)
{
checkParameterID = Action.ChooseParameterGUI("Float:", parameters, checkParameterID, ParameterType.Float);
if (checkParameterID < 0)
{
floatValue = EditorGUILayout.FloatField("Float:", floatValue);
}
}
break;
case VariableType.PopUp:
intCondition = (IntCondition)EditorGUILayout.EnumPopup("Condition:", intCondition);
if (getVarMethod == GetVarMethod.EnteredValue)
{
checkParameterID = Action.ChooseParameterGUI("Value:", parameters, checkParameterID, ParameterType.Integer);
if (checkParameterID < 0)
{
if (changeID && _vars != null && _vars.Count > variableNumber)
{
string[] popUpLabels = _vars[variableNumber].GenerateEditorPopUpLabels();
intValue = EditorGUILayout.Popup("Value:", intValue, popUpLabels);
placeholderPopUpLabelDataID = _vars[variableNumber].popUpID;
}
else if (!changeID && AdvGame.GetReferences().variablesManager != null)
{
// Parameter override
placeholderPopUpLabelDataID = AdvGame.GetReferences().variablesManager.ShowPlaceholderPresetData(placeholderPopUpLabelDataID);
PopUpLabelData popUpLabelData = AdvGame.GetReferences().variablesManager.GetPopUpLabelData(placeholderPopUpLabelDataID);
if (popUpLabelData != null && placeholderPopUpLabelDataID > 0)
{
// Show placeholder labels
intValue = EditorGUILayout.Popup("Index value:", intValue, popUpLabelData.GenerateEditorPopUpLabels());
}
else
{
intValue = EditorGUILayout.IntField("Index value:", intValue);
}
}
else
{
intValue = EditorGUILayout.IntField("Index value:", intValue);
}
}
}
break;
case VariableType.String:
boolCondition = (BoolCondition)EditorGUILayout.EnumPopup("Condition:", boolCondition);
if (getVarMethod == GetVarMethod.EnteredValue)
{
checkParameterID = Action.ChooseParameterGUI("String:", parameters, checkParameterID, ParameterType.String);
if (checkParameterID < 0)
{
stringValue = EditorGUILayout.TextField("String:", stringValue);
}
}
checkCase = EditorGUILayout.Toggle("Case-sensitive?", checkCase);
break;
case VariableType.Vector3:
vectorCondition = (VectorCondition)EditorGUILayout.EnumPopup("Condition:", vectorCondition);
if (getVarMethod == GetVarMethod.EnteredValue)
{
if (vectorCondition == VectorCondition.MagnitudeGreaterThan)
{
checkParameterID = Action.ChooseParameterGUI("Float:", parameters, checkParameterID, ParameterType.Float);
if (checkParameterID < 0)
{
floatValue = EditorGUILayout.FloatField("Float:", floatValue);
}
}
else if (vectorCondition == VectorCondition.EqualTo)
{
checkParameterID = Action.ChooseParameterGUI("Vector3:", parameters, checkParameterID, ParameterType.Vector3);
if (checkParameterID < 0)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Vector3:", GUILayout.MaxWidth(60f));
vector3Value = EditorGUILayout.Vector3Field("", vector3Value);
EditorGUILayout.EndHorizontal();
}
}
}
break;
default:
break;
}
if (getVarMethod == GetVarMethod.GlobalVariable)
{
if (AdvGame.GetReferences().variablesManager == null || AdvGame.GetReferences().variablesManager.vars == null || AdvGame.GetReferences().variablesManager.vars.Count == 0)
{
EditorGUILayout.HelpBox("No Global variables exist!", MessageType.Info);
}
else
{
checkParameterID = Action.ChooseParameterGUI("Global variable:", parameters, checkParameterID, ParameterType.GlobalVariable);
if (checkParameterID < 0)
{
compareVariableID = ShowVarSelectorGUI(AdvGame.GetReferences().variablesManager.vars, compareVariableID, "Global variable:");
}
}
}
else if (getVarMethod == GetVarMethod.LocalVariable)
{
if (localVariables == null || localVariables.localVars == null || localVariables.localVars.Count == 0)
{
EditorGUILayout.HelpBox("No Local variables exist!", MessageType.Info);
}
else
{
checkParameterID = Action.ChooseParameterGUI("Local variable:", parameters, checkParameterID, ParameterType.LocalVariable);
if (checkParameterID < 0)
{
compareVariableID = ShowVarSelectorGUI(localVariables.localVars, compareVariableID, "Local variable:");
}
}
}
else if (getVarMethod == GetVarMethod.ComponentVariable)
{
checkParameterID = Action.ChooseParameterGUI("Component variable:", parameters, checkParameterID, ParameterType.ComponentVariable);
if (checkParameterID < 0)
{
compareVariables = (Variables)EditorGUILayout.ObjectField("Component", compareVariables, typeof(Variables), true);
compareVariablesConstantID = FieldToID <Variables> (compareVariables, compareVariablesConstantID);
compareVariables = IDToField <Variables> (compareVariables, compareVariablesConstantID, false);
if (compareVariables != null)
{
compareVariableID = ShowVarSelectorGUI(compareVariables.vars, compareVariableID, "Component variable:");
}
}
}
return(ID);
}
override public void ShowGUI(List <ActionParameter> parameters)
{
location = (VariableLocation)EditorGUILayout.EnumPopup("Source:", location);
if (isAssetFile && getVarMethod == GetVarMethod.LocalVariable)
{
EditorGUILayout.HelpBox("Local Variables cannot be referenced by Asset-based Actions.", MessageType.Warning);
return;
}
switch (location)
{
case VariableLocation.Global:
if (AdvGame.GetReferences().variablesManager)
{
VariablesManager variablesManager = AdvGame.GetReferences().variablesManager;
parameterID = Action.ChooseParameterGUI("Variable:", parameters, parameterID, ParameterType.GlobalVariable);
if (parameterID >= 0)
{
placeholderType = (VariableType)EditorGUILayout.EnumPopup("Placeholder type:", placeholderType);
variableID = ShowVarGUI(parameters, variablesManager.vars, variableID, false);
}
else
{
variableID = ShowVarGUI(parameters, variablesManager.vars, variableID, true);
}
}
break;
case VariableLocation.Local:
if (localVariables != null)
{
parameterID = Action.ChooseParameterGUI("Variable:", parameters, parameterID, ParameterType.LocalVariable);
if (parameterID >= 0)
{
placeholderType = (VariableType)EditorGUILayout.EnumPopup("Placeholder type:", placeholderType);
variableID = ShowVarGUI(parameters, localVariables.localVars, variableID, false);
}
else
{
variableID = ShowVarGUI(parameters, localVariables.localVars, variableID, true);
}
}
else
{
EditorGUILayout.HelpBox("No 'Local Variables' component found in the scene. Please add an AC GameEngine object from the Scene Manager.", MessageType.Info);
}
break;
case VariableLocation.Component:
parameterID = Action.ChooseParameterGUI("Variable:", parameters, parameterID, ParameterType.ComponentVariable);
if (parameterID >= 0)
{
placeholderType = (VariableType)EditorGUILayout.EnumPopup("Placeholder type:", placeholderType);
variableID = ShowVarGUI(parameters, (variables != null) ? variables.vars : null, variableID, false);
}
else
{
variables = (Variables)EditorGUILayout.ObjectField("Component:", variables, typeof(Variables), true);
variablesConstantID = FieldToID <Variables> (variables, variablesConstantID);
variables = IDToField <Variables> (variables, variablesConstantID, false);
if (variables != null)
{
variableID = ShowVarGUI(parameters, variables.vars, variableID, true);
}
}
break;
}
}
public override void ShowGUI(List <ActionParameter> parameters)
{
if (AdvGame.GetReferences() && AdvGame.GetReferences().settingsManager)
{
parameterID = Action.ChooseParameterGUI("Hotspot to change:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
hotspot = null;
}
else
{
hotspot = (Hotspot)EditorGUILayout.ObjectField("Hotspot to change:", hotspot, typeof(Hotspot), true);
constantID = FieldToID <Hotspot> (hotspot, constantID);
hotspot = IDToField <Hotspot> (hotspot, constantID, false);
}
interactionType = (InteractionType)EditorGUILayout.EnumPopup("Interaction to change:", interactionType);
if ((!isAssetFile && hotspot != null) || isAssetFile)
{
switch (interactionType)
{
case InteractionType.Use:
if (hotspot == null)
{
number = EditorGUILayout.IntField("Use interaction:", number);
}
else if (AdvGame.GetReferences().cursorManager)
{
// Multiple use interactions
if (hotspot.useButtons.Count > 0 && hotspot.provideUseInteraction)
{
List <string> labelList = new List <string> ();
foreach (AC.Button button in hotspot.useButtons)
{
labelList.Add(hotspot.useButtons.IndexOf(button) + ": " + AdvGame.GetReferences().cursorManager.GetLabelFromID(button.iconID, 0));
}
number = EditorGUILayout.Popup("Use interaction:", number, labelList.ToArray());
}
else
{
EditorGUILayout.HelpBox("No 'Use' interactions defined!", MessageType.Info);
}
}
else
{
EditorGUILayout.HelpBox("A Cursor Manager is required.", MessageType.Warning);
}
break;
case InteractionType.Examine:
if (hotspot != null && !hotspot.provideLookInteraction)
{
EditorGUILayout.HelpBox("No 'Examine' interaction defined!", MessageType.Info);
}
break;
case InteractionType.Inventory:
if (hotspot == null)
{
number = EditorGUILayout.IntField("Inventory interaction:", number);
}
else if (AdvGame.GetReferences().inventoryManager)
{
if (hotspot.invButtons.Count > 0 && hotspot.provideInvInteraction)
{
List <string> labelList = new List <string> ();
foreach (AC.Button button in hotspot.invButtons)
{
labelList.Add(hotspot.invButtons.IndexOf(button) + ": " + AdvGame.GetReferences().inventoryManager.GetLabel(button.invID));
}
number = EditorGUILayout.Popup("Inventory interaction:", number, labelList.ToArray());
}
else
{
EditorGUILayout.HelpBox("No 'Inventory' interactions defined!", MessageType.Info);
}
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager is required.", MessageType.Warning);
}
break;
}
}
changeType = (ChangeType)EditorGUILayout.EnumPopup("Change to make:", changeType);
}
else
{
EditorGUILayout.HelpBox("A Settings Manager is required for this Action.", MessageType.Warning);
}
AfterRunningOption();
}
override public void ShowGUI(List <ActionParameter> parameters)
{
isPlayer = EditorGUILayout.Toggle("Move Player?", isPlayer);
if (!isPlayer)
{
parameterID = Action.ChooseParameterGUI("Moveable object:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
linkedProp = null;
}
else
{
linkedProp = (Moveable)EditorGUILayout.ObjectField("Moveable object:", linkedProp, typeof(Moveable), true);
constantID = FieldToID <Moveable> (linkedProp, constantID);
linkedProp = IDToField <Moveable> (linkedProp, constantID, false);
}
}
EditorGUILayout.BeginHorizontal();
transformType = (TransformType)EditorGUILayout.EnumPopup(transformType);
if (transformType != TransformType.CopyMarker)
{
toBy = (ToBy)EditorGUILayout.EnumPopup(toBy);
}
EditorGUILayout.EndHorizontal();
if (transformType == TransformType.CopyMarker)
{
markerParameterID = Action.ChooseParameterGUI("Marker:", parameters, markerParameterID, ParameterType.GameObject);
if (markerParameterID >= 0)
{
markerID = 0;
marker = null;
}
else
{
marker = (Marker)EditorGUILayout.ObjectField("Marker:", marker, typeof(Marker), true);
markerID = FieldToID <Marker> (marker, markerID);
marker = IDToField <Marker> (marker, markerID, false);
}
}
else
{
setVectorMethod = (SetVectorMethod)EditorGUILayout.EnumPopup("Vector is: ", setVectorMethod);
if (setVectorMethod == SetVectorMethod.EnteredHere)
{
newVectorParameterID = Action.ChooseParameterGUI("Value:", parameters, newVectorParameterID, ParameterType.Vector3);
if (newVectorParameterID < 0)
{
newVector = EditorGUILayout.Vector3Field("Value:", newVector);
}
}
else if (setVectorMethod == SetVectorMethod.FromVector3Variable)
{
variableLocation = (VariableLocation)EditorGUILayout.EnumPopup("Source:", variableLocation);
switch (variableLocation)
{
case VariableLocation.Global:
vectorVarParameterID = Action.ChooseParameterGUI("Vector3 variable:", parameters, vectorVarParameterID, ParameterType.GlobalVariable);
if (vectorVarParameterID < 0)
{
vectorVarID = AdvGame.GlobalVariableGUI("Vector3 variable:", vectorVarID, VariableType.Vector3);
}
break;
case VariableLocation.Local:
if (!isAssetFile)
{
vectorVarParameterID = Action.ChooseParameterGUI("Vector3 variable:", parameters, vectorVarParameterID, ParameterType.LocalVariable);
if (vectorVarParameterID < 0)
{
vectorVarID = AdvGame.LocalVariableGUI("Vector3 variable:", vectorVarID, VariableType.Vector3);
}
}
else
{
EditorGUILayout.HelpBox("Local variables cannot be accessed in ActionList assets.", MessageType.Info);
}
break;
case VariableLocation.Component:
vectorVarParameterID = Action.ChooseParameterGUI("Vector3 variable:", parameters, vectorVarParameterID, ParameterType.ComponentVariable);
if (vectorVarParameterID >= 0)
{
variables = null;
variablesConstantID = 0;
}
else
{
variables = (Variables)EditorGUILayout.ObjectField("Component:", variables, typeof(Variables), true);
variablesConstantID = FieldToID <Variables> (variables, variablesConstantID);
variables = IDToField <Variables> (variables, variablesConstantID, false);
if (variables != null)
{
vectorVarID = AdvGame.ComponentVariableGUI("Vector3 variable:", vectorVarID, VariableType.Vector3, variables);
}
}
break;
}
}
clearExisting = EditorGUILayout.Toggle("Stop existing transforms?", clearExisting);
}
if (transformType == TransformType.CopyMarker ||
(transformType == TransformType.Translate && toBy == ToBy.To) ||
(transformType == TransformType.Rotate && toBy == ToBy.To))
{
inWorldSpace = EditorGUILayout.Toggle("Act in world-space?", inWorldSpace);
if (inWorldSpace && transformType == TransformType.CopyMarker)
{
EditorGUILayout.HelpBox("The moveable object's scale will be changed in local space.", MessageType.Info);
}
}
transitionTimeParameterID = Action.ChooseParameterGUI("Transition time (s):", parameters, transitionTimeParameterID, ParameterType.Float);
if (transitionTimeParameterID < 0)
{
transitionTime = EditorGUILayout.FloatField("Transition time (s):", transitionTime);
}
if (transitionTime > 0f)
{
if (transformType == TransformType.Rotate)
{
doEulerRotation = EditorGUILayout.Toggle("Euler rotation?", doEulerRotation);
}
moveMethod = (MoveMethod)EditorGUILayout.EnumPopup("Move method:", moveMethod);
if (moveMethod == MoveMethod.CustomCurve)
{
timeCurve = EditorGUILayout.CurveField("Time curve:", timeCurve);
}
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
}
AfterRunningOption();
}
override public void ShowGUI(List <ActionParameter> parameters)
{
if (inventoryManager == null && AdvGame.GetReferences().inventoryManager)
{
inventoryManager = AdvGame.GetReferences().inventoryManager;
}
if (settingsManager == null && AdvGame.GetReferences().settingsManager)
{
settingsManager = AdvGame.GetReferences().settingsManager;
}
if (inventoryManager != null)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
if (parameterID == -1)
{
invNumber = -1;
}
if (inventoryManager.items.Count > 0)
{
foreach (InvItem _item in inventoryManager.items)
{
labelList.Add(_item.label);
// If a item has been removed, make sure selected variable is still valid
if (_item.id == invID)
{
invNumber = i;
}
if (_item.id == invIDReplace)
{
replaceInvNumber = i;
}
i++;
}
if (invNumber == -1)
{
Debug.Log("Previously chosen item no longer exists!");
invNumber = 0;
invID = 0;
}
if (invAction == InvAction.Replace && replaceInvNumber == -1)
{
Debug.Log("Previously chosen item no longer exists!");
replaceInvNumber = 0;
invIDReplace = 0;
}
invAction = (InvAction)EditorGUILayout.EnumPopup("Method:", invAction);
string label = "Item to add:";
if (invAction == InvAction.Remove)
{
label = "Item to remove:";
}
parameterID = Action.ChooseParameterGUI(label, parameters, parameterID, ParameterType.InventoryItem);
if (parameterID >= 0)
{
invNumber = Mathf.Min(invNumber, inventoryManager.items.Count - 1);
invID = -1;
}
else
{
invNumber = EditorGUILayout.Popup(label, invNumber, labelList.ToArray());
invID = inventoryManager.items[invNumber].id;
}
if (inventoryManager.items[invNumber].canCarryMultiple)
{
setAmount = EditorGUILayout.Toggle("Set amount?", setAmount);
if (setAmount)
{
if (invAction == InvAction.Remove)
{
amount = EditorGUILayout.IntField("Reduce count by:", amount);
}
else
{
amount = EditorGUILayout.IntField("Increase count by:", amount);
}
}
}
if (invAction == InvAction.Replace)
{
replaceParameterID = Action.ChooseParameterGUI("Item to remove:", parameters, replaceParameterID, ParameterType.InventoryItem);
if (replaceParameterID >= 0)
{
replaceInvNumber = Mathf.Min(replaceInvNumber, inventoryManager.items.Count - 1);
invIDReplace = -1;
}
else
{
replaceInvNumber = EditorGUILayout.Popup("Item to remove:", replaceInvNumber, labelList.ToArray());
invIDReplace = inventoryManager.items[replaceInvNumber].id;
}
}
}
else
{
EditorGUILayout.HelpBox("No inventory items exist!", MessageType.Info);
invID = -1;
invNumber = -1;
invIDReplace = -1;
replaceInvNumber = -1;
}
if (settingsManager != null && settingsManager.playerSwitching == PlayerSwitching.Allow && !settingsManager.shareInventory && invAction != InvAction.Replace)
{
EditorGUILayout.Space();
setPlayer = EditorGUILayout.Toggle("Affect specific player?", setPlayer);
if (setPlayer)
{
ChoosePlayerGUI();
}
}
else
{
setPlayer = false;
}
}
else
{
EditorGUILayout.HelpBox("An Inventory Manager must be assigned for this Action to work", MessageType.Warning);
}
AfterRunningOption();
}
private void ShowVarGUI(List <GVar> vars, List <ActionParameter> parameters, ParameterType parameterType)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
if (parameterID == -1)
{
variableNumber = -1;
}
if (vars.Count > 0)
{
foreach (GVar _var in vars)
{
labelList.Add(_var.label);
// If a GlobalVar variable has been removed, make sure selected variable is still valid
if (_var.id == variableID)
{
variableNumber = i;
}
i++;
}
if (variableNumber == -1 && (parameters == null || parameters.Count == 0 || parameterID == -1))
{
// Wasn't found (variable was deleted?), so revert to zero
ACDebug.LogWarning("Previously chosen variable no longer exists!");
variableNumber = 0;
variableID = 0;
}
parameterID = Action.ChooseParameterGUI("Variable:", parameters, parameterID, parameterType);
if (parameterID >= 0)
{
//variableNumber = 0;
variableNumber = Mathf.Min(variableNumber, vars.Count - 1);
variableID = -1;
}
else
{
variableNumber = EditorGUILayout.Popup("Variable:", variableNumber, labelList.ToArray());
variableID = vars [variableNumber].id;
}
string label = "Statement: ";
if (vars [variableNumber].type == VariableType.Boolean)
{
setVarMethodIntBool = (SetVarMethodIntBool)EditorGUILayout.EnumPopup("New value is:", setVarMethodIntBool);
label += "=";
if (setVarMethodIntBool == SetVarMethodIntBool.EnteredHere)
{
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Boolean);
if (setParameterID < 0)
{
boolValue = (BoolValue)EditorGUILayout.EnumPopup(label, boolValue);
}
}
else if (setVarMethodIntBool == SetVarMethodIntBool.SetAsMecanimParameter)
{
ShowMecanimGUI();
}
}
if (vars [variableNumber].type == VariableType.PopUp)
{
setVarMethod = (SetVarMethod)EditorGUILayout.EnumPopup("Method:", setVarMethod);
if (setVarMethod == SetVarMethod.Formula)
{
label += "=";
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String);
if (setParameterID < 0)
{
formula = EditorGUILayout.TextField(label, formula);
}
#if UNITY_WP8
EditorGUILayout.HelpBox("This feature is not available for Windows Phone 8.", MessageType.Warning);
#endif
}
else if (setVarMethod == SetVarMethod.IncreaseByValue || setVarMethod == SetVarMethod.SetValue)
{
if (setVarMethod == SetVarMethod.IncreaseByValue)
{
label += "+=";
}
else if (setVarMethod == SetVarMethod.SetValue)
{
label += "=";
}
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Integer);
if (setParameterID < 0)
{
if (setVarMethod == SetVarMethod.SetValue)
{
intValue = EditorGUILayout.Popup(label, intValue, vars[variableNumber].popUps);
}
else
{
intValue = EditorGUILayout.IntField(label, intValue);
}
if (setVarMethod == SetVarMethod.SetAsRandom && intValue < 0)
{
intValue = 0;
}
}
}
}
else if (vars [variableNumber].type == VariableType.Integer)
{
setVarMethodIntBool = (SetVarMethodIntBool)EditorGUILayout.EnumPopup("New value is:", setVarMethodIntBool);
if (setVarMethodIntBool == SetVarMethodIntBool.EnteredHere)
{
setVarMethod = (SetVarMethod)EditorGUILayout.EnumPopup("Method:", setVarMethod);
if (setVarMethod == SetVarMethod.Formula)
{
label += "=";
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String);
if (setParameterID < 0)
{
formula = EditorGUILayout.TextField(label, formula);
}
#if UNITY_WP8
EditorGUILayout.HelpBox("This feature is not available for Windows Phone 8.", MessageType.Warning);
#endif
}
else
{
if (setVarMethod == SetVarMethod.IncreaseByValue)
{
label += "+=";
}
else if (setVarMethod == SetVarMethod.SetValue)
{
label += "=";
}
else if (setVarMethod == SetVarMethod.SetAsRandom)
{
label += ("= 0 to");
}
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Integer);
if (setParameterID < 0)
{
intValue = EditorGUILayout.IntField(label, intValue);
if (setVarMethod == SetVarMethod.SetAsRandom && intValue < 0)
{
intValue = 0;
}
}
}
}
else if (setVarMethodIntBool == SetVarMethodIntBool.SetAsMecanimParameter)
{
ShowMecanimGUI();
}
}
else if (vars [variableNumber].type == VariableType.Float)
{
setVarMethodIntBool = (SetVarMethodIntBool)EditorGUILayout.EnumPopup("New value is:", setVarMethodIntBool);
if (setVarMethodIntBool == SetVarMethodIntBool.EnteredHere)
{
setVarMethod = (SetVarMethod)EditorGUILayout.EnumPopup("Method:", setVarMethod);
if (setVarMethod == SetVarMethod.Formula)
{
label += "=";
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String);
if (setParameterID < 0)
{
formula = EditorGUILayout.TextField(label, formula);
}
#if UNITY_WP8
EditorGUILayout.HelpBox("This feature is not available for Windows Phone 8.", MessageType.Warning);
#endif
}
else
{
if (setVarMethod == SetVarMethod.IncreaseByValue)
{
label += "+=";
}
else if (setVarMethod == SetVarMethod.SetValue)
{
label += "=";
}
else if (setVarMethod == SetVarMethod.SetAsRandom)
{
label += "= 0 to";
}
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Float);
if (setParameterID < 0)
{
floatValue = EditorGUILayout.FloatField(label, floatValue);
if (setVarMethod == SetVarMethod.SetAsRandom && floatValue < 0f)
{
floatValue = 0f;
}
}
}
}
else if (setVarMethodIntBool == SetVarMethodIntBool.SetAsMecanimParameter)
{
ShowMecanimGUI();
}
}
else if (vars [variableNumber].type == VariableType.String)
{
setVarMethodString = (SetVarMethodString)EditorGUILayout.EnumPopup("New value is:", setVarMethodString);
label += "=";
if (setVarMethodString == SetVarMethodString.EnteredHere)
{
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String);
if (setParameterID < 0)
{
stringValue = EditorGUILayout.TextField(label, stringValue);
}
}
else if (setVarMethodString == SetVarMethodString.SetAsMenuElementText)
{
menuName = EditorGUILayout.TextField("Menu name:", menuName);
elementName = EditorGUILayout.TextField("Element name:", elementName);
slotNumberParameterID = Action.ChooseParameterGUI("Slot # (optional):", parameters, slotNumberParameterID, ParameterType.Integer);
if (slotNumberParameterID < 0)
{
slotNumber = EditorGUILayout.IntField("Slot # (optional):", slotNumber);
}
}
}
AfterRunningOption();
}
else
{
EditorGUILayout.HelpBox("No variables exist!", MessageType.Info);
variableID = -1;
variableNumber = -1;
}
}
override public void ShowGUI(List <ActionParameter> parameters)
{
Upgrade();
if (inventoryManager == null)
{
inventoryManager = AdvGame.GetReferences().inventoryManager;
}
selectedCheckMethod = (SelectedCheckMethod)EditorGUILayout.EnumPopup("Check selected item is:", selectedCheckMethod);
if (inventoryManager != null)
{
if (selectedCheckMethod == SelectedCheckMethod.InSpecificCategory)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
int binNumber = 0;
if (parameterID == -1)
{
binNumber = -1;
}
if (inventoryManager.bins != null && inventoryManager.bins.Count > 0)
{
foreach (InvBin _bin in inventoryManager.bins)
{
labelList.Add(_bin.id.ToString() + ": " + _bin.label);
// If a category has been removed, make sure selected is still valid
if (_bin.id == binID)
{
binNumber = i;
}
i++;
}
if (binNumber == -1)
{
ACDebug.LogWarning("Previously chosen category no longer exists!");
binNumber = 0;
}
binNumber = EditorGUILayout.Popup("Inventory category:", binNumber, labelList.ToArray());
binID = inventoryManager.bins[binNumber].id;
includeLast = EditorGUILayout.Toggle("Include last-selected?", includeLast);
}
else
{
EditorGUILayout.HelpBox("No inventory categories exist!", MessageType.Info);
binID = -1;
}
}
else if (selectedCheckMethod == SelectedCheckMethod.SpecificItem)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
int invNumber = 0;
if (parameterID == -1)
{
invNumber = -1;
}
if (inventoryManager.items.Count > 0)
{
foreach (InvItem _item in inventoryManager.items)
{
labelList.Add(_item.label);
// If an item has been removed, make sure selected variable is still valid
if (_item.id == invID)
{
invNumber = i;
}
i++;
}
if (invNumber == -1)
{
ACDebug.LogWarning("Previously chosen item no longer exists!");
invID = 0;
}
parameterID = Action.ChooseParameterGUI("Inventory item:", parameters, parameterID, ParameterType.InventoryItem);
if (parameterID >= 0)
{
invNumber = Mathf.Min(invNumber, inventoryManager.items.Count - 1);
invID = -1;
}
else
{
invNumber = EditorGUILayout.Popup("Inventory item:", invNumber, labelList.ToArray());
invID = inventoryManager.items[invNumber].id;
}
includeLast = EditorGUILayout.Toggle("Include last-selected?", includeLast);
}
else
{
EditorGUILayout.HelpBox("No inventory items exist!", MessageType.Info);
invID = -1;
}
}
}
}
override public void ShowGUI(List <ActionParameter> parameters)
{
numSockets = EditorGUILayout.DelayedIntField("# of possible values:", numSockets);
numSockets = Mathf.Clamp(numSockets, 1, 100);
disallowSuccessive = EditorGUILayout.Toggle("Prevent same value twice?", disallowSuccessive);
if (disallowSuccessive)
{
saveToVariable = EditorGUILayout.Toggle("Save last value?", saveToVariable);
if (saveToVariable)
{
if (isAssetFile)
{
location = VariableLocation.Global;
}
else
{
location = (VariableLocation)EditorGUILayout.EnumPopup("Variable source:", location);
}
if (location == VariableLocation.Global)
{
if (AdvGame.GetReferences().variablesManager)
{
parameterID = Action.ChooseParameterGUI("Integer variable:", parameters, parameterID, ParameterType.GlobalVariable);
if (parameterID >= 0)
{
variableID = ShowVarGUI(variableID, false);
}
else
{
EditorGUILayout.BeginHorizontal();
variableID = ShowVarGUI(variableID, true);
if (GUILayout.Button("", CustomStyles.IconCog))
{
SideMenu();
}
EditorGUILayout.EndHorizontal();
}
}
}
else if (location == VariableLocation.Local)
{
if (KickStarter.localVariables)
{
parameterID = Action.ChooseParameterGUI("Integer variable:", parameters, parameterID, ParameterType.LocalVariable);
if (parameterID >= 0)
{
variableID = ShowVarGUI(variableID, false);
}
else
{
EditorGUILayout.BeginHorizontal();
variableID = ShowVarGUI(variableID, true);
if (GUILayout.Button("", CustomStyles.IconCog))
{
SideMenu();
}
EditorGUILayout.EndHorizontal();
}
}
else
{
EditorGUILayout.HelpBox("No 'Local Variables' component found in the scene. Please add an AC GameEngine object from the Scene Manager.", MessageType.Info);
}
}
}
}
}
override public void ShowGUI(List <ActionParameter> parameters)
{
UpgradeSelf();
isPlayer = EditorGUILayout.Toggle("Is Player?", isPlayer);
if (!isPlayer)
{
charToMoveParameterID = Action.ChooseParameterGUI("Character to move:", parameters, charToMoveParameterID, ParameterType.GameObject);
if (charToMoveParameterID >= 0)
{
charToMoveID = 0;
charToMove = null;
}
else
{
charToMove = (Char)EditorGUILayout.ObjectField("Character to move:", charToMove, typeof(Char), true);
charToMoveID = FieldToID <Char> (charToMove, charToMoveID);
charToMove = IDToField <Char> (charToMove, charToMoveID, false);
}
}
movePathMethod = (MovePathMethod)EditorGUILayout.EnumPopup("Method:", movePathMethod);
if (movePathMethod == MovePathMethod.MoveOnNewPath)
{
movePathParameterID = Action.ChooseParameterGUI("Path to follow:", parameters, movePathParameterID, ParameterType.GameObject);
if (movePathParameterID >= 0)
{
movePathID = 0;
movePath = null;
}
else
{
movePath = (Paths)EditorGUILayout.ObjectField("Path to follow:", movePath, typeof(Paths), true);
movePathID = FieldToID <Paths> (movePath, movePathID);
movePath = IDToField <Paths> (movePath, movePathID, false);
}
if (movePath != null && movePath.pathType == AC_PathType.IsRandom)
{
startRandom = EditorGUILayout.Toggle("Start at random node?", startRandom);
}
doTeleport = EditorGUILayout.Toggle("Teleport to start?", doTeleport);
if (movePath != null && movePath.pathType != AC_PathType.ForwardOnly && movePath.pathType != AC_PathType.ReverseOnly)
{
willWait = false;
}
else
{
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
}
if (movePath != null && movePath.GetComponent <Char>())
{
EditorGUILayout.HelpBox("Can't follow a Path attached to a Character!", MessageType.Warning);
}
}
else if (movePathMethod == MovePathMethod.StopMoving)
{
stopInstantly = EditorGUILayout.Toggle("Stop instantly?", stopInstantly);
}
else if (movePathMethod == MovePathMethod.ResumeLastSetPath)
{
//
}
AfterRunningOption();
}
override public void ShowGUI(List <ActionParameter> parameters)
{
saveHandling = (SaveHandling)EditorGUILayout.EnumPopup("Method:", saveHandling);
if (saveHandling == SaveHandling.LoadGame || saveHandling == SaveHandling.OverwriteExistingSave)
{
string _action = "load";
if (saveHandling == SaveHandling.OverwriteExistingSave)
{
_action = "overwrite";
}
selectSaveType = (SelectSaveType)EditorGUILayout.EnumPopup("Save to " + _action + ":", selectSaveType);
if (selectSaveType == SelectSaveType.SetSlotIndex)
{
saveIndexParameterID = Action.ChooseParameterGUI("Slot index to " + _action + ":", parameters, saveIndexParameterID, ParameterType.Integer);
if (saveIndexParameterID == -1)
{
saveIndex = EditorGUILayout.IntField("Slot index to " + _action + ":", saveIndex);
}
}
else if (selectSaveType == SelectSaveType.SlotIndexFromVariable)
{
slotVarID = AdvGame.GlobalVariableGUI("Integer variable:", slotVarID, VariableType.Integer);
}
if (selectSaveType != SelectSaveType.Autosave)
{
EditorGUILayout.Space();
menuName = EditorGUILayout.TextField("Menu with SavesList:", menuName);
elementName = EditorGUILayout.TextField("SavesList element:", elementName);
}
}
if (saveHandling == SaveHandling.OverwriteExistingSave || saveHandling == SaveHandling.SaveNewGame)
{
if (selectSaveType != SelectSaveType.Autosave)
{
EditorGUILayout.Space();
if (saveHandling == SaveHandling.OverwriteExistingSave)
{
updateLabel = EditorGUILayout.Toggle("Update label?", updateLabel);
}
if (updateLabel || saveHandling == SaveHandling.SaveNewGame)
{
customLabel = EditorGUILayout.Toggle("With custom label?", customLabel);
if (customLabel)
{
varID = AdvGame.GlobalVariableGUI("Label as String variable:", varID, VariableType.String);
}
}
}
}
if (saveHandling == SaveHandling.LoadGame || saveHandling == SaveHandling.ContinueFromLastSave)
{
doSelectiveLoad = EditorGUILayout.ToggleLeft("Selective loading?", doSelectiveLoad);
if (doSelectiveLoad)
{
selectiveLoad.ShowGUI();
}
}
if (saveHandling == SaveHandling.OverwriteExistingSave || saveHandling == SaveHandling.SaveNewGame)
{
AfterRunningOption();
}
}
override public void ShowGUI(List <ActionParameter> parameters)
{
invAction = (InvAction)EditorGUILayout.EnumPopup("Method:", invAction);
string _label = "Object to instantiate:";
if (invAction == InvAction.Remove)
{
_label = "Object to delete:";
}
parameterID = Action.ChooseParameterGUI(_label, parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
gameObject = null;
}
else
{
gameObject = (GameObject)EditorGUILayout.ObjectField(_label, gameObject, typeof(GameObject), true);
constantID = FieldToID(gameObject, constantID);
gameObject = IDToField(gameObject, constantID, false);
}
if (invAction == InvAction.Add)
{
positionRelativeTo = (PositionRelativeTo)EditorGUILayout.EnumPopup("Position relative to:", positionRelativeTo);
if (positionRelativeTo == PositionRelativeTo.RelativeToGameObject)
{
relativeGameObjectParameterID = Action.ChooseParameterGUI("Relative GameObject:", parameters, relativeGameObjectParameterID, ParameterType.GameObject);
if (relativeGameObjectParameterID >= 0)
{
relativeGameObjectID = 0;
relativeGameObject = null;
}
else
{
relativeGameObject = (GameObject)EditorGUILayout.ObjectField("Relative GameObject:", relativeGameObject, typeof(GameObject), true);
relativeGameObjectID = FieldToID(relativeGameObject, relativeGameObjectID);
relativeGameObject = IDToField(relativeGameObject, relativeGameObjectID, false);
}
}
else if (positionRelativeTo == PositionRelativeTo.EnteredValue)
{
relativeVectorParameterID = Action.ChooseParameterGUI("Value:", parameters, relativeVectorParameterID, ParameterType.Vector3);
if (relativeVectorParameterID < 0)
{
relativeVector = EditorGUILayout.Vector3Field("Value:", relativeVector);
}
}
else if (positionRelativeTo == PositionRelativeTo.VectorVariable)
{
if (isAssetFile)
{
variableLocation = VariableLocation.Global;
}
else
{
variableLocation = (VariableLocation)EditorGUILayout.EnumPopup("Source:", variableLocation);
}
if (variableLocation == VariableLocation.Global)
{
vectorVarParameterID = Action.ChooseParameterGUI("Vector3 variable:", parameters, vectorVarParameterID, ParameterType.GlobalVariable);
if (vectorVarParameterID < 0)
{
vectorVarID = AdvGame.GlobalVariableGUI("Vector3 variable:", vectorVarID, VariableType.Vector3);
}
}
else if (variableLocation == VariableLocation.Local)
{
vectorVarParameterID = Action.ChooseParameterGUI("Vector3 variable:", parameters, vectorVarParameterID, ParameterType.LocalVariable);
if (vectorVarParameterID < 0)
{
vectorVarID = AdvGame.LocalVariableGUI("Vector3 variable:", vectorVarID, VariableType.Vector3);
}
}
}
}
else if (invAction == InvAction.Replace)
{
EditorGUILayout.Space();
replaceParameterID = Action.ChooseParameterGUI("Object to delete:", parameters, replaceParameterID, ParameterType.GameObject);
if (replaceParameterID >= 0)
{
replaceConstantID = 0;
replaceGameObject = null;
}
else
{
replaceGameObject = (GameObject)EditorGUILayout.ObjectField("Object to delete:", replaceGameObject, typeof(GameObject), true);
replaceConstantID = FieldToID(replaceGameObject, replaceConstantID);
replaceGameObject = IDToField(replaceGameObject, replaceConstantID, false);
}
}
AfterRunningOption();
}
private void ButtonGUI(Button button, string suffix, InteractionSource source, bool isForInventory = false)
{
bool isEnabled = !button.isDisabled;
isEnabled = EditorGUILayout.Toggle("Enabled:", isEnabled);
button.isDisabled = !isEnabled;
if (source == InteractionSource.AssetFile)
{
EditorGUILayout.BeginHorizontal();
button.assetFile = (ActionListAsset)CustomGUILayout.ObjectField <ActionListAsset> ("Interaction:", button.assetFile, false, "", "The ActionList asset to run");
if (button.assetFile == null)
{
if (GUILayout.Button("Create", autoWidth))
{
string defaultName = GenerateInteractionName(suffix, true);
#if !(UNITY_WP8 || UNITY_WINRT)
defaultName = System.Text.RegularExpressions.Regex.Replace(defaultName, "[^\\w\\._]", "");
#else
defaultName = "";
#endif
button.assetFile = ActionListAssetMenu.CreateAsset(defaultName);
}
}
else if (GUILayout.Button("", CustomStyles.IconNodes))
{
ActionListEditorWindow.Init(button.assetFile);
}
EditorGUILayout.EndHorizontal();
if (button.assetFile != null && button.assetFile.NumParameters > 0)
{
EditorGUILayout.BeginHorizontal();
button.parameterID = Action.ChooseParameterGUI("Hotspot parameter:", button.assetFile.DefaultParameters, button.parameterID, ParameterType.GameObject, -1, "The GameObject parameter to automatically assign as this Hotspot");
EditorGUILayout.EndHorizontal();
if (isForInventory)
{
button.invParameterID = Action.ChooseParameterGUI("Inventory item parameter:", button.assetFile.DefaultParameters, button.invParameterID, ParameterType.InventoryItem, -1, "The Inventory Item parameter to automatically assign as the used item");
}
}
}
else if (source == InteractionSource.CustomScript)
{
button.customScriptObject = (GameObject)CustomGUILayout.ObjectField <GameObject> ("Object with script:", button.customScriptObject, true, "", "The GameObject with the custom script to run");
button.customScriptFunction = CustomGUILayout.TextField("Message to send:", button.customScriptFunction, "", "The name of the function to run");
if (isForInventory)
{
EditorGUILayout.HelpBox("If the receiving function has an integer parameter, the Inventory item's ID will be passed to it.", MessageType.Info);
}
}
else if (source == InteractionSource.InScene)
{
EditorGUILayout.BeginHorizontal();
button.interaction = (Interaction)CustomGUILayout.ObjectField <Interaction> ("Interaction:", button.interaction, true, "", "The Interaction ActionList to run");
if (button.interaction == null)
{
if (GUILayout.Button("Create", autoWidth))
{
Undo.RecordObject(_target, "Create Interaction");
Interaction newInteraction = SceneManager.AddPrefab("Logic", "Interaction", true, false, true).GetComponent <Interaction>();
newInteraction.gameObject.name = GenerateInteractionName(suffix, false);
button.interaction = newInteraction;
}
}
else
{
if (GUILayout.Button("", CustomStyles.IconNodes))
{
ActionListEditorWindow.Init(button.interaction);
}
}
EditorGUILayout.EndHorizontal();
if (button.interaction != null && button.interaction.source == ActionListSource.InScene && button.interaction.NumParameters > 0)
{
EditorGUILayout.BeginHorizontal();
button.parameterID = Action.ChooseParameterGUI("Hotspot parameter:", button.interaction.parameters, button.parameterID, ParameterType.GameObject, -1, "The GameObject parameter to automatically assign as this Hotspot");
EditorGUILayout.EndHorizontal();
if (isForInventory)
{
button.invParameterID = Action.ChooseParameterGUI("Inventory item parameter:", button.interaction.parameters, button.invParameterID, ParameterType.InventoryItem, -1, "The Inventory Item parameter to automatically assign as the used item");
}
}
else if (button.interaction != null && button.interaction.source == ActionListSource.AssetFile && button.interaction.assetFile != null && button.interaction.assetFile.NumParameters > 0)
{
EditorGUILayout.BeginHorizontal();
button.parameterID = Action.ChooseParameterGUI("Hotspot parameter:", button.interaction.assetFile.DefaultParameters, button.parameterID, ParameterType.GameObject, -1, "The GameObject parameter to automatically assign as this Hotspot");
EditorGUILayout.EndHorizontal();
if (isForInventory)
{
button.invParameterID = Action.ChooseParameterGUI("Inventory item parameter:", button.interaction.assetFile.DefaultParameters, button.invParameterID, ParameterType.InventoryItem, -1, "The Inventory Item parameter to automatically assign as the used item");
}
}
}
button.playerAction = (PlayerAction)CustomGUILayout.EnumPopup("Player action:", button.playerAction, "", "What the Player prefab does after clicking the Hotspot, but before the Interaction itself is run");
if (button.playerAction == PlayerAction.WalkTo || button.playerAction == PlayerAction.WalkToMarker)
{
if (button.playerAction == PlayerAction.WalkToMarker && _target.walkToMarker == null)
{
EditorGUILayout.HelpBox("You must assign a 'Walk-to marker' above for this option to work.", MessageType.Warning);
}
button.isBlocking = CustomGUILayout.Toggle("Cutscene while moving?", button.isBlocking, "", "If True, then gameplay will be blocked while the Player moves");
button.faceAfter = CustomGUILayout.Toggle("Face after moving?", button.faceAfter, "", "If True, then the Player will face the Hotspot after reaching the Marker");
if (button.playerAction == PlayerAction.WalkTo)
{
button.setProximity = CustomGUILayout.Toggle("Set minimum distance?", button.setProximity, "", "If True, then the Interaction will be run once the Player is within a certain distance of the Hotspot");
if (button.setProximity)
{
button.proximity = CustomGUILayout.FloatField("Proximity:", button.proximity, "", "The proximity the Player must be within");
}
}
}
}
override public void ShowGUI(List <ActionParameter> parameters)
{
if (AdvGame.GetReferences().settingsManager != null)
{
SettingsManager settingsManager = AdvGame.GetReferences().settingsManager;
if (GUILayout.Button("Ambience Storage window"))
{
AmbienceStorageWindow.Init();
}
if (settingsManager.ambienceStorages.Count == 0)
{
EditorGUILayout.HelpBox("Before a track can be selected, it must be added to the Ambience Storage window.", MessageType.Info);
return;
}
musicAction = (MusicAction)EditorGUILayout.EnumPopup("Method:", (MusicAction)musicAction);
string fadeLabel = "Transition time (s):";
if (musicAction == MusicAction.Play || musicAction == MusicAction.Crossfade)
{
GetTrackIndex(settingsManager.ambienceStorages.ToArray(), parameters);
loop = EditorGUILayout.Toggle("Loop?", loop);
isQueued = EditorGUILayout.Toggle("Queue?", isQueued);
resumeIfPlayedBefore = EditorGUILayout.Toggle("Resume if played before?", resumeIfPlayedBefore);
}
else if (musicAction == MusicAction.Stop)
{
fadeLabel = "Fade-out time (s):";
}
else if (musicAction == MusicAction.ResumeLastStopped)
{
resumeFromStart = EditorGUILayout.Toggle("Restart track?", resumeFromStart);
}
if (CanWaitComplete())
{
willWaitComplete = EditorGUILayout.Toggle("Wait until track completes?", willWaitComplete);
}
fadeTimeParameterID = Action.ChooseParameterGUI(fadeLabel, parameters, fadeTimeParameterID, ParameterType.Float);
if (fadeTimeParameterID < 0)
{
fadeTime = EditorGUILayout.Slider(fadeLabel, fadeTime, 0f, 10f);
}
if (!CanWaitComplete() || !willWaitComplete)
{
if (fadeTime > 0f && !isQueued)
{
willWait = EditorGUILayout.Toggle("Wait until transition ends?", willWait);
}
}
}
else
{
EditorGUILayout.HelpBox("A Settings Manager must be defined for this Action to function correctly. Please go to your Game Window and assign one.", MessageType.Warning);
}
AfterRunningOption();
}
override public void ShowGUI(List <ActionParameter> parameters)
{
if (KickStarter.settingsManager != null)
{
if (KickStarter.settingsManager.playerSwitching == PlayerSwitching.DoNotAllow)
{
EditorGUILayout.HelpBox("This Action requires Player Switching to be allowed, as set in the Settings Manager.", MessageType.Info);
return;
}
if (KickStarter.settingsManager.players.Count == 0)
{
EditorGUILayout.HelpBox("No players are defined in the Settings Manager.", MessageType.Warning);
return;
}
playerIDParameterID = Action.ChooseParameterGUI("New Player ID:", parameters, playerIDParameterID, ParameterType.Integer);
if (playerIDParameterID == -1)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
int playerNumber = -1;
foreach (PlayerPrefab playerPrefab in KickStarter.settingsManager.players)
{
if (playerPrefab.playerOb != null)
{
labelList.Add(playerPrefab.playerOb.name);
}
else
{
labelList.Add("(Undefined prefab)");
}
// If a player has been removed, make sure selected player is still valid
if (playerPrefab.ID == playerID)
{
playerNumber = i;
}
i++;
}
if (playerNumber == -1)
{
// Wasn't found (item was possibly deleted), so revert to zero
ACDebug.LogWarning("Previously chosen Player no longer exists!");
playerNumber = 0;
playerID = 0;
}
playerNumber = EditorGUILayout.Popup("New Player:", playerNumber, labelList.ToArray());
playerID = KickStarter.settingsManager.players[playerNumber].ID;
}
newTransformParameterID = Action.ChooseParameterGUI("New Transform:", parameters, newTransformParameterID, ParameterType.GameObject);
if (newTransformParameterID >= 0)
{
newTransformConstantID = 0;
newTransform = null;
}
else
{
newTransform = (Transform)EditorGUILayout.ObjectField("New Transform:", newTransform, typeof(Transform), true);
newTransformConstantID = FieldToID(newTransform, newTransformConstantID);
newTransform = IDToField(newTransform, newTransformConstantID, true);
}
associatedCameraParameterID = Action.ChooseParameterGUI("Camera (optional):", parameters, associatedCameraParameterID, ParameterType.GameObject);
if (associatedCameraParameterID >= 0)
{
associatedCameraConstantID = 0;
associatedCamera = null;
}
else
{
associatedCamera = (_Camera)EditorGUILayout.ObjectField("Camera (optional):", associatedCamera, typeof(_Camera), true);
associatedCameraConstantID = FieldToID(associatedCamera, associatedCameraConstantID);
associatedCamera = IDToField(associatedCamera, associatedCameraConstantID, true);
}
}
else
{
EditorGUILayout.HelpBox("No Settings Manager assigned!", MessageType.Warning);
}
AfterRunningOption();
}
override public void ShowGUI(List <ActionParameter> parameters)
{
if (AdvGame.GetReferences().settingsManager != null && !AdvGame.GetReferences().settingsManager.useProfiles)
{
EditorGUILayout.HelpBox("Save game profiles are not enabled - please set in Settings Manager to use this Action.", MessageType.Warning);
AfterRunningOption();
return;
}
manageProfileType = (ManageProfileType)EditorGUILayout.EnumPopup("Method:", manageProfileType);
if (manageProfileType == ManageProfileType.CreateProfile)
{
useCustomLabel = EditorGUILayout.Toggle("Use custom label?", useCustomLabel);
}
if ((manageProfileType == ManageProfileType.CreateProfile && useCustomLabel) || manageProfileType == AC.ManageProfileType.RenameProfile)
{
varID = AdvGame.GlobalVariableGUI("Label as String variable:", varID);
if (varID >= 0 && AdvGame.GetReferences() && AdvGame.GetReferences().variablesManager)
{
GVar _var = AdvGame.GetReferences().variablesManager.GetVariable(varID);
if (_var != null && _var.type != VariableType.String)
{
EditorGUILayout.HelpBox("The chosen Variable must be a String.", MessageType.Warning);
}
}
}
if (manageProfileType == ManageProfileType.DeleteProfile || manageProfileType == ManageProfileType.RenameProfile)
{
string _action = "delete";
if (manageProfileType == ManageProfileType.RenameProfile)
{
_action = "rename";
}
deleteProfileType = (DeleteProfileType)EditorGUILayout.EnumPopup("Profile to " + _action + ":", deleteProfileType);
if (deleteProfileType == DeleteProfileType.SetSlotIndex)
{
profileIndexParameterID = Action.ChooseParameterGUI("Slot index to " + _action + ":", parameters, profileIndexParameterID, ParameterType.Integer);
if (profileIndexParameterID == -1)
{
profileIndex = EditorGUILayout.IntField("Slot index to " + _action + ":", profileIndex);
}
}
else if (deleteProfileType == DeleteProfileType.SlotIndexFromVariable)
{
slotVarID = AdvGame.GlobalVariableGUI("Integer variable:", slotVarID);
if (slotVarID >= 0 && AdvGame.GetReferences() && AdvGame.GetReferences().variablesManager)
{
GVar _var = AdvGame.GetReferences().variablesManager.GetVariable(slotVarID);
if (_var != null && _var.type != VariableType.Integer)
{
EditorGUILayout.HelpBox("The chosen Variable must be an Integer.", MessageType.Warning);
}
}
}
if (deleteProfileType != DeleteProfileType.ActiveProfile)
{
EditorGUILayout.Space();
menuName = EditorGUILayout.TextField("Menu with ProfilesList:", menuName);
elementName = EditorGUILayout.TextField("ProfilesList element:", elementName);
}
}
AfterRunningOption();
}
override public void ShowGUI(List <ActionParameter> parameters)
{
chooseSceneBy = (ChooseSceneBy)EditorGUILayout.EnumPopup("Choose scene by:", chooseSceneBy);
if (chooseSceneBy == ChooseSceneBy.Name)
{
sceneNameParameterID = Action.ChooseParameterGUI("Scene name:", parameters, sceneNameParameterID, ParameterType.String);
if (sceneNameParameterID < 0)
{
sceneName = EditorGUILayout.TextField("Scene name:", sceneName);
}
}
else
{
sceneNumberParameterID = Action.ChooseParameterGUI("Scene number:", parameters, sceneNumberParameterID, ParameterType.Integer);
if (sceneNumberParameterID < 0)
{
sceneNumber = EditorGUILayout.IntField("Scene number:", sceneNumber);
}
}
onlyPreload = EditorGUILayout.ToggleLeft("Don't change scene, just preload data?", onlyPreload);
if (!onlyPreload)
{
forceReload = EditorGUILayout.ToggleLeft("Reload even if scene is already open?", forceReload);
relativePosition = EditorGUILayout.ToggleLeft("Position Player relative to Marker?", relativePosition);
if (relativePosition)
{
relativeMarkerParameterID = Action.ChooseParameterGUI("Relative Marker:", parameters, relativeMarkerParameterID, ParameterType.GameObject);
if (relativeMarkerParameterID >= 0)
{
relativeMarkerID = 0;
relativeMarker = null;
}
else
{
relativeMarker = (Marker)EditorGUILayout.ObjectField("Relative Marker:", relativeMarker, typeof(Marker), true);
relativeMarkerID = FieldToID(relativeMarker, relativeMarkerID);
relativeMarker = IDToField(relativeMarker, relativeMarkerID, false);
}
}
}
if (onlyPreload && !relativePosition)
{
if (AdvGame.GetReferences() != null && AdvGame.GetReferences().settingsManager != null && AdvGame.GetReferences().settingsManager.useAsyncLoading)
{
}
else
{
EditorGUILayout.HelpBox("To pre-load scenes, 'Load scenes asynchronously?' must be enabled in the Settings Manager.", MessageType.Warning);
}
numSockets = 1;
AfterRunningOption();
}
else
{
numSockets = 0;
assignScreenOverlay = EditorGUILayout.ToggleLeft("Overlay current screen during switch?", assignScreenOverlay);
}
}
override public void ShowGUI(List <ActionParameter> parameters)
{
numSockets = EditorGUILayout.DelayedIntField("# of possible values:", numSockets);
numSockets = Mathf.Clamp(numSockets, 1, 100);
disallowSuccessive = EditorGUILayout.Toggle("Prevent same value twice?", disallowSuccessive);
if (disallowSuccessive)
{
saveToVariable = EditorGUILayout.Toggle("Save last value?", saveToVariable);
if (saveToVariable)
{
location = (VariableLocation)EditorGUILayout.EnumPopup("Variable source:", location);
if (location == VariableLocation.Local && KickStarter.localVariables == null)
{
EditorGUILayout.HelpBox("No 'Local Variables' component found in the scene. Please add an AC GameEngine object from the Scene Manager.", MessageType.Info);
}
else if (location == VariableLocation.Local && isAssetFile)
{
EditorGUILayout.HelpBox("Local variables cannot be accessed in ActionList assets.", MessageType.Info);
}
if ((location == VariableLocation.Global && AdvGame.GetReferences().variablesManager != null) ||
(location == VariableLocation.Local && KickStarter.localVariables != null && !isAssetFile) ||
(location == VariableLocation.Component))
{
ParameterType _parameterType = ParameterType.GlobalVariable;
if (location == VariableLocation.Local)
{
_parameterType = ParameterType.LocalVariable;
}
else if (location == VariableLocation.Component)
{
_parameterType = ParameterType.ComponentVariable;
}
parameterID = Action.ChooseParameterGUI("Integer variable:", parameters, parameterID, _parameterType);
if (parameterID >= 0)
{
if (location == VariableLocation.Component)
{
variablesConstantID = 0;
variables = null;
}
variableID = ShowVarGUI(variableID, false);
}
else
{
if (location == VariableLocation.Component)
{
variables = (Variables)EditorGUILayout.ObjectField("Component:", variables, typeof(Variables), true);
variablesConstantID = FieldToID <Variables> (variables, variablesConstantID);
variables = IDToField <Variables> (variables, variablesConstantID, false);
if (variables != null)
{
variableID = ShowVarGUI(variableID, true);
}
}
else
{
EditorGUILayout.BeginHorizontal();
variableID = ShowVarGUI(variableID, true);
if (GUILayout.Button(string.Empty, CustomStyles.IconCog))
{
SideMenu();
}
EditorGUILayout.EndHorizontal();
}
}
}
}
}
}
override public void ShowGUI(List <ActionParameter> parameters)
{
listSource = (ListSource)EditorGUILayout.EnumPopup("Source:", listSource);
if (listSource == ListSource.InScene)
{
parameterID = Action.ChooseParameterGUI("ActionList:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
localParameters.Clear();
constantID = 0;
actionList = null;
}
else
{
actionList = (ActionList)EditorGUILayout.ObjectField("ActionList:", actionList, typeof(ActionList), true);
constantID = FieldToID <ActionList> (actionList, constantID);
actionList = IDToField <ActionList> (actionList, constantID, true);
if (actionList != null)
{
if (actionList.actions.Contains(this))
{
EditorGUILayout.HelpBox("This Action cannot be used to run the ActionList it is in - use the Skip option below instead.", MessageType.Warning);
}
else if (actionList.source == ActionListSource.AssetFile && actionList.assetFile != null && actionList.assetFile.useParameters && actionList.assetFile.parameters.Count > 0)
{
SetParametersGUI(actionList.assetFile.parameters, parameters);
}
else if (actionList.source == ActionListSource.InScene && actionList.useParameters && actionList.parameters.Count > 0)
{
SetParametersGUI(actionList.parameters, parameters);
}
}
}
runFromStart = EditorGUILayout.Toggle("Run from start?", runFromStart);
if (!runFromStart)
{
jumpToActionParameterID = Action.ChooseParameterGUI("Action # to skip to:", parameters, jumpToActionParameterID, ParameterType.Integer);
if (jumpToActionParameterID == -1 && actionList != null && actionList.actions.Count > 1)
{
JumpToActionGUI(actionList.actions);
}
}
}
else if (listSource == ListSource.AssetFile)
{
assetParameterID = Action.ChooseParameterGUI("ActionList asset:", parameters, assetParameterID, ParameterType.UnityObject);
if (assetParameterID < 0)
{
invActionList = (ActionListAsset)EditorGUILayout.ObjectField("ActionList asset:", invActionList, typeof(ActionListAsset), true);
}
if (invActionList != null)
{
if (invActionList.actions.Contains(this))
{
EditorGUILayout.HelpBox("This Action cannot be used to run the ActionList it is in - use the Skip option below instead.", MessageType.Warning);
}
else if (invActionList.useParameters && invActionList.parameters.Count > 0)
{
SetParametersGUI(invActionList.parameters, parameters);
}
}
runFromStart = EditorGUILayout.Toggle("Run from start?", runFromStart);
if (!runFromStart && invActionList != null && invActionList.actions.Count > 1)
{
JumpToActionGUI(invActionList.actions);
}
}
if (!runInParallel)
{
Upgrade();
}
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
AfterRunningOption();
}
