/* ---------------------------------------------------------------- */
// TriggerParam
/* ---------------------------------------------------------------- */
public static TriggerParam CreateSignal(TriggerTarget target, Item specifiedTargetItem, string key)
{
var value = new TriggerValue();
var param = new TriggerParam(target, null, key, ParameterType.Signal, value);
return(param);
}
/*
* If the specified trigger behavior is Remove, removes the game object from
* the scene and returns true. If not, returns false.
*/
public override void Trigger(TriggerTarget.TriggerBehavior triggerType)
{
if (triggerType != TriggerTarget.TriggerBehavior.Remove)
return;
Destroy(gameObject, timeToDestroy);
PrintMessage();
}
/// <summary>
/// Validates target object is appropriate for the activation type. Null is considered valid.
/// </summary>
/// <param name="property"></param>
/// <returns>Returns false if invalid</returns>
public static bool ValidateTriggerTargetProperty(SerializedProperty property)
{
if (property == null)
{
return(false);
}
var targProp = property.FindPropertyRelative(TriggerTargetPropertyDrawer.PROP_TRIGGERABLETARG);
if (targProp.objectReferenceValue == null)
{
return(true);
}
var actProp = property.FindPropertyRelative(TriggerTargetPropertyDrawer.PROP_ACTIVATIONTYPE);
var act = actProp.GetEnumValue <TriggerActivationType>();
if (!TriggerTarget.IsValidTriggerTarget(targProp.objectReferenceValue, act))
{
targProp.objectReferenceValue = null;
return(false);
}
else
{
return(true);
}
}
public override bool Trigger(object sender, object arg)
{
if (!this.CanTrigger)
{
return(false);
}
var targ = this.GetTarget(arg);
if (targ == null)
{
return(false);
}
switch (_triggerAction)
{
case TriggerActivationType.TriggerAllOnTarget:
TriggerTarget.TriggerAllOnTarget(targ, sender, arg);
return(true);
case TriggerActivationType.TriggerSelectedTarget:
TriggerTarget.TriggerSelectedTarget(targ, sender, arg);
return(true);
case TriggerActivationType.DestroyTarget:
TriggerTarget.DestroyTarget(targ);
return(true);
}
return(false);
}
public override void Trigger(MessageBoxTriggerData triggerData)
{
if (triggerData.Sender.GetType() == typeof(SimpleMessageBox))
{
// Trigger from bad name message box
Destroy(triggerData.Sender.gameObject);
}
else if (triggerData.Sender.GetType() == typeof(ConfirmMessageBox))
{
// Trigger from overwrite message box
if (triggerData.ButtonPressed == MessageBoxButtonType.Positive)
{
// Confirm overwrite
MessageBoxTriggerData newTriggerData = new MessageBoxTriggerData
{
ButtonPressed = MostRecentButtonType,
Sender = this,
TextInput = this.TextInput.FindChildGameObject("UIMessageBoxTextInputText").GetComponent <Text>().text
};
TriggerTarget.Trigger(newTriggerData);
}
Destroy(triggerData.Sender.gameObject);
}
}
public void OnSaveAsChallengeButtonClick()
{
string filename = this.TextInput.FindChildGameObject("UIMessageBoxTextInputText").GetComponent <Text>().text;
string fullname = filename + ".json";
string fullpath = Directories.CHALLENGE_FOLDER_FULL_PATH + "/" + fullname;
MostRecentButtonType = MessageBoxButtonType.Neutral;
// If file has invalid name, show error dialog
if (filename.IndexOfAny(Path.GetInvalidFileNameChars()) != -1 ||
String.IsNullOrWhiteSpace(filename))
{
MessageBoxFactory.MakeFromConfig(SaveBadNameMessageBoxConfig, this);
return;
}
// If file already exists, ask for overwrite confirmation
if (File.Exists(fullpath))
{
MessageBoxFactory.MakeFromConfig(SaveOverwriteMessageBoxConfig, this);
return;
}
// Run callback to save circuit, close message box, and unfreeze canvas
MessageBoxTriggerData triggerData = new MessageBoxTriggerData
{
ButtonPressed = MessageBoxButtonType.Neutral,
Sender = this,
TextInput = filename
};
TriggerTarget.Trigger(triggerData);
}
public TriggerParam(TriggerTarget target, IItem specifiedTargetItem, string key, ParameterType type, TriggerValue value)
{
Target = target;
SpecifiedTargetItem = specifiedTargetItem;
Key = key;
Type = type;
Value = value;
}
public TriggerParam(TriggerTarget target, Item.Implements.Item specifiedTargetItem, string key, ParameterType type, Value value)
{
this.target = target;
this.specifiedTargetItem = specifiedTargetItem;
this.key = key;
this.type = type;
this.value = value;
}
// Start is called before the first frame update
void Start()
{
//tutorialPointer.SetBool("showPointer", true);
triggerTarget = FindObjectOfType <TriggerTarget>();
//numberOfTargets = GameObject.FindGameObjectsWithTag("Target").Length;
fakePanel = FindObjectOfType <MyPanel>();
fakePanel.PanelSwitch(false);
}
void Start()
{
gameController = GetGameController();
triggerTarget = GetComponent <TriggerTarget>();
initialY = transform.position.y;
state = State.Down;
lastStateChangeTime = Time.time;
}
void Start()
{
triggerTarget = GetComponent <TriggerTarget>();
if (triggerTarget == null)
{
SetEnabled(true);
}
}
/// <summary>
/// Adds targets to a Trigger/SPEvent.
///
/// This method applies changes to the SerializedProperty. Only call if you expect this behaviour.
/// </summary>
/// <param name="triggerProperty"></param>
/// <param name="objs"></param>
public static void AddObjectsToTrigger(SerializedProperty triggerProperty, UnityEngine.Object[] objs)
{
if (triggerProperty == null)
{
throw new System.ArgumentNullException("triggerProperty");
}
if (triggerProperty.serializedObject.isEditingMultipleObjects)
{
throw new System.ArgumentException("Can not use this method for multi-selected SerializedObjects.", "triggerProperty");
}
try
{
triggerProperty.serializedObject.ApplyModifiedProperties();
var trigger = EditorHelper.GetTargetObjectOfProperty(triggerProperty) as BaseSPEvent;
if (trigger == null)
{
return;
}
Undo.RecordObject(triggerProperty.serializedObject.targetObject, "Add Trigger Targets");
using (var set = TempCollection.GetSet <UnityEngine.Object>())
{
for (int i = 0; i < trigger.Targets.Count; i++)
{
set.Add(trigger.Targets[i].Target);
}
foreach (var obj in objs)
{
if (set.Contains(obj))
{
continue;
}
set.Add(obj);
var targ = trigger.AddNew();
if (TriggerTarget.IsValidTriggerTarget(obj, TriggerActivationType.TriggerAllOnTarget))
{
targ.ConfigureTriggerAll(obj);
}
else
{
targ.ConfigureCallMethod(obj, "");
}
targ.Weight = 1f;
}
}
triggerProperty.serializedObject.Update();
}
catch (System.Exception ex)
{
Debug.LogException(ex);
}
}
public static TriggerParam CreateBool(TriggerTarget target, Item specifiedTargetItem, string key, bool boolValue)
{
var value = new TriggerValue();
value.BoolValue = boolValue;
var param = new TriggerParam(target, null, key, ParameterType.Bool, value);
return(param);
}
public static TriggerParam CreateFloat(TriggerTarget target, Item specifiedTargetItem, string key, float floatValue)
{
var value = new TriggerValue();
value.FloatValue = floatValue;
var param = new TriggerParam(target, null, key, ParameterType.Float, value);
return(param);
}
public static TriggerParam CreateInteger(TriggerTarget target, Item specifiedTargetItem, string key, int intValue)
{
var value = new TriggerValue();
value.IntegerValue = intValue;
var param = new TriggerParam(target, null, key, ParameterType.Integer, value);
return(param);
}
public void OnCancelButtonClick()
{
var triggerData = new MessageBoxTriggerData
{
ButtonPressed = MessageBoxButtonType.Negative,
Sender = this,
};
TriggerTarget.Trigger(triggerData);
}
public void OnCancelButtonClick()
{
// Run callback to close message box and unfreeze canvas
MessageBoxTriggerData triggerData = new MessageBoxTriggerData
{
ButtonPressed = MessageBoxButtonType.Negative,
Sender = this
};
TriggerTarget.Trigger(triggerData);
}
void Start()
{
triggerTarget = FindObjectOfType <TriggerTarget>(); //Find triggerTarget
this.transform.position = triggerTarget.transform.position; //Set position of this GO same as position of triggerTarget
this.transform.localScale = triggerTarget.transform.lossyScale;
audioManager = FindObjectOfType <AudioManager>(); //Get AudioManager (unable to do it via prefabs)
if (!letter || !letterTXT)
{
Debug.LogWarning("Letter or TextMesh missing!"); //Check for Letter and TextMeshLetter
}
}
public void OnConfirmButtonClick()
{
var triggerData = new MessageBoxTriggerData
{
ButtonPressed = MessageBoxButtonType.Positive,
Sender = this,
NumberInput = SliderValue
};
TriggerTarget.Trigger(triggerData);
}
/*
* If the specified trigger behavior is Move, moves the game object to the
* specified coordinates, sets the move coordinates to the old coordinates,
* and returns true. If not, returns false.
*/
public override void Trigger(TriggerTarget.TriggerBehavior triggerType)
{
if (triggerType != TriggerTarget.TriggerBehavior.Move)
return;
Vector3 temp = gameObject.transform.position;
gameObject.transform.position = new Vector3(xCoordinate, yCoordinate, zCoordinate);
xCoordinate = temp.x;
yCoordinate = temp.y;
zCoordinate = temp.z;
PrintMessage();
}
public override string FormatTarget(TriggerTarget target)
{
switch (target)
{
case TriggerTarget.Item:
return("This");
case TriggerTarget.Player:
return("Owner");
default:
return(target.ToString());
}
}
static bool TryGetKey(TriggerTarget target, ItemId senderItemId, IItem specifiedTarget, GameObject collidedObject, string triggerKey, out string key)
{
key = default;
switch (target)
{
case TriggerTarget.Item:
key = RoomStateKey.GetItemKey(senderItemId.Value, triggerKey);
return(true);
case TriggerTarget.SpecifiedItem:
if (specifiedTarget == null)
{
return(false);
}
if (specifiedTarget.gameObject == null)
{
return(false);
}
key = RoomStateKey.GetItemKey(specifiedTarget.Id.Value, triggerKey);
return(true);
case TriggerTarget.Player:
key = RoomStateKey.GetPlayerKey(triggerKey);
return(true);
case TriggerTarget.CollidedItemOrPlayer:
if (collidedObject.CompareTag("Player"))
{
key = RoomStateKey.GetPlayerKey(triggerKey);
return(true);
}
var collidedItem = collidedObject.GetComponentInParent <IItem>();
if (collidedItem != null)
{
key = RoomStateKey.GetItemKey(collidedItem.Id.Value, triggerKey);
return(true);
}
return(false);
case TriggerTarget.Global:
key = RoomStateKey.GetGlobalKey(triggerKey);
return(true);
default:
throw new NotImplementedException();
}
}
public void OnCancelButtonClick()
{
if (TriggerTarget != null)
{
MessageBoxTriggerData triggerData = new MessageBoxTriggerData
{
ButtonPressed = MessageBoxButtonType.Negative,
Sender = this
};
TriggerTarget.Trigger(triggerData);
}
else
{
Destroy(gameObject);
}
}
public static void FireTrigger(Vector2 Position, TriggerTypes trigger, TriggerTarget Target, int Value = 0, int Value2 = 0, float Value3 = 0, float Value4 = 0, float Value5 = 0)
{
List <TerraGuardian> tgs = new List <TerraGuardian>();
foreach (int key in MainMod.ActiveGuardians.Keys)
{
bool Run = true;
if ((trigger == TriggerTypes.Death || trigger == TriggerTypes.Spotted) &&
(Target.TargetType == TriggerTarget.TargetTypes.TerraGuardian && Target.TargetID == key))
{
Run = false;
}
if (Run && (Position == Vector2.Zero || MainMod.ActiveGuardians[key].InPerceptionRange(Position)))
{
MainMod.ActiveGuardians[key].DoTrigger(trigger, Target, Value, Value2, Value3, Value4, Value5);
tgs.Add(MainMod.ActiveGuardians[key]);
}
}
TerraGuardian.DoTriggerGroup(tgs, trigger, Target, Value, Value2, Value3, Value4, Value5);
}
public void OnOpenButtonClick()
{
// If no selection, do nothing
if (CurrentlySelectedEntry == null)
{
return;
}
string filename = CurrentlySelectedEntry.Text.GetComponent <Text>().text;
string fullname = filename + ".json";
string fullpath = Directories.SAVEFILE_FOLDER_FULL_PATH + "/" + fullname;
// If file has invalid name, show error dialog
if (filename.IndexOfAny(Path.GetInvalidFileNameChars()) != -1 ||
String.IsNullOrWhiteSpace(filename))
{
MessageBoxFactory.MakeFromConfig(OpenBadNameMessageBoxConfig, this);
return;
}
// If file does not exist, show error dialog
if (!File.Exists(fullpath))
{
MessageBoxFactory.MakeFromConfig(OpenNoFileMessageBoxConfig, this);
return;
}
// Run callback to open circuit, close message box, and unfreeze canvas
MessageBoxTriggerData triggerData = new MessageBoxTriggerData
{
ButtonPressed = MessageBoxButtonType.Positive,
Sender = this,
TextInput = filename
};
TriggerTarget.Trigger(triggerData);
}
public override bool WhenTriggerActivates(TerraGuardian guardian, TriggerTypes trigger, TriggerTarget Sender, int Value, int Value2 = 0, float Value3 = 0, float Value4 = 0, float Value5 = 0)
{
switch (trigger)
{
case TriggerTypes.Downed:
{
if (Sender.TargetType == TriggerTarget.TargetTypes.TerraGuardian)
{
TerraGuardian tg = MainMod.ActiveGuardians[Sender.TargetID];
AlexanderData data = (AlexanderData)guardian.Data;
if (!guardian.DoAction.InUse && !tg.MyID.IsSameID(guardian) && tg.Base.IsTerraGuardian && !data.WasGuardianIdentified(tg))
{
if (guardian.StartNewGuardianAction(new Companions.Alexander.SleuthAction(tg), 0))
{
return(true);
}
}
}
}
break;
case TriggerTypes.Spotted:
{
if (Sender.TargetType == TriggerTarget.TargetTypes.TerraGuardian)
{
TerraGuardian tg = MainMod.ActiveGuardians[Sender.TargetID];
AlexanderData data = (AlexanderData)guardian.Data;
if (!guardian.DoAction.InUse && !tg.MyID.IsSameID(guardian) && tg.Base.IsTerraGuardian && tg.IsSleeping && !data.WasGuardianIdentified(tg))
{
if (guardian.StartNewGuardianAction(new Companions.Alexander.SleuthAction(tg), 0))
{
return(true);
}
}
}
}
break;
}
return(base.WhenTriggerActivates(guardian, trigger, Sender, Value, Value2, Value3, Value4, Value5));
}
public virtual string FormatTarget(TriggerTarget target)
{
return(target.ToString());
}
void Start()
{
triggerTarget = GetComponent <TriggerTarget>();
}
protected EnableDisableTriggerStatement(Sequence<Qualified<SchemaName, TriggerName>> triggerNames, TriggerTarget target) {
Debug.Assert(target != null);
this.target = target;
this.triggerNames = triggerNames.ToList();
}
public EnableTriggerStatement(Sequence<Qualified<SchemaName, TriggerName>> triggerNames, TriggerTarget target): base(triggerNames, target) {}
private void _targetList_DrawElement(Rect area, int index, bool isActive, bool isFocused)
{
var element = _targetList.serializedProperty.GetArrayElementAtIndex(index);
var targProp = element.FindPropertyRelative(TriggerTargetPropertyDrawer.PROP_TRIGGERABLETARG);
const float MARGIN = 1.0f;
const float WEIGHT_FIELD_WIDTH = 60f;
const float PERC_FIELD_WIDTH = 45f;
const float FULLWEIGHT_WIDTH = WEIGHT_FIELD_WIDTH + PERC_FIELD_WIDTH;
EditorGUI.BeginProperty(area, GUIContent.none, targProp);
Rect trigRect;
if (_drawWeight && area.width > FULLWEIGHT_WIDTH)
{
var top = area.yMin + MARGIN;
var labelRect = new Rect(area.xMin, top, EditorGUIUtility.labelWidth - FULLWEIGHT_WIDTH, EditorGUIUtility.singleLineHeight);
var weightRect = new Rect(area.xMin + EditorGUIUtility.labelWidth - FULLWEIGHT_WIDTH, top, WEIGHT_FIELD_WIDTH, EditorGUIUtility.singleLineHeight);
var percRect = new Rect(area.xMin + EditorGUIUtility.labelWidth - PERC_FIELD_WIDTH, top, PERC_FIELD_WIDTH, EditorGUIUtility.singleLineHeight);
trigRect = new Rect(area.xMin + EditorGUIUtility.labelWidth, top, area.width - EditorGUIUtility.labelWidth, EditorGUIUtility.singleLineHeight);
var weightProp = element.FindPropertyRelative(PROP_WEIGHT);
float weight = weightProp.floatValue;
if (this.OnDrawCustomizedEntryLabel != null)
{
this.OnDrawCustomizedEntryLabel(labelRect, element, index);
}
else
{
DrawDefaultListElementLabel(labelRect, element, index);
}
weightProp.floatValue = EditorGUI.FloatField(weightRect, weight);
float p = (_totalWeight > 0f) ? (100f * weight / _totalWeight) : ((index == 0) ? 100f : 0f);
EditorGUI.LabelField(percRect, string.Format("{0:0.#}%", p));
}
else
{
//Draw Triggerable - this is the simple case to make a clean designer set up for newbs
var top = area.yMin + MARGIN;
var labelRect = new Rect(area.xMin, top, EditorGUIUtility.labelWidth, EditorGUIUtility.singleLineHeight);
trigRect = new Rect(area.xMin + EditorGUIUtility.labelWidth, top, area.width - EditorGUIUtility.labelWidth, EditorGUIUtility.singleLineHeight);
if (this.OnDrawCustomizedEntryLabel != null)
{
this.OnDrawCustomizedEntryLabel(labelRect, element, index);
}
else
{
DrawDefaultListElementLabel(labelRect, element, index);
}
}
//Draw Triggerable - this is the simple case to make a clean designer set up for newbs
EditorGUI.BeginChangeCheck();
var targObj = TriggerTargetPropertyDrawer.TargetObjectField(trigRect, GUIContent.none, targProp.objectReferenceValue);
if (EditorGUI.EndChangeCheck())
{
var actInfo = TriggerTargetPropertyDrawer.GetTriggerActivationInfo(element);
targProp.objectReferenceValue = TriggerTarget.IsValidTriggerTarget(targObj, actInfo.ActivationType) ? targObj : null;
}
EditorGUI.EndProperty();
ReorderableListHelper.DrawDraggableElementDeleteContextMenu(_targetList, area, index, isActive, isFocused);
}
public IntervalTrigger(TimeSpan interval, TriggerTarget target)
{
this.elapsedTime = TimeSpan.Zero;
this.interval = interval;
this.target = target;
}
public void PostTrigger(bool trigger)
{
TriggerTarget.Post(trigger);
}
public override bool WhenTriggerActivates(TerraGuardian guardian, TriggerTypes trigger, TriggerTarget Sender, int Value, int Value2 = 0, float Value3 = 0, float Value4 = 0, float Value5 = 0)
{
/*if (!guardian.DoAction.InUse)
{
if (trigger == TriggerTypes.Hurt)
{
switch (Sender.TargetType)
{
case TriggerTarget.TargetTypes.Player:
{
guardian.StartNewGuardianAction(new Alex.HealingLickAction(Main.player[Sender.TargetID]), HealingLickAction);
}
break;
case TriggerTarget.TargetTypes.TerraGuardian:
{
guardian.StartNewGuardianAction(new Alex.HealingLickAction(MainMod.ActiveGuardians[Sender.TargetID]), HealingLickAction);
}
break;
}
}
}*/
return base.WhenTriggerActivates(guardian, trigger, Sender, Value, Value2, Value3, Value4, Value5);
}
public EnableTriggerStatement(TriggerTarget target): this(null, target) {}
private void DrawAdvanced_TriggerAll(Rect area, SerializedProperty property)
{
//Draw Target
/*
* var targRect = new Rect(area.xMin, area.yMin, area.width, EditorGUIUtility.singleLineHeight);
* var targProp = property.FindPropertyRelative(TriggerTargetPropertyDrawer.PROP_TRIGGERABLETARG);
* var targLabel = EditorHelper.TempContent("Triggerable Target");
* var targGo = GameObjectUtil.GetGameObjectFromSource(targProp.objectReferenceValue);
* var newTargGo = EditorGUI.ObjectField(targRect, targLabel, targGo, typeof(GameObject), true) as GameObject;
* if (newTargGo != targGo)
* {
* targGo = newTargGo;
* targProp.objectReferenceValue = (targGo != null) ? targGo.transform : null;
* }
*/
var targRect = new Rect(area.xMin, area.yMin, area.width, EditorGUIUtility.singleLineHeight);
var targProp = property.FindPropertyRelative(TriggerTargetPropertyDrawer.PROP_TRIGGERABLETARG);
var targLabel = EditorHelper.TempContent("Triggerable Target");
EditorGUI.BeginChangeCheck();
var targObj = TargetObjectField(targRect, targLabel, targProp.objectReferenceValue);
if (EditorGUI.EndChangeCheck())
{
targProp.objectReferenceValue = TriggerTarget.IsValidTriggerTarget(targObj, TriggerActivationType.TriggerAllOnTarget) ? targObj : null;
}
//Draw Triggerable Arg
var argRect = new Rect(area.xMin, targRect.yMax, area.width - ARG_BTN_WIDTH, EditorGUIUtility.singleLineHeight);
var btnRect = new Rect(argRect.xMax, argRect.yMin, ARG_BTN_WIDTH, EditorGUIUtility.singleLineHeight);
var argArrayProp = property.FindPropertyRelative(TriggerTargetPropertyDrawer.PROP_TRIGGERABLEARGS);
if (argArrayProp.arraySize == 0)
{
EditorGUI.LabelField(argRect, _defaultArgLabel, _undefinedArgLabel);
if (GUI.Button(btnRect, _argBtnLabel))
{
argArrayProp.arraySize = 1;
argArrayProp.serializedObject.ApplyModifiedProperties();
}
}
else
{
if (argArrayProp.arraySize > 1)
{
argArrayProp.arraySize = 1;
}
var argProp = argArrayProp.GetArrayElementAtIndex(0);
//EditorGUI.PropertyField(argRect, argProp, _defaultArgLabel);
_variantDrawer.RestrictVariantType = false;
_variantDrawer.ForcedObjectType = null;
_variantDrawer.OnGUI(argRect, argProp, _defaultArgLabel);
if (GUI.Button(btnRect, _argBtnLabel))
{
argArrayProp.arraySize = 0;
argArrayProp.serializedObject.ApplyModifiedProperties();
}
}
}
