public void LateUpdate() { CustomBeatmapData beatmapData = this.beatmapData as CustomBeatmapData; if (beatmapData == null) { return; } foreach (var pair in beatmapData.customEventData) { if (!callbackDatas.ContainsKey(pair.Key)) { continue; } foreach (var callbackData in callbackDatas[pair.Key]) { while (callbackData.nextEventIndex < pair.Value.Count) { CustomEventData eventData = pair.Value[callbackData.nextEventIndex]; if (eventData.time - callbackData.aheadTime >= audioTimeSyncController.songTime) { break; } if (eventData.time >= spawningStartTime || callbackData.callIfBeforeStartTime) // skip events before song start { callbackData.callback(eventData); } callbackData.nextEventIndex++; } } } }
private T DeserializeCustomEvent <T>(CustomEventData eventData) where T : NetworkEventDTO { var payload = eventData.Payload.ToStringUtf8(); return(JsonConvert.DeserializeObject <T>(payload, new Vector3Converter())); }
internal static void Callback(CustomEventData customEventData) { if (customEventData.type == "AssignPathAnimation") { EventHelper.StartEventCoroutine(customEventData, EventType.AssignPathAnimation); } }
public void OnPointerHover(PointerEventData eventData) { if (currentDICOM != null) { // Cast event data to CustomEventData: CustomEventData cEventData = eventData as CustomEventData; if (cEventData != null) // Just in case // Calculate which pixel in the dicom was hit: { Vector2 pixel = uvToPixel(cEventData.textureCoord); // Calculate which 3D-Position (in the patient coordinate system) this pixel represents: Vector3 pos3D = pixelTo3DPos(pixel); // Display the current position: Text t = transform.Find("PositionText").GetComponent <Text> (); t.text = "(" + (int)Mathf.Round(pixel.x) + ", " + (int)Mathf.Round(pixel.y) + ", " + currentViewSettings.slice + ")"; GameObject pointer = GameObject.Find("3DPointer"); if (pointer != null) { pointer.transform.localPosition = pos3D; } } } }
internal static void Callback(CustomEventData customEventData) { if (customEventData.type == ANIMATETRACK) { EventHelper.StartEventCoroutine(customEventData, EventType.AnimateTrack); } }
public void PlayEntranceAnimation(CustomEventData eventData) { if (animationName != null) { anim.Play(animationName); } }
void DisplayImageOverlay(CustomEventData eventData) { GameObject tappedObject = eventData.obj; Image tappedImageComponent = tappedObject.GetComponent <Image>(); Sprite ImageSprite = tappedImageComponent.sprite; SetImage(ImageSprite); OpenOverlay(); }
private async void HandleCustomEvent(CustomEventData eventData) { try { Logger.Log("Handled custom event " + eventData.Code, NetworkLogType.Broadcasting); var code = (CustomEventCode)eventData.Code; switch (code) { case CustomEventCode.PlayerMoved: var movedEvent = DeserializeCustomEvent <PlayerMovedEventDTO>(eventData); var player = _simulation.Players.FirstOrDefault(_ => _.Id == movedEvent.PlayerId); if (player == null) { Debug.LogError($"Player {movedEvent.PlayerId} not found "); break; } player.MoveTo(movedEvent.Position); break; case CustomEventCode.FullUpdateRequest: if (!_isHost) { break; } var fullUpdateEvent = new FullUpdateEventDTO() { Simulation = _simulation.Save() }; var json = JsonConvert.SerializeObject(fullUpdateEvent, new Vector3Converter()); var bytes = Encoding.UTF8.GetBytes(json); await BroadcastEventAsync(bytes, (int)CustomEventCode.FullUpdate); break; case CustomEventCode.FullUpdate: var updateEvent = DeserializeCustomEvent <FullUpdateEventDTO>(eventData); _simulation.LoadFrom(updateEvent.Simulation); break; default: throw new ArgumentOutOfRangeException(); } } catch (Exception e) { Debug.LogException(e); } }
protected void CopyFromTo(CustomEventData @from, CustomEventData @to) { @to.position = @from.position; @to.delta = @from.delta; @to.scrollDelta = @from.scrollDelta; @to.pointerCurrentRaycast = @from.pointerCurrentRaycast; @to.pointerEnter = @from.pointerEnter; @to.textureCoord = @from.textureCoord; @to.hitTriangleIndex = @from.hitTriangleIndex; }
public static void TriggerEvent(CustomEventData eventData) { CustomEvent thisEvent = null; DebugLog.WriteLog("Event Broadcasted: " + eventData.eventName); if (instance.eventDictionary.TryGetValue(eventData.eventName, out thisEvent)) { thisEvent.Invoke(eventData); } }
internal static void Callback(CustomEventData customEventData) { if (customEventData.type == "AssignPlayerToTrack") { Track track = GetTrack(customEventData.data); if (track != null) { PlayerTrack.AssignTrack(track); } } }
internal static void StartEventCoroutine(CustomEventData customEventData, EventType eventType) { NoodleCoroutineEventData noodleData = (NoodleCoroutineEventData)NoodleEventDatas[customEventData]; if (noodleData == null) { return; } float duration = noodleData.Duration; duration = 60f * duration / Instance.BeatmapObjectSpawnController.currentBpm; // Convert to real time; Functions easing = noodleData.Easing; foreach (NoodleCoroutineEventData.CoroutineInfo coroutineInfo in noodleData.CoroutineInfos) { Property property = coroutineInfo.Property; PointDefinition pointData = coroutineInfo.PointDefinition; if (property.Coroutine != null) { Instance.StopCoroutine(property.Coroutine); } if (pointData == null) { switch (eventType) { case EventType.AnimateTrack: property.Value = null; break; case EventType.AssignPathAnimation: ((PointDefinitionInterpolation)property.Value).Init(null); break; } } else { switch (eventType) { case EventType.AnimateTrack: property.Coroutine = Instance.StartCoroutine(AnimateTrack.AnimateTrackCoroutine(pointData, property, duration, customEventData.time, easing)); break; case EventType.AssignPathAnimation: ((PointDefinitionInterpolation)property.Value).Init(pointData); property.Coroutine = Instance.StartCoroutine(AssignPathAnimation.AssignPathAnimationCoroutine(property, duration, customEventData.time, easing)); break; } } } }
public void OnPointerClick(PointerEventData pointerEventData) { GameObject obj = pointerEventData.pointerCurrentRaycast.gameObject; if (obj != null) { string eventName = "on" + obj.tag + "Tapped"; CustomEventData eventData = new CustomEventData(eventName, obj); EventManager.TriggerEvent(eventData); } }
internal static void Callback(CustomEventData customEventData) { if (customEventData.type == ASSIGNPLAYERTOTRACK) { NoodlePlayerTrackEventData noodleData = (NoodlePlayerTrackEventData)NoodleEventDatas[customEventData]; Track track = noodleData.Track; if (track != null) { PlayerTrack.AssignTrack(track); } } }
private EventGridEvent CreateEventInstance(CustomEventData customEventData) { return(new EventGridEvent { DataVersion = "1.0", EventTime = DateTime.Now, Id = Guid.NewGuid().ToString(), EventType = customEventData.CustomEvent.ToString(), Subject = "speeding.infraction.management.customevent", Data = customEventData }); }
public void OnSdkCallbackCall(string data) { //Debug.Log("OnSdkCallbackCall:" + data); CustomEventData sDKCallData = JsonUtility.FromJson <CustomEventData>(data); //Debug.Log("sDKCallData.eventName = " + sDKCallData.eventName); //Debug.Log("sDKCallData.data = " + sDKCallData.data); if (sDKCallData != null && gameSdkCallback != null) { gameSdkCallback.Call(sDKCallData.eventName, sDKCallData.data); } }
internal static void Callback(CustomEventData customEventData) { if (customEventData.type == ASSIGNTRACKPARENT) { NoodleParentTrackEventData?noodleData = TryGetEventData <NoodleParentTrackEventData>(customEventData); if (noodleData != null) { IEnumerable <Track> tracks = noodleData.ChildrenTracks; Track parentTrack = noodleData.ParentTrack; ParentObject.AssignTrack(tracks, parentTrack, noodleData.WorldPositionStays, noodleData.Position, noodleData.Rotation, noodleData.LocalRotation, noodleData.Scale); } } }
protected override void Start() { lineRenderer = this.GetComponent <LineRenderer>(); eventData = new CustomEventData(eventSystem); leftData = new CustomEventData(eventSystem); rightData = new CustomEventData(eventSystem); middleData = new CustomEventData(eventSystem); triggerData = new CustomEventData(eventSystem); //set Layer Mask on Default resetLayerMask(); }
public void OnLoginClick(BaseEventData data) { print("login"); this.MoveOut(); maininterfacePanel.transform.GetComponent <MainInterface> ().FadeIn(); Hashtable table = new Hashtable(); table.Add("UserName", account.text); CustomEventData eventdata = new CustomEventData("AccountChange", table, this.gameObject); CustomEventManager.GetInstance().DispatchEvent(eventdata); }
public async Task PublishEventToTopicAsync(CustomEventData customEventData) { List <EventGridEvent> eventGridEvents = new List <EventGridEvent> { CreateEventInstance(customEventData) }; await _eventGridClient .PublishEventsAsync( topicHostname : _eventGridOptions.TopicHostName, eventGridEvents ) .ConfigureAwait(false); }
public void Publish(CustomEventData messageData) { var eventName = messageData.Message; if (!_dictionarySubscribers.ContainsKey(eventName)) { return; } foreach (var subscriber in _dictionarySubscribers[eventName].ToList()) { subscriber.OnEvent(messageData); } }
internal static T?TryGetEventData <T>(CustomEventData customEventData) { if (_noodleEventDatas.TryGetValue(customEventData, out NoodleEventData noodleEventData)) { if (noodleEventData is T t) { return(t); } else { throw new InvalidOperationException($"NoodleEventData was not of correct type. Expected: {typeof(T).Name}, was: {noodleEventData.GetType().Name}"); } } return(default);
internal static void Callback(CustomEventData customEventData) { if (customEventData.type == ASSIGNPLAYERTOTRACK) { NoodlePlayerTrackEventData?noodleData = TryGetEventData <NoodlePlayerTrackEventData>(customEventData); if (noodleData != null) { Track track = noodleData.Track; if (track != null) { PlayerTrack.AssignTrack(track); } } } }
public void OnTrackableStateChanged(TrackableBehaviour.Status previousStatus, TrackableBehaviour.Status newStatus) { CustomEventData eventData = new CustomEventData(); eventData.obj = transform.gameObject; if (newStatus == TrackableBehaviour.Status.DETECTED || newStatus == TrackableBehaviour.Status.TRACKED || newStatus == TrackableBehaviour.Status.EXTENDED_TRACKED) { eventData.eventName = "onImageTargetDetected"; EventManager.TriggerEvent(eventData); } else { eventData.eventName = "onImageTargetDetected"; EventManager.TriggerEvent(eventData); } }
internal static void Callback(CustomEventData customEventData) { if (customEventData.type == ASSIGNTRACKPARENT) { NoodleParentTrackEventData noodleData = (NoodleParentTrackEventData)NoodleEventDatas[customEventData]; IEnumerable <Track> tracks = noodleData.ChildrenTracks; Track parentTrack = noodleData.ParentTrack; if (tracks != null && parentTrack != null) { ParentObject.AssignTrack(tracks, parentTrack, noodleData.Position, noodleData.Rotation, noodleData.LocalRotation, noodleData.Scale); } else { NoodleLogger.Log($"Missing _parentTrack or _childrenTracks!", IPA.Logging.Logger.Level.Error); } } }
/// <summary> /// <para>Custom Events (optional).</para> /// </summary> /// <param name="customEventName"></param> /// <param name="position"></param> public static AnalyticsResult CustomEvent(string customEventName, Vector3 position) { if (string.IsNullOrEmpty(customEventName)) { throw new ArgumentException("Cannot set custom event name to an empty or null string"); } UnityAnalyticsHandler unityAnalyticsHandler = GetUnityAnalyticsHandler(); if (unityAnalyticsHandler == null) { return AnalyticsResult.NotInitialized; } CustomEventData eventData = new CustomEventData(customEventName); eventData.Add("x", (double) Convert.ToDecimal(position.x)); eventData.Add("y", (double) Convert.ToDecimal(position.y)); eventData.Add("z", (double) Convert.ToDecimal(position.z)); return unityAnalyticsHandler.CustomEvent(eventData); }
public void OnEvent(CustomEventData messageData) { var eventName = messageData.Message; switch (eventName) { case GameEventName.CreateNewObject: var position = (Vector3)messageData.Value; CreateNewObject(position); break; case GameEventName.ClickedObject: var target = (GameObject)messageData.Value; ClickedObject(target); break; } }
public async Task BroadcastEventAsync(byte[] serializedEvent, int eventCode) { var eventDataBase64 = serializedEvent == null ? string.Empty : Convert.ToBase64String(serializedEvent, 0, serializedEvent.Length); var customEvent = new CustomEventData() { Code = eventCode, Payload = ByteString.FromBase64(eventDataBase64) }; var message = new EventData() { Code = EventCode.CustomEvent, Payload = customEvent.ToByteString() }; Logger.Log($"Broadcast event {eventCode}", NetworkLogType.Broadcasting); await SendRequestAsync(message : message, OperationRequestCode.RaiseEvent); }
void OnGUI() { var eventData = new CustomEventData (EventSystem.current) { message = this.message }; if (GUILayout.Button ("EventSystem")) { ExecuteEvents.Execute<ICustomEventHandler> (receiver, eventData, (_handler, _eventData) => { _handler.OnReceiveEvent((CustomEventData)_eventData); }); //ExecuteEvents.Execute<ICustomEventHandler> (receiver, eventData, CustomEventHandler.Execute); //ExecuteEvents.ExecuteHierarchy<ICustomEventHandler> (receiver, eventData, CustomEventHandler.Execute); } if (GUILayout.Button ("SendMessage")) { receiver.SendMessage ("OnReceiveEvent", eventData); //receiver.SendMessageUpwards ("OnReceiveEvent", eventData); } }
public static AnalyticsResult CustomEvent(string customEventName, IDictionary<string, object> eventData) { if (string.IsNullOrEmpty(customEventName)) { throw new ArgumentException("Cannot set custom event name to an empty or null string"); } UnityAnalyticsHandler unityAnalyticsHandler = GetUnityAnalyticsHandler(); if (unityAnalyticsHandler == null) { return AnalyticsResult.NotInitialized; } if (eventData == null) { return unityAnalyticsHandler.CustomEvent(customEventName); } CustomEventData data = new CustomEventData(customEventName); data.Add(eventData); return unityAnalyticsHandler.CustomEvent(data); }
internal static void Callback(CustomEventData customEventData) { if (customEventData.type == "AssignTrackParent") { Track parentTrack = GetTrack(customEventData.data, "_parentTrack"); IEnumerable <Track> tracks = GetTrackArray(customEventData.data, "_childrenTracks"); IEnumerable <float> position = ((List <object>)Trees.at(customEventData.data, POSITION))?.Select(n => Convert.ToSingle(n)); Vector3? posVector = null; if (position != null) { posVector = new Vector3(position.ElementAt(0), position.ElementAt(1), position.ElementAt(2)); } IEnumerable <float> rotation = ((List <object>)Trees.at(customEventData.data, ROTATION))?.Select(n => Convert.ToSingle(n)); Quaternion? rotQuaternion = null; if (rotation != null) { rotQuaternion = Quaternion.Euler(rotation.ElementAt(0), rotation.ElementAt(1), rotation.ElementAt(2)); } IEnumerable <float> localrot = ((List <object>)Trees.at(customEventData.data, LOCALROTATION))?.Select(n => Convert.ToSingle(n)); Quaternion? localRotQuaternion = null; if (localrot != null) { localRotQuaternion = Quaternion.Euler(localrot.ElementAt(0), localrot.ElementAt(1), localrot.ElementAt(2)); } IEnumerable <float> scale = ((List <object>)Trees.at(customEventData.data, SCALE))?.Select(n => Convert.ToSingle(n)); Vector3? scaleVector = null; if (scale != null) { scaleVector = new Vector3(scale.ElementAt(0), scale.ElementAt(1), scale.ElementAt(2)); } if (tracks != null && parentTrack != null) { ParentObject.AssignTrack(tracks, parentTrack, posVector, rotQuaternion, localRotQuaternion, scaleVector); } } }
public async Task ManageExceptions( [EventGridTrigger] EventGridEvent eventGridEvent, ILogger logger ) { CustomEventData inputEventData = ((JObject)eventGridEvent.Data).ToObject <CustomEventData>(); var correlationId = LoggingHelper.GetCorrelationId(inputEventData); #region Logging logger.LogInformation( new EventId((int)LoggingConstants.EventId.ManageExeceptionsStarted), LoggingConstants.Template, LoggingConstants.EventId.ManageExeceptionsStarted.ToString(), correlationId, LoggingConstants.ProcessingFunction.ManageExeceptions.ToString(), LoggingConstants.ProcessStatus.Started.ToString(), "Execution started" ); #endregion await _blobHandler .CopyBlobAcrossContainerWithUrlsAsync(inputEventData.ImageUrl, _options.CompensationContainerName) .ConfigureAwait(false); #region Logging logger.LogInformation( new EventId((int)LoggingConstants.EventId.ManageExeceptionsFinished), LoggingConstants.Template, LoggingConstants.EventId.ManageExeceptionsFinished.ToString(), correlationId, LoggingConstants.ProcessingFunction.ManageExeceptions.ToString(), LoggingConstants.ProcessStatus.Finished.ToString(), "Execution Finished" ); #endregion }
private void LateUpdate() { if (_beatmapObjectCallbackController.enabled && _beatmapData is CustomBeatmapData customBeatmapData) { for (int l = 0; l < _customEventCallbackData.Count; l++) { CustomEventCallbackData customEventCallbackData = _customEventCallbackData[l]; while (customEventCallbackData.nextEventIndex < customBeatmapData.customEventData.Length) { CustomEventData customEventData = customBeatmapData.customEventData[customEventCallbackData.nextEventIndex]; if (customEventData.time - customEventCallbackData.aheadTime >= _audioTimeSource.songTime) { break; } if (customEventData.time >= _spawningStartTime || customEventCallbackData.callIfBeforeStartTime) // skip events before song start { customEventCallbackData.callback(customEventData); } customEventCallbackData.nextEventIndex++; } } } }
private extern AnalyticsResult SendCustomEvent(CustomEventData eventData);
public void OnReceiveEvent(CustomEventData eventData) { Debug.Log (string.Format("[CustomEventReceiver]{0} : {1}", name, eventData.message)); }
public AnalyticsResult CustomEvent(CustomEventData eventData) { return this.SendCustomEvent(eventData); }