public static void CreateRuntimeEditor(GameObject commandsPanel, string name)
{
if (!Object.FindObjectOfType <EventSystem>())
{
GameObject es = new GameObject();
es.AddComponent <EventSystem>();
es.AddComponent <StandaloneInputModule>();
es.name = "EventSystem";
}
GameObject go = new GameObject();
go.name = name;
SplineRuntimeEditor srtEditor = go.AddComponent <SplineRuntimeEditor>();
GameObject uiEditorGO = RTEditorMenu.InstantiateRuntimeEditor();
uiEditorGO.transform.SetParent(go.transform, false);
RuntimeEditor rtEditor = uiEditorGO.GetComponent <RuntimeEditor>();
UnityEventTools.AddPersistentListener(rtEditor.Closed, new UnityAction(srtEditor.OnClosed));
Placeholder[] placeholders = uiEditorGO.GetComponentsInChildren <Placeholder>(true);
Placeholder cmd = placeholders.Where(p => p.Id == Placeholder.CommandsPlaceholder).First();
commandsPanel.transform.SetParent(cmd.transform, false);
Undo.RegisterCreatedObjectUndo(go, "Battlehub.Spline.CreateRuntimeEditor");
}
public static void AddPersistentListener(this UnityEvent uEvent, Action action)
{
MethodInfo targetInfo = UnityEventBase.GetValidMethodInfo(action.Target, action.Method.Name, new Type[0]);
UnityAction methodDelegate = Delegate.CreateDelegate(typeof(UnityAction), action.Target, targetInfo) as UnityAction;
UnityEventTools.AddPersistentListener(uEvent, methodDelegate);
}
private GameObject CreateFileOpen()
{
FileOpenFactory factory = Undoable.AddComponent <FileOpenFactory>(disposable);
factory.parent = parent;
GameObject panel = factory.Generate();
fileOpenInstance = panel;
GameObject fileOpenContainer = panel.transform.parent.gameObject;
fileOpenContainer.transform.localPosition = fileOpenLocalPosition;
fileOpen = fileOpenInstance.transform.Find("DrivesPanel").GetComponent <FileOpen>();
#if UNITY_EDITOR
var onOpen = fileOpen.onOpen;
for (int i = 0; i < onOpen.GetPersistentEventCount(); i++)
{
UnityEventTools.RemovePersistentListener(onOpen, 0);
}
UnityEventTools.AddPersistentListener(onOpen, fileManager.Open);
fileOpen.onOpen = onOpen;
#endif
return(panel);
}
void Reset()
{
var button = this.GetComponent <Button>();
RemoveAllPersistentListener(button.onClick);
UnityEventTools.AddPersistentListener(button.onClick, BackScreen);
}
public static void CB_COMP_vBreakableObject(GameObject target)
{
if (target.GetComponent <vBreakableObject>())
{
if (!target.GetComponent <NetworkBreakObject>())
{
target.AddComponent <NetworkBreakObject>();
}
E_Helpers.SetObjectIcon(target, E_Core.h_genericIcon);
if (!E_PlayerEvents.HasUnityEvent(target.GetComponent <vBreakableObject>().OnBroken, "BreakObject", target.GetComponent <NetworkBreakObject>()))
{
UnityEventTools.AddPersistentListener(target.GetComponent <vBreakableObject>().OnBroken, target.GetComponent <NetworkBreakObject>().BreakObject);
}
}
if (target.GetComponentInChildren <vBreakableObject>())
{
foreach (vBreakableObject bo in target.GetComponentsInChildren <vBreakableObject>())
{
if (!bo.gameObject.GetComponent <NetworkBreakObject>())
{
bo.gameObject.AddComponent <NetworkBreakObject>();
}
if (!E_PlayerEvents.HasUnityEvent(bo.OnBroken, "BreakObject", bo.gameObject.GetComponent <NetworkBreakObject>()))
{
UnityEventTools.AddPersistentListener(bo.OnBroken, bo.gameObject.GetComponent <NetworkBreakObject>().BreakObject);
}
E_Helpers.SetObjectIcon(bo.gameObject, E_Core.h_genericIcon);
}
}
}
public static void CB_COMP_vHealthController(GameObject target)
{
if (target.GetComponent <vHealthController>())
{
if (!target.GetComponent <SyncHealthController>())
{
target.AddComponent <SyncHealthController>();
}
E_Helpers.SetObjectIcon(target, E_Core.h_genericIcon);
vHealthController hc = target.GetComponent <vHealthController>();
if (!E_PlayerEvents.HasUnityEvent(hc.onReceiveDamage, "SendDamageOverNetwork", target.GetComponent <SyncHealthController>()))
{
UnityEventTools.AddPersistentListener(hc.onReceiveDamage, target.GetComponent <SyncHealthController>().SendDamageOverNetwork);
}
}
if (target.GetComponentInChildren <vHealthController>())
{
foreach (vHealthController hc in target.GetComponentsInChildren <vHealthController>())
{
if (!hc.gameObject.GetComponent <SyncHealthController>())
{
hc.gameObject.AddComponent <SyncHealthController>();
}
E_Helpers.SetObjectIcon(hc.gameObject, E_Core.h_genericIcon);
if (!E_PlayerEvents.HasUnityEvent(hc.onReceiveDamage, "SendDamageOverNetwork", hc.gameObject.GetComponent <SyncHealthController>()))
{
UnityEventTools.AddPersistentListener(hc.onReceiveDamage, hc.gameObject.GetComponent <SyncHealthController>().SendDamageOverNetwork);
}
}
}
}
private void Reset()
{
// Finds the fisrt parent object with a CanvasMenu component and sets the _fromMenu field to that menu.
for (Transform parent = transform.parent; parent != null && parent.transform is RectTransform; parent = parent.parent)
{
if (parent.TryGetComponent <CanvasMenu>(out CanvasMenu menu))
{
_fromMenu = menu;
break;
}
}
// Adds the transition to the button's click event.
var onClick = GetComponent <Button>().onClick;
int removeAt = -1;
for (int i = 0; i < onClick.GetPersistentEventCount(); i++)
{
if (onClick.GetPersistentMethodName(i) == nameof(Transition))
{
removeAt = i;
break;
}
}
if (removeAt < 0)
{
UnityEventTools.AddPersistentListener(GetComponent <Button>().onClick, new UnityAction(Transition));
}
}
/// <summary>
/// EDITOR ONLY
/// </summary>
public static void OnValidateOnlyAddEvent(this UnityEvent e, UnityAction action)
{
#if UNITY_EDITOR
UnityEventTools.RemovePersistentListener(e, action);
UnityEventTools.AddPersistentListener(e, action);
#endif
}
private GameObject CreateFileSaveAs()
{
FileSaveAsFactory factory = Undoable.AddComponent <FileSaveAsFactory>(disposable);
factory.parent = parent;
factory.keyboard = keyboard;
GameObject panel = factory.Generate();
fileSaveAsInstance = panel;
GameObject fileSaveAsContainer = panel.transform.parent.gameObject;
fileSaveAsContainer.transform.localPosition = fileSaveAsLocalPosition;
fileSaveAs = fileSaveAsInstance.transform.Find("DrivesPanel").GetComponent <FileSaveAs>();
fileManager.saveAsPanel = fileSaveAs;
#if UNITY_EDITOR
var onSaveAs = fileSaveAs.onSaveAs;
for (int i = 0; i < onSaveAs.GetPersistentEventCount(); i++)
{
UnityEventTools.RemovePersistentListener(onSaveAs, 0);
}
UnityEventTools.AddPersistentListener(onSaveAs, fileManager.SaveAs);
fileSaveAs.onSaveAs = onSaveAs;
#endif
return(panel);
}
public void SetupPersistentListeners(object runner)
{
UnityEventTools.AddPersistentListener((UnityEvent <ITest>)runner.GetType().GetField("testStartedEvent",
BindingFlags.NonPublic | BindingFlags.Instance).GetValue(runner), new UnityAction <ITest>(test =>
{
if (!(test is TestMethod))
{
return;
}
ourLogger.Verbose("TestStarted : {0}", test.FullName);
var internalEvent = new TestInternalEvent(TestEventsSender.GetIdFromNUnitTest(test), "", 0, Status.Running, TestEventsSender.GetIdFromNUnitTest(test.Parent));
TestEventReceived(new TestEvent(EventType.TestStarted, internalEvent));
})
);
UnityEventTools.AddPersistentListener((UnityEvent <ITestResult>)runner.GetType().GetField("testFinishedEvent",
BindingFlags.NonPublic | BindingFlags.Instance).GetValue(runner), new UnityAction <ITestResult>(result =>
{
if (!(result.Test is TestMethod))
{
return;
}
var internalEvent = TestEventsSender.GetTestResult(result);
TestEventReceived(new TestEvent(EventType.TestFinished, internalEvent));
}));
UnityEventTools.AddPersistentListener((UnityEvent <ITestResult>)runner.GetType().GetField("runFinishedEvent",
BindingFlags.NonPublic | BindingFlags.Instance).GetValue(runner),
new UnityAction <ITestResult>(result =>
{
var internalEvent = new TestInternalEvent("", "", 0, Status.Success, "");
TestEventReceived(new TestEvent(EventType.RunFinished, internalEvent));
}));
}
private void InitialiseArrays()
{
inputHandler = player.GetComponent <AgentInputHandler>();
int numberOfInputs = inputHandler.commandList.Length;
menuElements = new GameObject[numberOfInputs];
menuElementText = new Text[numberOfInputs, 2];
KeybindElementFactory keybindElementFactory = new KeybindElementFactory(KeybindMenuElement, this.transform);
for (int i = 0; i < numberOfInputs; i++)
{
menuElements[i] = keybindElementFactory.GetNewInstance();
Text[] tempTextHolder = menuElements[i].GetComponentsInChildren <Text>();
for (int j = 0; j < 2; j++)
{
menuElementText[i, j] = tempTextHolder[j];
}
InputField inputField = menuElements[i].GetComponentInChildren <InputField>();
UnityEventTools.AddPersistentListener(inputField.onValueChanged, inputHandler.commandList[i].ChangeKeycode);
}
}
void AddEventToTpInput()
{
track = target as vHeadTrack;
if (!track)
{
return;
}
var tpInput = track.GetComponent <vThirdPersonInput>();
if (tpInput)
{
bool containsListener = false;
for (int i = 0; i < tpInput.OnLateUpdate.GetPersistentEventCount(); i++)
{
if (tpInput.OnLateUpdate.GetPersistentTarget(i).GetType().Equals(typeof(vHeadTrack)) && tpInput.OnLateUpdate.GetPersistentMethodName(i).Equals("UpdateHeadTrack"))
{
containsListener = true;
break;
}
}
if (!containsListener)
{
UnityEventTools.AddPersistentListener(tpInput.OnLateUpdate, track.UpdateHeadTrack);
SerializedObject tpI = new SerializedObject(tpInput);
EditorUtility.SetDirty(tpInput);
tpI.ApplyModifiedProperties();
}
}
}
static void Compute_ExecuteNode(ActionNode actionNode, Rect placeRect, bool isActive, bool haveWarning, bool haveError)
{
ExecuteNode executeNode = (ExecuteNode)actionNode;
string typeName = "> ";
int tmpCommentIndex = 90;
string detailsText = "";
#region task information
// check there is any target
if (executeNode.OnExecute == null)
{
return;
}
if (executeNode.OnExecute.GetPersistentEventCount() > 0)
{
var eventTarget = executeNode.OnExecute.GetPersistentTarget(0);
// Get target component name.
string componentName = GetComponentNameFromUnityEventTarget(actionNode, eventTarget);
// Get target gameObject name.
string gameObjectName = GetGameObjectNameFromUnityEventTarget(actionNode, eventTarget);
// Get target methud name.
string methodName = executeNode.OnExecute.GetPersistentMethodName(0);
string methodParams = "";
// Set detailsText.
if (eventTarget is IDetails)
{
detailsText = ((IDetails)eventTarget).GetDetails(gameObjectName, componentName, methodName, methodParams);
}
else
{
detailsText = string.Format(" [ {0} ] . {1} . {2}({3})", gameObjectName, componentName, methodName, methodParams);
}
}
else if (executeNode.GetComponent <IDefaultExcute>() != null)
{
UnityEventTools.AddPersistentListener(executeNode.OnExecute, executeNode.GetComponent <IDefaultExcute>().DefaultExecute);
}
else
{
// Set detailsText.
detailsText = string.Format(" [ --- ]");
}
#endregion
#region show stuff
ShowInformations_DefultStyle(actionNode,
isActive,
haveWarning,
haveError,
typeName,
detailsText,
placeRect,
tmpCommentIndex,
COLOR_NODE);
#endregion
}
public static void AddListenersToLines()
{
CampaignPlayerController playerController = GameObject.Find("GameManager").GetComponent <CampaignPlayerController>();
//Debug.Log("Player Controller: " + playerController);
GameObject[] lineButtonsInLevel = GameObject.FindGameObjectsWithTag("LinePlacement");
//Debug.Log("Line Buttons: " + lineButtonsInLevel.Length);
foreach (GameObject obj in lineButtonsInLevel)
{
UnityEvent btnOnClick = obj.GetComponent <Button>().onClick;
//Remove 2 empty listeners that are part of the prefab
UnityEventTools.RemovePersistentListener(btnOnClick, 0);
UnityEventTools.RemovePersistentListener(btnOnClick, 0);
//Create Actions for methods to add
UnityAction drawMethod = new UnityAction(playerController.PlayerDrawLine);
UnityAction destroyMethod = new UnityAction(playerController.DestroyStaticLine);
//Add persistent listeners in editor
UnityEventTools.AddPersistentListener(btnOnClick, drawMethod);
UnityEventTools.AddPersistentListener(btnOnClick, destroyMethod);
}
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
Debug.Log("Added listeners to " + lineButtonsInLevel.Length + " line buttons.");
}
private GameObject CreateToolsPanel()
{
ToolsExamplePanelFactory factory = Undoable.AddComponent <ToolsExamplePanelFactory>(disposable);
factory.parent = parent;
factory.fileOpen = fileOpen;
factory.fileSaveAs = fileSaveAs;
factory.skyboxManager = skyboxManager;
GameObject panel = factory.Generate();
toolsInstance = panel;
Vector3 localPosition = toolsInstance.transform.localPosition;
localPosition.x = toolsLocalPosition.x;
toolsInstance.transform.localPosition = localPosition;
#if UNITY_EDITOR
var touchPadButtons = touchPadMenuController.touchPadButtons;
for (int i = 0; i < touchPadButtons[0].onSelected.GetPersistentEventCount(); i++)
{
UnityEventTools.RemovePersistentListener(touchPadButtons[0].onSelected, 0);
}
UnityEventTools.AddPersistentListener(touchPadButtons[0].onSelected, toolsInstance.GetComponent <StandardPanel>().ToggleVisible);
touchPadMenuController.touchPadButtons = touchPadButtons;
#endif
return(panel);
}
public static void CB_COMP_vLadderAction(GameObject target, ref List <string> log)
{
if (!target.GetComponent <vLadderAction>())
{
return;
}
if (!target.GetComponent <SyncPlayer>())
{
CB_COMP_SyncPlayer(target, ref log);
}
if (!E_PlayerEvents.HasUnityEvent(target.GetComponent <vLadderAction>().OnEnterLadder, "EnterLadder", target.GetComponent <SyncPlayer>()))
{
if (log != null)
{
log.Add("Adding 'EnterLadder' event to vLadderAction's 'OnEnterLadder' unityEvent.");
}
UnityEventTools.AddPersistentListener(target.GetComponent <vLadderAction>().OnEnterLadder, target.GetComponent <SyncPlayer>().EnterLadder);
}
if (!E_PlayerEvents.HasUnityEvent(target.GetComponent <vLadderAction>().OnExitLadder, "ExitLadder", target.GetComponent <SyncPlayer>()))
{
if (log != null)
{
log.Add("Adding 'ExitLadder' event to vLadderAction's 'OnExitLadder' unityEvent.");
}
UnityEventTools.AddPersistentListener(target.GetComponent <vLadderAction>().OnExitLadder, target.GetComponent <SyncPlayer>().ExitLadder);
}
}
private static void SetListeners <T>(PlaymodeTestsController controller, TestRunnerListener eventHandler)
{
UnityEventTools.AddPersistentListener <string>(controller.testStartedEvent, new UnityAction <string>(eventHandler.TestStarted));
UnityEventTools.AddPersistentListener <TestResult>(controller.testFinishedEvent, new UnityAction <TestResult>(eventHandler.TestFinished));
UnityEventTools.AddPersistentListener <string, List <string> >(controller.runStartedEvent, new UnityAction <string, List <string> >(eventHandler.RunStarted));
UnityEventTools.AddPersistentListener <List <TestResult> >(controller.runFinishedEvent, new UnityAction <List <TestResult> >(eventHandler.RunFinished));
}
private static void SetListeners(PlaymodeTestsController controller, ITestRunnerListener eventHandler)
{
UnityEventTools.AddPersistentListener(controller.testStartedEvent, eventHandler.TestStarted);
UnityEventTools.AddPersistentListener(controller.testFinishedEvent, eventHandler.TestFinished);
UnityEventTools.AddPersistentListener(controller.runStartedEvent, eventHandler.RunStarted);
UnityEventTools.AddPersistentListener(controller.runFinishedEvent, eventHandler.RunFinished);
}
void C_vBreakableObject(GameObject target)
{
if (_cvBreakableObjects == false)
{
return;
}
if (target.GetComponent <vBreakableObject>())
{
E_Helpers.SetObjectIcon(target, E_Core.h_genericIcon);
if (!target.GetComponent <NetworkBreakObject>())
{
target.AddComponent <NetworkBreakObject>();
}
bool sync = !FindObjectOfType <NetworkManager>().syncScenes;
target.GetComponent <NetworkBreakObject>().GetType().GetField("syncCrossScenes", E_Helpers.allBindings).SetValue(target.GetComponent <NetworkBreakObject>(), sync);
if (sync == true)
{
target.GetComponent <NetworkBreakObject>().GetType().GetField("holder", E_Helpers.allBindings).SetValue(target.GetComponent <NetworkBreakObject>(), target.transform);
}
if (!E_PlayerEvents.HasUnityEvent(target.GetComponent <vBreakableObject>().OnBroken, "BreakObject", target.GetComponent <NetworkBreakObject>()))
{
UnityEventTools.AddPersistentListener(target.GetComponent <vBreakableObject>().OnBroken, target.GetComponent <NetworkBreakObject>().BreakObject);
}
}
}
/// <summary>
/// Replace Close button callback on Cancel instead of the Hide for the Dialog components in the specified GameObject.
/// </summary>
/// <param name="go">GameObject.</param>
public static void FixDialogCloseButton(GameObject go)
{
var dialogs = go.GetComponentsInChildren <Dialog>(true);
foreach (var dialog in dialogs)
{
var button_go = dialog.transform.Find("Header/CloseButton");
if (button_go == null)
{
continue;
}
var button = button_go.GetComponent <Button>();
if (button == null)
{
continue;
}
if (IsEventCallMethod(button.onClick, dialog, "Hide"))
{
UnityEventTools.RemovePersistentListener(button.onClick, dialog.Hide);
UnityEventTools.AddPersistentListener(button.onClick, dialog.Cancel);
}
}
}
private void PUN_ConvertvItemCollection(GameObject obj)
{
if (obj.GetComponent <vItemCollection>())
{
vItemCollection org = obj.GetComponent <vItemCollection>();
if (!obj.GetComponent <PhotonView>())
{
obj.AddComponent <PhotonView>();
}
if (!obj.GetComponent <PUN_ItemCollect>())
{
obj.AddComponent <PUN_ItemCollect>();
for (int i = 0; i < obj.GetComponent <vItemCollection>().onDoActionWithTarget.GetPersistentEventCount(); i++)
{
if (obj.GetComponent <vItemCollection>().onDoActionWithTarget.GetPersistentMethodName(i) == "NetworkDestroy")
{
UnityEventTools.RemovePersistentListener(obj.GetComponent <vItemCollection>().onDoActionWithTarget, i);
}
}
obj.GetComponent <vItemCollection>().OnDoAction.AddListener(obj.GetComponent <PUN_ItemCollect>().NetworkDestory);
UnityEventTools.AddPersistentListener(obj.GetComponent <vItemCollection>().OnDoAction, obj.GetComponent <PUN_ItemCollect>().NetworkDestory);
}
modified.Add(obj);
}
}
void AddBlankerObject()
{
if (keyboardController.blanker != null)
{
Debug.Log("this object already has blanker");
addBlanker = false;
return;
}
var blankerObj = new GameObject("Blanker");
var layouel = blankerObj.AddComponent <LayoutElement>();
layouel.ignoreLayout = true;
blankerObj.transform.SetParent(transform);
blankerObj.transform.FillParent();
blankerObj.transform.SetAsFirstSibling();
var rect = blankerObj.GetComponent <RectTransform>();
rect.anchorMin = new Vector2(0, 1);
rect.anchorMax = new Vector2(1, 1);
rect.pivot = new Vector2(0.5f, 0);
rect.sizeDelta = new Vector2(0, 300);
var img = blankerObj.AddComponent <Image>();
img.color = new Color(0, 0, 0, 0.2f);
var button = blankerObj.AddComponent <Button>();
button.transform.localScale = Vector3.one * 2;
UnityAction action = new UnityAction(keyboardController.Close);
UnityEventTools.AddPersistentListener(button.onClick, action);
keyboardController.blanker = button;
}
public override void OnInspectorGUI()
{
DirtableOverlayPanel dirtablePanel = target as DirtableOverlayPanel;
DrawDefaultInspector();
EditorGUILayout.Space();
if (GUILayout.Button("Add SetDirty to all child inputfields' OnValueChanged", GUILayout.ExpandHeight(true), GUILayout.Height(50)))
{
UnityAction <string> dirtyAction = new UnityAction <string>(dirtablePanel.MarkDirty);
bool alreadyListensToAction = false;
foreach (InputField IF in dirtablePanel.GetComponentsInChildren <InputField>(true))
{
alreadyListensToAction = false;
for (int i = 0; i < IF.onValueChanged.GetPersistentEventCount(); i++)
{
if (IF.onValueChanged.GetPersistentMethodName(i) == "MarkDirty")
{
alreadyListensToAction = true;
break;
}
}
if (alreadyListensToAction)
{
continue;
}
UnityEventTools.AddPersistentListener(IF.onValueChanged, dirtyAction);
Debug.Log("added event to IF: " + IF.transform.name);
}
}
}
void TryRegisterProperty(Toggle.ToggleEvent poller, UnityAction <bool> f)
{
var count = poller.GetPersistentEventCount();
if (this._clean_empty_no_target_events && count > 0)
{
//poller.PollEvent.RemoveAllListeners(); // Only non-persistent listeners.
for (var i = 0; i < count; i++)
{
if (poller.GetPersistentTarget(i) == null || poller.GetPersistentMethodName(i) == null)
{
UnityEventTools.RemovePersistentListener(poller, i);
}
}
}
count = poller.GetPersistentEventCount();
if (count == 0)
{
UnityEventTools.AddPersistentListener(poller, f);
poller.SetPersistentListenerState(0, this._unity_event_call_state);
}
else if (count > 0)
{
#if NEODROID_DEBUG
if (this.Debugging)
{
Debug.Log($"PollEvent on {poller} already has a listeners");
}
#endif
}
}
static void ConnectNearTilePushedItems(
Dictionary <Vector2, GameObject> tiles,
Vector2 nearPosition,
TileDirection direction,
PushedItemsEventNode.EventType moveEvent,
List <PlayerBase> playerBases
)
{
var nearPlayerBase = playerBases.FirstOrDefault(playerBase => playerBase.Contains(nearPosition));
if (nearPlayerBase != null)
{
var action = new UnityAction <PushedItemsEventNode.Data>(nearPlayerBase.Player.PullItems);
UnityEventTools.AddPersistentListener(moveEvent, action);
}
else if (tiles.ContainsKey(nearPosition))
{
var nearTile = tiles[nearPosition];
var nearDirection = nearTile.GetComponent <TileDirection>();
var action = new UnityAction <PushedItemsEventNode.Data>(nearDirection.PullItems);
UnityEventTools.AddPersistentListener(moveEvent, action);
}
}
public static void CB_COMP_vItemManager(GameObject target, ref List <string> log)
{
if (!target.GetComponent <vItemManager>())
{
return;
}
if (!target.GetComponent <SyncPlayer>())
{
CB_COMP_SyncPlayer(target, ref log);
}
if (!E_PlayerEvents.HasUnityEvent(target.GetComponent <vItemManager>().onDropItem, "OnDropItem", target.GetComponent <SyncPlayer>()))
{
if (log != null)
{
log.Add(" * Adding OnDropItem Event to vItemManager");
}
UnityEventTools.AddPersistentListener(target.GetComponent <vItemManager>().onDropItem, target.GetComponent <SyncPlayer>().OnDropItem);
}
foreach (EquipPoint ep in target.GetComponent <vItemManager>().equipPoints)
{
CB_COMP_AddSyncObjComp(ep.handler.defaultHandler.gameObject, false, ep.equipPointName.ToLower().Contains("left"), false, false, false, true, ref log);
foreach (Transform customHandler in ep.handler.customHandlers)
{
CB_COMP_AddSyncObjComp(customHandler.gameObject, false, ep.equipPointName.ToLower().Contains("left"), false, false, false, true, ref log);
}
}
}
private void Reset()
{
InputField field = GetComponent <InputField>();
field.contentType = InputField.ContentType.IntegerNumber;
UnityEventTools.AddPersistentListener(field.onValueChanged, OnValChangedCaller);
UnityEventTools.AddPersistentListener(field.onEndEdit, OnEndEditCaller);
}
public void RefreshUnityEventBase()
{
if (selectedUnityEventBase is UnityEvent)
{
UnityEventTools.RemovePersistentListener((UnityEvent)selectedUnityEventBase, EventTriggerHandler);
UnityEventTools.AddPersistentListener((UnityEvent)selectedUnityEventBase, EventTriggerHandler);
}
}
public static void AddListenerIfNotExist <T>(this UnityEvent <T> evt, UnityAction <T> action)
{
if (evt.IndexOf(action) >= 0)
{
return;
}
UnityEventTools.AddPersistentListener(evt, action);
}
public void Bind(UnityEvent_string @event)
{
#if UNITY_EDITOR
UnityEventTools.AddPersistentListener(@event, GetAction <string>(target, methodName));
#else
System.Reflection.MethodInfo targetinfo = UnityEvent.GetValidMethodInfo(target, setMethodName, new Type[0]);
@event.AddListener((str) => targetinfo.Invoke(target, new object[] { str }));
#endif
}