private static void SetupEvent(EventsType eventName)
{
if (!events.ContainsKey(eventName))
{
events.Add(eventName, new List <Delegate>());
}
}
private static void SetupEvent(EventsType eventName)
{
if (!events.ContainsKey(eventName))
{
events.Add(eventName, null);
}
}
private static void ListenerRemoved(EventsType eventName)
{
if (events.ContainsKey(eventName) && events[eventName] == null)
{
events.Remove(eventName);
}
}
public static void BroadcastWithParams(EventsType eventName, params object[] param)
{
if (CallCondition(eventName))
{
((Action <object[]>)events[eventName])(param);
}
}
public PYAudioSource RemoveListinerFromEvent(EventsType type, System.Action <PYAudioSourceEventData> action)
{
switch (type)
{
case EventsType.OnStartPlaying:
OnStartPlaying -= action;
break;
case EventsType.OnPlaying:
OnPlaying -= action;
break;
case EventsType.OnResume:
OnResume -= action;
break;
case EventsType.OnPaused:
OnPaused -= action;
break;
case EventsType.OnCompleted:
OnCompleted -= action;
break;
case EventsType.OnStopped:
OnStopped -= action;
break;
}
return(this);
}
// Update is called once per frame
void Update()
{
if (CheckHorizontal(m_Target))
{
IsOutOfRange = true;
if (PreOutofRange != IsOutOfRange)
{
if (OnTrackingRangeEvent != null)
{
OnTrackingRangeEvent.Invoke(EventsType.TrackingOutofRange);
}
m_Region.SetActive(true);
PreOutofRange = IsOutOfRange;
RangeState = EventsType.TrackingOutofRange;
}
}
else
{
IsOutOfRange = false;
if (PreOutofRange != IsOutOfRange)
{
if (OnTrackingRangeEvent != null)
{
OnTrackingRangeEvent.Invoke(EventsType.TrackingInRange);
}
m_Region.SetActive(false);
PreOutofRange = IsOutOfRange;
RangeState = EventsType.TrackingInRange;
}
}
}
/// <summary>
/// 设置事件类型
/// </summary>
/// <param name="unityEvent"></param>
/// <param name="eventType"></param>
/// <param name="gos"></param>
/// <param name="eventsManager"></param>
private static void SetFunc(UnityEvent unityEvent, EventsType eventType, GameObject[] gos, EventParames EventParames)
{
foreach (var go in gos)
{
if (!go.GetComponent <Collider>())
{
throw new Exception(go.name + "物体没有碰撞器，不能被检测！");
}
}
unityEvent.go = gos;
unityEvent.EventType = eventType;
unityEvent.EventParames = EventParames;
if ((EventParames & EventParames.NoOrder) != 0)
{
// 这里向事件脚本中传递的是 客户端的Action;
AddEvent(unityEvent, unityEvent.action);
return;
}
eventQueue.Enqueue(unityEvent);
if (begin)
{
NextTool();
begin = false;
}
}
public EventsGrid(DataBase db, EventsType type)
: base(db)
{
Name = "masterEventGrid";
EventType = type;
RefreshGrid();
var gridId = type == EventsType.Event
? DataBase.GridsIds.EventsGridId
: DataBase.GridsIds.MasterGridId;
GridId = gridId;
var columns = Db.GetColumnsSettingsList(gridId).OrderBy(c => c.OrderNr);
foreach (var column in columns)
{
Columns.Add(new DataGridViewTextBoxColumn
{
Name = column.ColumnName,
HeaderText = column.ColumnHeader,
DataPropertyName = column.ColumnName,
SortMode = DataGridViewColumnSortMode.Programmatic,
Visible = column.IsVisible,
Width = column.Width
});
}
}
public static void Broadcast <T, U>(EventsType eventName, T param, U param2)
{
if (CallCondition(eventName))
{
((Action <T, U>)events[eventName])(param, param2);
}
}
public static void Broadcast(EventsType eventName)
{
if (CallCondition(eventName))
{
((Action)events[eventName])();
}
}
public static void RemoveListener <T, U>(EventsType eventName, Action <T, U> callback)
{
if (events.ContainsKey(eventName))
{
events[eventName] = (Action <T, U>)events[eventName] - callback;
ListenerRemoved(eventName);
}
}
//hmr
public ReaderEventArgs(EventsType Event, DateTime GpiDateTime, int Gpiport, int Gpistatus)
: base()
{
this.EventType = Event;
this.ScannedDateTime = GpiDateTime;
this.GpiPort = Gpiport;
this.GpiStatus = Gpistatus;
}
public bool RemoveKey(EventsType et)
{
if (ContainsKey(et))
{
return(dict.Remove(et));
}
return(false);
}
public CommonEvent GetValue(EventsType et)
{
if (dict.ContainsKey(et))
{
return(dict[et]);
}
return(null);
}
public static void RemoveListenerWithParams(EventsType eventName, Action <object[]> callback)
{
if (events.ContainsKey(eventName))
{
events[eventName] = (Action <object[]>)events[eventName] - callback;
ListenerRemoved(eventName);
}
}
public static void RemoveListener <T>(EventsType eventName, Action <T> callback)
{
if (events.ContainsKey(eventName))
{
events[eventName].Add(callback);
ListenerRemoved(eventName);
}
}
public static void Send(EventsType eventMessage, params object[] args)
{
var actions = listeners[eventMessage] as Handler;
if (actions != null)
{
actions(args);
}
}
public static void Remove(EventsType eventMessage, Handler action)
{
var actions = listeners[eventMessage] as Handler;
if (actions != null)
{
listeners[eventMessage] = actions - action;
}
}
public static void Broadcast(EventsType eventName)
{
if (CallCondition(eventName))
{
foreach (var item in events[eventName])
{
((Action)item)();
}
}
}
public static void Unsubscribe(EventsType eventType, EventReceiver listener)
{
if (_events != null)
{
if (_events.ContainsKey(eventType))
{
_events[eventType] -= listener;
}
}
}
public static void Broadcast <T, U>(EventsType eventName, T param, U param2)
{
if (CallCondition(eventName))
{
foreach (var item in events[eventName])
{
((Action <T, U>)item)(param, param2);
}
}
}
public void SetValue(EventsType et, CommonEvent ce)
{
if (dict.ContainsKey(et))
{
dict[et] = ce;
}
else
{
dict.Add(et, ce);
}
}
/// <summary>
/// 事件绑定
/// </summary>
public void AttachEvent(EventsType key, CommonEvent attachEvent)
{
if (m_dicEvents.ContainsKey(key))
{
m_dicEvents[key] += attachEvent;
}
else
{
m_dicEvents.Add(key, attachEvent);
}
}
/// <summary>
/// 事件触发
/// </summary>
public void TriigerEvent(EventsType strEventKey, object param)
{
if (m_dicEvents.ContainsKey(strEventKey))
{
m_dicEvents[strEventKey](param);
}
else
{
//CommonTools.Log("没有监听这个事件"+ strEventKey);
}
}
public static void SubscribeToEvent(EventsType eventType, EventReceiver listener)
{
if (_events == null)
{
_events = new Dictionary <EventsType, EventReceiver>();
}
if (!_events.ContainsKey(eventType))
{
_events.Add(eventType, null);
}
_events[eventType] += listener;
}
public EventEntity(EventsType et, CommonEvent ce)
{
dict = new Dictionary <EventsType, CommonEvent>();
if (dict.ContainsKey(et))
{
dict[et] = ce;
}
else
{
dict.Add(et, ce);
}
}
public static void Listen(EventsType eventMessage, Handler action)
{
var actions = listeners[eventMessage] as Handler;
if (actions != null)
{
listeners[eventMessage] = actions + action;
}
else
{
listeners[eventMessage] = action;
}
}
public static void TriggerEvent(EventsType eventType, params object[] parameters)
{
if (_events == null)
{
Debug.Log("No events subscribed");
return;
}
if (_events.ContainsKey(eventType))
{
if (_events[eventType] != null)
{
_events[eventType](parameters);
}
}
}
/// <summary>
/// 对事件的类型进行设置； T 为有参数的委托；
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="eventType"></param>
/// <param name="gos"></param>
/// <param name="function"></param>
/// <param name="parameters"></param>
/// <param name="eventsManager"></param>
public static void SetFunc <T>(EventsType eventType, GameObject[] gos, T function, string parameters,
EventParames EventParames) where T : class
{
UnityEvent unityEvent = new UnityEvent();
if (typeof(T) == typeof(Action <string>))
{
unityEvent.AddActKeyPair(parameters, (Action <string>)(object) function);
}
else
{
throw new Exception("事件委托机制不支持该函数类型！");
}
SetFunc(unityEvent, eventType, gos, EventParames);
}
/// <summary>
/// 去除事件绑定
/// </summary>
public void UnRegEvent(ulong Id, EventsType et)
{
if (m_dicAllEvents.ContainsKey(Id))
{
if (m_dicAllEvents[Id].ContainsKey(et))
{
m_dicAllEvents[Id].RemoveKey(et);
}
else
{
Debug.Log("没有监听这个事件:" + et);
}
}
else
{
Debug.Log("没有监听这个ID:" + Id);
}
}
