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);
}
