internal TriggerGroup CreateTriggerGroup(int _coordinate)
{
TriggerGroup _group = new TriggerGroup(_coordinate, GetNextGroupID(_coordinate));
TriggerGroupList.Add(_group);
return(_group);
}
internal void RemoveTriggerGroupState(int _coordinate, int _kind, int _state)
{
TriggerGroup _group = GetTriggerGroup(_coordinate, _kind);
if (_group == null)
{
return;
}
if (!_group.States.ContainsKey(_state))
{
return;
}
if (_state == 0 || _state == 1)
{
_logger.LogMessage($"Removing the first two states is restricted");
return;
}
TriggerPropertyList.RemoveAll(x => x.Coordinate == _coordinate && x.RefKind == _kind && x.RefState == _state);
_group.States.Remove(_state);
if (_group.Startup == _state)
{
_group.Startup = 0;
}
if (_group.State == _state)
{
_group.State = _group.Startup;
}
}
internal void MissingGroupCheck(int _coordinate)
{
string _name = _cordNames[_coordinate];
HashSet <int> _kinds = new HashSet <int>(TriggerPropertyList.Where(x => x.Coordinate == _coordinate && x.RefKind >= 9).OrderBy(x => x.RefKind).Select(x => x.RefKind));
foreach (int _kind in _kinds)
{
HashSet <int> _states = new HashSet <int>(TriggerPropertyList.Where(x => x.Coordinate == _coordinate && x.RefKind == _kind).OrderBy(x => x.RefState).Select(x => x.RefState));
TriggerGroup _group = GetTriggerGroup(_coordinate, _kind);
if (_group == null)
{
_logger.LogMessage($"Group info on {_name} for group {_group.Label} added because of absent");
_group = new TriggerGroup(_coordinate, _kind);
}
foreach (int _state in _states)
{
if (_group.States.ContainsKey(_state))
{
continue;
}
_group.AddNewState(_state);
_logger.LogMessage($"State info on {_name} for group {_group.Label} state {_group.States[_state]} added because of absent");
}
}
}
internal void CloneAsNewTriggerGroupState(int _coordinate, int _kind, int _state)
{
TriggerGroup _group = GetTriggerGroup(_coordinate, _kind);
if (_group == null)
{
return;
}
if (!_group.States.ContainsKey(_state))
{
return;
}
int _newState = _group.AddNewState();
TriggerPropertyList.RemoveAll(x => x.Coordinate == _coordinate && x.RefKind == _kind && x.RefState == _newState);
List <TriggerProperty> _tempTriggerProperty = TriggerPropertyList.Where(x => x.Coordinate == _coordinate && x.RefKind == _kind && x.RefState == _state).ToList().JsonClone() as List <TriggerProperty>;
if (_tempTriggerProperty?.Count == 0)
{
return;
}
foreach (TriggerProperty x in _tempTriggerProperty)
{
x.RefState = _newState;
}
TriggerPropertyList.AddRange(_tempTriggerProperty);
}
public AnimProxy()
{
animFlusher = new TriggerGroup(Flush);
animFlusher.AddTrigger(targetAnim);
animFlusher.AddTrigger(anim);
animFlusher.AddTrigger(animWrapMode);
}
public void 改值回调()
{
TriggerGroupElement <int> i = new TriggerGroupElement <int>(2);
TriggerGroupElement <float> j = new TriggerGroupElement <float>(1.0f);
int calledTimes = 0;
TriggerGroup group = new TriggerGroup(() => {
calledTimes++;
});
group.AddTrigger(i);
group.AddTrigger(j);
group.Operate(opr => {
opr.SetValue(i, 3);
}
);
Assert.AreEqual(calledTimes, 1);
group.Operate(opr => {
opr.SetValue(i, 5);
opr.SetValue(j, 2f);
}
);
Assert.AreEqual(calledTimes, 2);
group.Operate(value =>
{
int TestResult = i.GetValue();
});
Assert.AreEqual(calledTimes, 2);
}
public TriggerGroup AddSkillTrigger(SkillInfo skillInfo)
{
//Debug.Log("AddSkillTrigger");
TriggerGroup group = AddTriggerGroup();
group.LoadDataWithSkill(skillInfo);
return(group);
}
public void Start()
{
//Debug.Log("SkillEvent_Start");
TriggerGroup trigger = GetSpareTriggerGroup();
Reset(trigger, true);
//Debug.Log("triggerGroup--------------" + triggerGroup.Id + "-----" + triggerGroup.GetActive());
eventDispatcher.Broadcast("SkillEvent_start");
}
/// <summary>
/// 初始化接口
/// </summary>
/// <param name="control"></param>
public PlayerPosBehaviour(IPosControl control)
{
posControl = control;
currentPos = new Triggable <Vector2>(control.GetPos(), OnCurrentPosChanged);
timeSpanCalculator = new TriggerGroup(RecalulateTimeSpan, OnBeforeChange);
timeSpanCalculator.AddTrigger(targetPos);
timeSpanCalculator.AddTrigger(speed);
}
internal void RenameTriggerGroup(int _coordinate, int _kind, string _label)
{
TriggerGroup _group = GetTriggerGroup(_coordinate, _kind);
if (_group == null)
{
return;
}
_group.Rename(_label);
}
internal void SetSecondaryGroup(int _coordinate, int _kind, int _secondary)
{
TriggerGroup _group = GetTriggerGroup(_coordinate, _kind);
if (_group == null)
{
return;
}
_group.Secondary = _secondary;
}
internal void SetGroupState(int _kind, int _state)
{
if (!_cachedGroupKind.Contains(_kind))
{
return;
}
TriggerGroup _group = _cachedCoordinateGroupList.Where(x => x.Kind == _kind).First();
_group.State = _state;
ToggleByRefKind(_kind);
}
internal TriggerGroup NewOrGetTriggerGroup(int _coordinate, int _kind)
{
TriggerGroup _group = GetTriggerGroup(_coordinate, _kind);
if (_group == null)
{
_group = new TriggerGroup(_coordinate, _kind);
TriggerGroupList.Add(_group);
}
return(_group);
}
// Token: 0x0600212A RID: 8490
// RVA: 0x0001AE2D File Offset: 0x0001902D
internal void method_3(TriggerGroup triggerGroup_1)
{
if (triggerGroup_1 > TriggerGroup.None)
{
throw new InvalidOperationException("Invalid trigger group");
}
if (this.triggerGroup_0 != TriggerGroup.None)
{
throw new InvalidOperationException("A trigger's group can't be changed once set");
}
this.triggerGroup_0 = triggerGroup_1;
}
internal void RemoveAllLoops(TriggerGroup triggerGroup)
{
List <TriggerLoop> list;
if (EventLoopTriggers.TryGetValue(triggerGroup, out list))
{
foreach (TriggerLoop l in list)
{
RemoveLoop(l);
}
}
}
public void End(TriggerGroup trigger)
{
trigger.isActive = false;
foreach (TriggerGroup v in triggerGroupList)
{
if (v.GetActive())
{
return;
}
}
//Debug.Log("SkillEvent_End");
this.isActive = false;
}
public TriggerGroup GetSpareTriggerGroup()
{
foreach (TriggerGroup trigger in triggerGroupList)
{
if (!trigger.GetActive())
{
return(trigger);
}
}
TriggerGroup trigger1 = TriggerManager.getInstance().AddSkillTrigger(this);
triggerGroupList.Add(trigger1);
return(trigger1);
}
public void Execute(object parameter)
{
AddTriggerGroupView view = new AddTriggerGroupView();
var dataContext = new TriggerGroup(_solutionDirectory);
dataContext.AvailableGenerators = _viewModel.ConfigData.Generators.Select(generator => generator.Name);
dataContext.AvailableProjects = _uniqueProjectNames;
view.DataContext = dataContext;
if (view.ShowDialog() == true)
{
_viewModel.ConfigData.TriggerGroups.Add(dataContext);
}
}
TriggerGroup AddTriggerGroup()
{
triggerGroupId++;
TriggerGroup group = new TriggerGroup(triggerGroupId);
if (triggerGroups.ContainsKey(triggerGroupId))
{
triggerGroups[triggerGroupId] = group;
}
else
{
triggerGroups.Add(triggerGroupId, group);
}
return(group);
}
internal void SetSpecificTriggerGroup(TriggerGroup triggerGroup)
{
// Prevents default groups to be picked
if ((int)triggerGroup > 0)
{
throw new InvalidOperationException("Invalid trigger group");
}
// The group can't be changed once set because it might be already listed in an Event's EventLoopTriggers
if (specificTriggerGroup != TriggerGroup.None)
{
throw new InvalidOperationException("A trigger's group can't be changed once set");
}
specificTriggerGroup = triggerGroup;
}
public void Update(float deltaTime)
{
foreach (int key in triggerGroups.Keys)
{
TriggerGroup group = triggerGroups[key];
if (group.GetActive())
{
foreach (TriggerInfo trigger in group.triggerInfos)
{
//Debug.Log("triggerInfo Id = " + trigger.Id + "Active = " + trigger.GetActive());
if (trigger.GetActive())
{
TickTrigger(trigger, deltaTime);
}
}
}
}
}
internal void SetGroupStateNext(int _kind)
{
if (!_cachedGroupKind.Contains(_kind))
{
return;
}
TriggerGroup _group = _cachedCoordinateGroupList.Where(x => x.Kind == _kind).First();
int _state = _group.State;
List <int> _states = _group.States.OrderBy(x => x.Key).Select(x => x.Key).ToList();
int _index = _states.IndexOf(_state);
if (_index == _states.Count - 1)
{
_group.State = _states[0];
}
else
{
_group.State = _states[_index + 1];
}
ToggleByRefKind(_kind);
}
internal void MissingPropertyCheck(int _coordinate)
{
string _name = _cordNames[_coordinate];
HashSet <int> _kinds = new HashSet <int>(TriggerPropertyList.Where(x => x.Coordinate == _coordinate).OrderBy(x => x.RefKind).Select(x => x.RefKind));
foreach (int _kind in _kinds)
{
HashSet <int> _slots = new HashSet <int>(TriggerPropertyList.Where(x => x.Coordinate == _coordinate && x.RefKind == _kind).OrderBy(x => x.Slot).Select(x => x.Slot));
foreach (int _slot in _slots)
{
List <TriggerProperty> _list = TriggerPropertyList.Where(x => x.Coordinate == _coordinate && x.RefKind == _kind && x.Slot == _slot).OrderBy(x => x.RefState).ToList();
if (_kind < 9 && _list.Count < 4)
{
for (int _state = 0; _state <= 3; _state++)
{
if (_list.Any(x => x.RefState == _state))
{
continue;
}
TriggerPropertyList.Add(new TriggerProperty(_coordinate, _slot, _kind, _state));
_logger.LogMessage($"Triggers on {_name} slot {_slot + 1:00} for group {_clothesNames[_kind]} state {_statesNames[_state]} added because of absent");
}
}
else if (_kind >= 9)
{
TriggerGroup _group = GetTriggerGroup(_coordinate, _kind);
foreach (int _state in _group.States.Keys)
{
if (_list.Any(x => x.RefState == _state))
{
continue;
}
TriggerPropertyList.Add(new TriggerProperty(_coordinate, _slot, _kind, _state));
_logger.LogMessage($"Triggers on {_name} slot {_slot + 1:00} for group {_group.Label} state {_group.States[_state]} added because of absent");
}
}
}
}
}
private static TriggerGroup DebuffOnTargetTrigger(string debuff)
{
var trigger = new TriggerGroup
{
Trigger = new Trigger
{
AuraNames = new List <string> {
debuff
},
AuraSpellIds = new List <string>(),
DebuffType = "HARMFUL",
Duration = "1",
Event = "Cooldown Progress (Spell)",
GenericShowOn = "showAlways",
Names = new List <string>(),
OwnOnly = true,
SpellIds = new List <long>(),
SubeventPrefix = "SPELL",
SubeventSuffix = "_CAST_START",
Track = "auto",
Type = "aura2",
Unevent = "auto",
Unit = "target",
UseGenericShowOn = true,
// todo: all these needed?
UseSpellName = true,
UseTrack = true,
UseUnit = true,
UseName = true,
},
UnTrigger = new UnTrigger
{
GenericShowOn = "showAlways"
}
};
return(trigger);
}
void DrawGroupScene(int index)
{
TriggerGroup group = spline.triggerGroups[index];
for (int i = 0; i < group.triggers.Length; i++)
{
SplineComputerEditorHandles.SplineSliderGizmo gizmo = SplineComputerEditorHandles.SplineSliderGizmo.DualArrow;
switch (group.triggers[i].type)
{
case SplineTrigger.Type.Backward: gizmo = SplineComputerEditorHandles.SplineSliderGizmo.BackwardTriangle; break;
case SplineTrigger.Type.Forward: gizmo = SplineComputerEditorHandles.SplineSliderGizmo.ForwardTriangle; break;
case SplineTrigger.Type.Double: gizmo = SplineComputerEditorHandles.SplineSliderGizmo.DualArrow; break;
}
double last = group.triggers[i].position;
if (SplineComputerEditorHandles.Slider(spline, ref group.triggers[i].position, group.triggers[i].color, group.triggers[i].name, gizmo) || last != group.triggers[i].position)
{
Select(index, i);
Repaint();
}
}
}
public override void DrawInspector()
{
base.DrawInspector();
EditorGUI.BeginChangeCheck();
EditorGUILayout.BeginVertical();
for (int i = 0; i < spline.triggerGroups.Length; i++)
{
DrawGroupGUI(i);
}
EditorGUILayout.Space();
if (GUILayout.Button("New Group"))
{
RecordUndo("Add Trigger Group");
TriggerGroup group = new TriggerGroup();
group.name = "Trigger Group " + (spline.triggerGroups.Length + 1);
ArrayUtility.Add(ref spline.triggerGroups, group);
}
EditorGUILayout.EndVertical();
if (EditorGUI.EndChangeCheck())
{
SceneView.RepaintAll();
}
}
private static TriggerGroup AbilityCooldownTrigger(string ability, IEnumerable <int> spells) // int spellId)
{
var trigger = new TriggerGroup
{
Trigger = new Trigger
{
// AuraNames = new List<string>(),
// AuraSpellIds = new List<string>(),
DebuffType = "HELPFUL", //
Duration = "1", //
Event = "Cooldown Progress (Spell)", //
GenericShowOn = "showAlways", //
Names = new List <string>(), //
RealSpellName = ability, //
SpellName = spells.First(),
// OwnOnly = true,
SpellIds = spells.Select(s => (long)s).ToList(), //
SubeventPrefix = "SPELL", //
SubeventSuffix = "_CAST_START", //
// Track = "auto",
Type = "status", //
Unevent = "auto", //
Unit = "player", //
UseGenericShowOn = true, //
UseSpellName = true, //
UseTrack = true, //
UseUnit = true, //
// UseName = true,
},
UnTrigger = new UnTrigger
{
GenericShowOn = "showAlways"
}
};
return(trigger);
}
public void Reset(TriggerGroup trigger, bool isActive)
{
this.isActive = isActive;
trigger.Reset(isActive);
}
public void LoadData()
{
TriggerGroup triggerGroup = TriggerManager.getInstance().AddSkillTrigger(this);
triggerGroupList.Add(triggerGroup);
}
void DrawTriggerGUI(int index, int groupIndex, SerializedProperty groupProperty)
{
bool isSelected = selected == index && selectedGroup == groupIndex;
TriggerGroup group = spline.triggerGroups[groupIndex];
SplineTrigger trigger = group.triggers[index];
SerializedProperty triggersProperty = groupProperty.FindPropertyRelative("triggers");
SerializedProperty triggerProperty = triggersProperty.GetArrayElementAtIndex(index);
SerializedProperty eventProperty = triggerProperty.FindPropertyRelative("onCross");
SerializedProperty positionProperty = triggerProperty.FindPropertyRelative("position");
SerializedProperty colorProperty = triggerProperty.FindPropertyRelative("color");
SerializedProperty nameProperty = triggerProperty.FindPropertyRelative("name");
SerializedProperty enabledProperty = triggerProperty.FindPropertyRelative("enabled");
SerializedProperty workOnceProperty = triggerProperty.FindPropertyRelative("workOnce");
SerializedProperty typeProperty = triggerProperty.FindPropertyRelative("type");
Color col = colorProperty.colorValue;
if (isSelected)
{
col.a = 1f;
}
else
{
col.a = 0.6f;
}
GUI.backgroundColor = col;
EditorGUILayout.BeginVertical(GUI.skin.box);
GUI.backgroundColor = Color.white;
if (trigger == null)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label("NULL");
if (GUILayout.Button("x"))
{
ArrayUtility.RemoveAt(ref group.triggers, index);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
return;
}
if (isSelected && renameTrigger)
{
if (Event.current.type == EventType.KeyDown && (Event.current.keyCode == KeyCode.Return || Event.current.keyCode == KeyCode.KeypadEnter))
{
renameTrigger = false;
Repaint();
}
nameProperty.stringValue = EditorGUILayout.TextField(nameProperty.stringValue);
}
else
{
EditorGUILayout.LabelField(nameProperty.stringValue);
}
if (isSelected)
{
EditorGUILayout.Space();
EditorGUILayout.PropertyField(enabledProperty);
EditorGUILayout.PropertyField(colorProperty);
EditorGUILayout.BeginHorizontal();
positionProperty.floatValue = EditorGUILayout.Slider("Position", positionProperty.floatValue, 0f, 1f);
if (GUILayout.Button("Set Distance", GUILayout.Width(85)))
{
DistanceWindow w = EditorWindow.GetWindow <DistanceWindow>(true);
w.Init(OnSetDistance, spline.CalculateLength());
setDistanceGroup = groupIndex;
setDistanceTrigger = index;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.PropertyField(typeProperty);
EditorGUILayout.PropertyField(workOnceProperty);
EditorGUILayout.PropertyField(eventProperty);
}
EditorGUILayout.EndVertical();
Rect lastRect = GUILayoutUtility.GetLastRect();
if (lastRect.Contains(Event.current.mousePosition) && Event.current.type == EventType.MouseDown)
{
if (Event.current.button == 0)
{
Select(groupIndex, index);
}
else if (Event.current.button == 1)
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Deselect"), false, delegate { Select(-1, -1); });
menu.AddItem(new GUIContent("Rename"), false, delegate { Select(groupIndex, index); renameTrigger = true; renameGroup = false; });
if (index > 0)
{
menu.AddItem(new GUIContent("Move Up"), false, delegate {
RecordUndo("Move Trigger Up");
SplineTrigger temp = group.triggers[index - 1];
group.triggers[index - 1] = trigger;
group.triggers[index] = temp;
selected--;
renameTrigger = false;
});
}
else
{
menu.AddDisabledItem(new GUIContent("Move Up"));
}
if (index < group.triggers.Length - 1)
{
menu.AddItem(new GUIContent("Move Down"), false, delegate {
RecordUndo("Move Trigger Down");
SplineTrigger temp = group.triggers[index + 1];
group.triggers[index + 1] = trigger;
group.triggers[index] = temp;
selected--;
renameTrigger = false;
});
}
else
{
menu.AddDisabledItem(new GUIContent("Move Down"));
}
menu.AddItem(new GUIContent("Duplicate"), false, delegate {
RecordUndo("Duplicate Trigger");
SplineTrigger newTrigger = new SplineTrigger(SplineTrigger.Type.Double);
newTrigger.color = colorProperty.colorValue;
newTrigger.enabled = enabledProperty.boolValue;
newTrigger.position = positionProperty.floatValue;
newTrigger.type = (SplineTrigger.Type)typeProperty.intValue;
newTrigger.name = "Trigger " + (group.triggers.Length + 1);
ArrayUtility.Add(ref group.triggers, newTrigger);
Select(groupIndex, group.triggers.Length - 1);
});
menu.AddItem(new GUIContent("Delete"), false, delegate {
RecordUndo("Delete Trigger");
ArrayUtility.RemoveAt(ref group.triggers, index);
Select(-1, -1);
});
menu.ShowAsContext();
}
}
}
void DrawGroupGUI(int index)
{
TriggerGroup group = spline.triggerGroups[index];
SerializedObject serializedObject = new SerializedObject(spline);
SerializedProperty groups = serializedObject.FindProperty("triggerGroups");
SerializedProperty groupProperty = groups.GetArrayElementAtIndex(index);
EditorGUI.indentLevel += 2;
if (selectedGroup == index && renameGroup)
{
if (Event.current.type == EventType.KeyDown && (Event.current.keyCode == KeyCode.Return || Event.current.keyCode == KeyCode.KeypadEnter))
{
renameGroup = false;
Repaint();
}
group.name = EditorGUILayout.TextField(group.name);
}
else
{
group.open = EditorGUILayout.Foldout(group.open, index + " - " + group.name);
}
Rect lastRect = GUILayoutUtility.GetLastRect();
if (lastRect.Contains(Event.current.mousePosition) && Event.current.type == EventType.MouseDown && Event.current.button == 1)
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Rename"), false, delegate { RecordUndo("Rename Trigger Group"); selectedGroup = index; renameGroup = true; renameTrigger = false; Repaint(); });
menu.AddItem(new GUIContent("Delete"), false, delegate {
RecordUndo("Delete Trigger Group");
ArrayUtility.RemoveAt(ref spline.triggerGroups, index);
Repaint();
});
menu.ShowAsContext();
}
EditorGUI.indentLevel -= 2;
if (!group.open)
{
return;
}
for (int i = 0; i < group.triggers.Length; i++)
{
DrawTriggerGUI(i, index, groupProperty);
}
if (GUI.changed)
{
serializedObject.ApplyModifiedProperties();
}
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Add Trigger"))
{
RecordUndo("Add Trigger");
SplineTrigger newTrigger = new SplineTrigger(addTriggerType);
newTrigger.name = "Trigger " + (group.triggers.Length + 1);
ArrayUtility.Add(ref group.triggers, newTrigger);
}
addTriggerType = (SplineTrigger.Type)EditorGUILayout.EnumPopup(addTriggerType);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.Space();
}
