public void BroadcastEvent(IEventData evt, SendParameters param)
{
foreach (StarCollectorPeer peer in listPeer)
{
peer.SendEvent(evt, param);
}
}
//This is the constructor for a WorkItem - the only required parameter is the threadstart itself, but you can optionally add additional parameters if you need.
//If you don't provide an eventType or eventData, the workItem assumes it does not trigger an event.
//If you don't tell the work item it is persistent when you create it, it will assume it only needs to be run once.
public WorkItem(ThreadStart action, bool isPersistent = false, FlightEventType type = FlightEventType.None, IEventData eventData = null)
{
Action = action;
EventType = type;
EventData = eventData;
IsPersistent = isPersistent;
}
public static void EndGame(IEventData raw)
{
var data = (WallHit)raw;
SetupAudio(data.State.Audio);
if (data.Target == WallHitTarget.WALL_TOP) {
++data.State.Score.Player;
data.State.NewGame();
data.State.Flare.Show();
raw.State.Score.Update(Config.PointsPerWin, "Won a round!");
data.State.Audio.Play(WIN_LOSE_CHANNEL, WIN_SOUND, 1.0f);
if (raw.State.Score.Player == Config.WinScore)
Pongstar.Get<GameController>().Win();
} else if (data.Target == WallHitTarget.WALL_BOTTOM) {
++data.State.Score.Ai;
data.State.NewGame();
data.State.Flare.Show();
raw.State.Score.Update(Config.PointsPerLoss, "Lost a round");
data.State.Audio.Play(WIN_LOSE_CHANNEL, LOSE_SOUND, 1.0f);
if (raw.State.Score.Ai == Config.WinScore)
Pongstar.Get<GameController>().Lose();
}
else {
raw.State.Score.Update(Config.PointsPerBounce, "Bounce!");
if (_wallAudio == null) SetupAudio(data.State.Audio);
if (NoBounce())
_wallAudio.Play();
}
}
public static void AddSparklesToWall(IEventData raw)
{
var data = (WallHit)raw;
if ((data.Target == WallHitTarget.WALL_LEFT) || (data.Target == WallHitTarget.WALL_RIGHT)) {
var s = data.State;
s.Sparkle.CreateSparkles(data.Position, s.Ball.Velocity, SparkleType.SPARKLE_WALL);
}
}
protected override void OnEvent(IEventData eventData, SendParameters sendParameters)
{
IPhotonEventHandler handler;
if (EventHandlers.TryGetValue(eventData.Code, out handler))
{
handler.HandleEvent(eventData as EventData);
}
}
public static Event Make(IEventData eventData, Guid aggregateId, int eventSequence)
{
return new Event {
AggregateId = aggregateId,
AggregateEventSequence = eventSequence,
DateTime = System.DateTime.UtcNow,
EventType = eventData.GetType().FullName,
Data = JsonConvert.SerializeObject(eventData)
};
}
public WorkItem(ThreadStart action, ref byte[] arrayData, EventType type = EventType.None, IEventData eventData = null, bool persistent = false, bool pauseable = false)
{
Action = action;
EventType = type;
EventData = eventData;
ArrayData = arrayData;
_repeatable = persistent;
Persistent = persistent;
Pauseable = pauseable;
if (Pauseable) MemoryMonitor.Instance.RegisterPauseableAction(this);
}
//this is the code that runs when all events trigger!!!
private void TestGyro(FlightEventType eventType, IEventData eventData) {
//since this runs when ALL events trigger, we want to stop running it if the
//event was NOT a gyro event.
if (eventType != FlightEventType.Gyro) return;
//if we got here, the event was a Gyro event, and we can trust that the eventData
// will be GyroData rather than some other kind.
var data = eventData as GyroData;
//if for some reason we didn't get any data, something went wrong - just get out of
//here so we don't crash.
if (data == null) return;
//the data was gyro data, and it isn't null! Print it to the debug window.
Debug.Print("Gyro X: " + data.X + " Y: " + data.Y + " Z:" + data.Z);
}
/// <inheritdoc/>
public Task TriggerAsync(Type eventType, IEventData eventData)
{
return(TriggerAsync(eventType, null, eventData));
}
public GroupMemberAddedSession(IRpcProtocol protocol, IEventData eventData)
: base(protocol, eventData.Parameters)
{
}
public void MarkEventAsProcessed(int key, IEventData eventData)
{
_cache[key] = eventData.ReceivedOn.Ticks;
}
protected virtual void HandleUpdateGameState(IEventData eventData)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("HandleUpdateGameState");
}
var updateEvent = new UpdateGameEvent(this.Protocol, eventData);
if (updateEvent.IsValid == false)
{
string msg = updateEvent.GetErrorMessage();
log.ErrorFormat("UpdateGame contract error: {0}", msg);
return;
}
this.application.Lobby.UpdateGameState(updateEvent, this);
}
public static void PlayerMove(IEventData raw)
{
var data = (PlayerInput)raw;
if (data.Request == PlayerInputType.LEFT) {
var delta = data.Distance < data.Target.Speed ? data.Distance : data.Target.Speed;
data.Target.MoveLeft(delta);
}
else if (data.Request == PlayerInputType.RIGHT) {
var delta = data.Distance < data.Target.Speed ? data.Distance : data.Target.Speed;
data.Target.MoveRight(delta);
}
}
protected override void OnEvent(IEventData eventData, SendParameters sendParameters)
{
throw new NotSupportedException();
}
public void OnEvent(IEventData eventData, SendParameters sendParameters)
{
HandleMessage(new Event(eventData.Code,
eventData.Parameters.ContainsKey(Server.SubCodeParameterCode) ? (int?)Convert.ToInt32(eventData.Parameters[Server.SubCodeParameterCode])
: null, eventData.Parameters));
}
/** Test delegates */
public void test_delegate_event2(IEventData raw)
{
var data = (EventHandlerTestsEvent2) raw;
Value += data.Data;
}
protected void Event(IEventData data)
{
if (RejectNextEvent == data.EventType)
{
data.Cancel = true;
}
Events.Add(data);
}
private void OnDataFound(EventType eventName, IEventData trigger, ref byte[] arrayData) {
if (!trigger.loggable) return;
var thisarray = arrayData;
var count = arrayData.Length;
arrayData = new byte[count];
//Debug.Print("Adding to queue... new count: " + _pendingData.Count);
_pendingData.Enqueue(new QueuePacket(eventName, trigger, thisarray));
}
public UnitEvent(IClaptrapIdentity claptrapIdentity, string eventTypeCode, IEventData data)
{
ClaptrapIdentity = claptrapIdentity;
EventTypeCode = eventTypeCode;
Data = data;
}
public QueuePacket(EventType eventName, IEventData eventData, byte[] arrayData) {
Name = eventName;
EventData = eventData;
ArrayData = arrayData;
}
protected override void OnEvent(IEventData eventData, SendParameters sendParameters)
{
}
public EventPacket(IEventData value)
{
Value = value;
}
/** Trigger an event */
public void Trigger(IEventData data)
{
_events.Trigger(data);
}
/// <summary>
/// 同步发布指定事件
/// </summary>
/// <param name="eventType">事件数据类型</param>
/// <param name="eventData">事件数据</param>
/// <param name="wait">是否等待结果返回</param>
public virtual void Publish(Type eventType, IEventData eventData, bool wait = true)
{
Publish(eventType, null, eventData, wait);
}
public abstract Task Publish(IEventData @event);
/// <summary>
/// 异步发布指定事件
/// </summary>
/// <param name="eventType">事件数据类型</param>
/// <param name="eventData">事件数据</param>
/// <param name="wait">是否等待结果返回</param>
public virtual Task PublishAsync(Type eventType, IEventData eventData, bool wait = true)
{
return(PublishAsync(eventType, null, eventData, wait));
}
protected override void OnEvent(IEventData eventData, SendParameters sendParameters)
{
// do nothing
}
/// <summary>
/// 重写以实现异步触发事件的执行
/// </summary>
/// <param name="factory">事件处理器工厂</param>
/// <param name="eventType">事件类型</param>
/// <param name="eventData">事件数据</param>
/// <param name="wait">是否等待结果返回</param>
/// <returns></returns>
protected virtual Task InvokeHandlerAsync(IEventHandlerFactory factory, Type eventType, IEventData eventData, bool wait = true)
{
EventHandlerDisposeWrapper handlerWrapper = factory.GetHandler();
IEventHandler handler = handlerWrapper.EventHandler;
try
{
if (handler == null)
{
Logger.LogWarning($"事件源“{eventData.GetType()}”的事件处理器无法找到");
return(Task.FromResult(0));
}
if (!handler.CanHandle(eventData))
{
return(Task.FromResult(0));
}
if (wait)
{
return(RunAsync(factory, handler, eventType, eventData));
}
Task.Run(async() =>
{
await RunAsync(factory, handler, eventType, eventData);
});
return(Task.FromResult(0));
}
finally
{
handlerWrapper.Dispose();
}
}
protected virtual void HandleRemoveGameState(IEventData eventData)
{
var removeEvent = new RemoveGameEvent(this.Protocol, eventData);
if (removeEvent.IsValid == false)
{
string msg = removeEvent.GetErrorMessage();
log.ErrorFormat("RemoveGame contract error: {0}", msg);
return;
}
this.application.Lobby.RemoveGame(removeEvent.GameId);
}
private void Run(IEventHandlerFactory factory, IEventHandler handler, Type eventType, IEventData eventData)
{
try
{
handler.Handle(eventData);
}
catch (Exception ex)
{
string msg = $"执行事件“{eventType.Name}”的处理器“{handler.GetType()}”时引发异常：{ex.Message}";
Logger.LogError(ex, msg);
}
}
private void IQEvent(IEventData dc)
{
CapturedEvent = dc.EventType;
CapturedDC = dc;
}
private Task RunAsync(IEventHandlerFactory factory, IEventHandler handler, Type eventType, IEventData eventData)
{
try
{
ICancellationTokenProvider cancellationTokenProvider = _serviceProvider.GetService <ICancellationTokenProvider>();
return(handler.HandleAsync(eventData, cancellationTokenProvider.Token));
}
catch (Exception ex)
{
string msg = $"执行事件“{eventType.Name}”的处理器“{handler.GetType()}”时引发异常：{ex.Message}";
Logger.LogError(ex, msg);
}
return(Task.FromResult(0));
}
public static void UpdateScore(IEventData raw)
{
var data = (CollectableHit) raw;
raw.State.Score.Update(data.Points, "Collected a star!");
/* Play a random star noise~ */
SetupAudio(data.State.Audio);
var id = nRand.Int(1, 3, 0);
data.State.Audio.Play(COLLECT_STAR_CHANNEL, id, 0.6f);
}
/// <summary>
/// 同步发布指定事件
/// </summary>
/// <param name="eventType">事件数据类型</param>
/// <param name="eventData">事件数据</param>
public virtual void PublishSync(Type eventType, IEventData eventData)
{
PublishSync(eventType, null, eventData);
}
public abstract Task <TResponse> Handle(IEventData <TResponse> request, CancellationToken cancellationToken);
/// <summary>
/// 异步发布指定事件
/// </summary>
/// <param name="eventType">事件数据类型</param>
/// <param name="eventData">事件数据</param>
public virtual Task PublishAsync(Type eventType, IEventData eventData)
{
return(PublishAsync(eventType, null, eventData));
}
/// <inheritdoc/>
public void Trigger(Type eventType, IEventData eventData)
{
Trigger(eventType, null, eventData);
}
/// <summary>
/// 重写以实现异步触发事件的执行，默认异步执行将只触发事件启动
/// </summary>
/// <param name="factory">事件处理器工厂</param>
/// <param name="eventType">事件类型</param>
/// <param name="eventData">事件数据</param>
/// <returns></returns>
protected virtual Task InvokeHandlerAsync(IEventHandlerFactory factory, Type eventType, IEventData eventData)
{
IEventHandler handler = factory.GetHandler();
if (!handler.CanHandle(eventData))
{
return(Task.FromResult(0));
}
Task.Run(async() =>
{
try
{
await handler.HandleAsync(eventData);
}
catch (Exception ex)
{
string msg = $"执行事件“{eventType.Name}”的处理器“{handler.GetType()}”时引发异常：{ex.Message}";
_Logger.LogError(ex, msg);
}
finally
{
factory.ReleaseHandler(handler);
}
});
return(Task.FromResult(0));
}
/**
* Queue an event callback.
* <p>
* Note, events are not dispatched until Dispatch() is called.
* Also, if there is no binding for an id, it is not saved.
*/
public void Trigger(IEventData data)
{
data.Handlers = (from h in _bindings where h.Matches(data) select h).ToList();
if (data.Handlers.Any())
_events.Add(data);
}
private static void SerializeEventData(ReusableMemoryStream stream, IEventData eventData)
{
BigEndianBinaryWriter binaryWriter = new BigEndianBinaryWriter(stream);
GpBinaryByteWriter.WriteEventData(binaryWriter, eventData);
}
public UpdateServerEvent(IRpcProtocol protocol, IEventData eventData)
: base(protocol, eventData.Parameters)
{
}
private void IQEvent(IEventData dc)
{
CapturedEvent = dc.EventType;
CapturedDC = dc;
}
protected override void OnEvent(IEventData eventData, SendParameters sendParameters)
{
//Try to get the only parameter
//Should be the RequestMessage
KeyValuePair<byte, object> objectPair = eventData.Parameters.FirstOrDefault();
//TODO: Easyception should offer Now() ctors
Throw<InvalidOperationException>.If.IsTrue(objectPair.Value == null)?.Now();
EventMessage message = deserializer.Deserialize<EventMessage>(objectPair.Value as byte[]);
//TODO: Easyception should offer Now() ctors
Throw<InvalidOperationException>.If.IsTrue(message == null)?.Now();
//TODO: Handle decryption
message.Payload.Deserialize(deserializer);
networkReciever.OnNetworkMessageReceive(message, new PhotonMessageParametersAdapter(sendParameters));
}
/// <summary>
/// 是否可处理指定事件
/// </summary>
/// <param name="eventData">事件源数据</param>
/// <returns>是否可处理</returns>
public virtual bool CanHandle(IEventData eventData)
{
return(eventData.GetType() == typeof(TEventData));
}
//Manages responses to events - when an event is triggered, if anyone has subscribed to it, it will let them know so they can execute code
//Keep in mind - I personify other classes and objects in code(anyone, them, they, he, she, etc) as it makes it a litte easier to talk about.
public void TriggerEvent(FlightEventType eventType, IEventData eventData)
{
OnEventTriggered?.Invoke(eventType, eventData);
}
public void Publish(Type eventType, IEventData eventData, bool wait = true)
{
throw new NotImplementedException();
}
public static void AddSparkles(IEventData raw)
{
var data = (PaddleHit) raw;
var s = data.State;
s.Sparkle.CreateSparkles(data.Position, s.Ball.Velocity, data.Type);
}
public Task PublishAsync(Type eventType, object eventSource, IEventData eventData, bool wait = true)
{
throw new NotImplementedException();
}
public AuthenticateUpdateEvent(IRpcProtocol protocol, IEventData eventData)
: base(protocol, eventData.Parameters)
{
}
/// <summary>
/// Initializes a new instance of the <see cref = "ItemEventMessage" /> class.
/// </summary>
/// <param name = "source">
/// The source.
/// </param>
/// <param name = "eventData">
/// The event Data.
/// </param>
/// <param name = "sendParameters">
/// The send Options.
/// </param>
public ItemEventMessage(Item source, IEventData eventData, SendParameters sendParameters)
{
this.source = source;
this.eventData = eventData;
this.sendParameters = sendParameters;
}
protected virtual void HandleUpdateGameServerEvent(IEventData eventData)
{
var updateGameServer = new UpdateServerEvent(this.Protocol, eventData);
if (updateGameServer.IsValid == false)
{
string msg = updateGameServer.GetErrorMessage();
log.ErrorFormat("UpdateServer contract error: {0}", msg);
return;
}
var previuosLoadLevel = this.LoadLevel;
this.LoadLevel = (FeedbackLevel)updateGameServer.LoadIndex;
this.PeerCount = updateGameServer.PeerCount;
if ((ServerState)updateGameServer.State != this.State)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("GameServer state changed for {0}: old={1}, new={2} ", this.TcpAddress, this.State, (ServerState)updateGameServer.State);
}
this.State = (ServerState)updateGameServer.State;
if (this.State == ServerState.Normal)
{
if (this.application.LoadBalancer.TryAddServer(this, (int)this.LoadLevel) == false)
{
log.WarnFormat("Failed to add game server to load balancer: serverId={0}", this.ServerId);
}
}
else if (this.State == ServerState.Offline)
{
///this.RemoveGameServerPeerOnMaster();
}
else
{
this.application.LoadBalancer.TryRemoveServer(this);
}
}
else if (previuosLoadLevel != this.LoadLevel)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("UpdateGameServer - from LoadLevel {0} to {1}, PeerCount {2}", previuosLoadLevel, this.LoadLevel, this.PeerCount);
}
if (!this.application.LoadBalancer.TryUpdateServer(this, (int)this.LoadLevel))
{
log.WarnFormat("Failed to update game server state for {0}", this.TcpAddress);
}
}
}
//
// EventListener implementation
//
/// <summary><inheritDoc/></summary>
public void EventOccurred(IEventData data, EventType type)
{
switch (type)
{
case EventType.RENDER_IMAGE:
{
ImageRenderInfo renderInfo = (ImageRenderInfo)data;
Matrix ctm = renderInfo.GetImageCtm();
float[] yCoords = new float[4];
for (int x = 0; x < 2; x++)
{
for (int y = 0; y < 2; y++)
{
Vector corner = new Vector(x, y, 1).Cross(ctm);
yCoords[2 * x + y] = corner.Get(Vector.I2);
}
}
Array.Sort(yCoords);
AddVerticalUseSection(yCoords[0], yCoords[3]);
break;
}
case EventType.RENDER_PATH:
{
PathRenderInfo renderInfo = (PathRenderInfo)data;
if (renderInfo.GetOperation() != PathRenderInfo.NO_OP)
{
Matrix ctm = renderInfo.GetCtm();
Path path = renderInfo.GetPath();
foreach (Subpath subpath in path.GetSubpaths())
{
List <float> yCoordsList = new List <float>();
foreach (Point point2d in subpath.GetPiecewiseLinearApproximation())
{
Vector vector = new Vector((float)point2d.GetX(), (float)point2d.GetY(), 1);
vector = vector.Cross(ctm);
yCoordsList.Add(vector.Get(Vector.I2));
}
if (yCoordsList.Count != 0)
{
float[] yCoords = yCoordsList.ToArray();
Array.Sort(yCoords);
AddVerticalUseSection(yCoords[0], yCoords[yCoords.Length - 1]);
}
}
}
break;
}
case EventType.RENDER_TEXT:
{
TextRenderInfo renderInfo = (TextRenderInfo)data;
LineSegment ascentLine = renderInfo.GetAscentLine();
LineSegment descentLine = renderInfo.GetDescentLine();
float[] yCoords = new float[]
{
ascentLine.GetStartPoint().Get(Vector.I2),
ascentLine.GetEndPoint().Get(Vector.I2),
descentLine.GetStartPoint().Get(Vector.I2),
descentLine.GetEndPoint().Get(Vector.I2)
};
Array.Sort(yCoords);
AddVerticalUseSection(yCoords[0], yCoords[3]);
break;
}
default:
{
break;
}
}
}
protected override void OnEvent(IEventData eventData, SendParameters sendParameters)
{
try
{
if (!this.ServerId.HasValue)
{
log.Warn("received game server event but server is not registered");
return;
}
switch ((ServerEventCode)eventData.Code)
{
default:
if (log.IsDebugEnabled)
{
log.DebugFormat("Received unknown event code {0}", eventData.Code);
}
break;
case ServerEventCode.UpdateServer:
this.HandleUpdateGameServerEvent(eventData);
break;
case ServerEventCode.UpdateGameState:
this.HandleUpdateGameState(eventData);
break;
case ServerEventCode.RemoveGameState:
this.HandleRemoveGameState(eventData);
break;
}
}
catch (Exception ex)
{
log.Error(ex);
}
}
public RemoveSession(IRpcProtocol protocol, IEventData eventData)
: base(protocol, eventData.Parameters)
{
}
public RemoveGameEvent(IRpcProtocol protocol, IEventData eventData)
: base(protocol, eventData.Parameters)
{
}
public AttrConstraint(IDataContext context, IEventData e) : base(context, e)
{
}
public static void PlayerTouch(IEventData raw)
{
var data = (PaddleHit)raw;
if (data.Target == data.State.PlayerPaddle) {
raw.State.Score.Update(Config.PointsPerPaddleBounce, "Deflected!");
if (_playerAudio == null) SetupAudio(data.State.Audio);
if (NoBounce())
_playerAudio.Play();
}
else {
if (_aiAudio == null) SetupAudio(data.State.Audio);
if (NoBounce())
_aiAudio.Play();
}
}
private void TriggerHandlingException(Type eventType, object eventSource, IEventData eventData, List <Exception> exceptions)
{
//TODO: This method can be optimized by adding all possibilities to a dictionary.
eventData.EventSource = eventSource;
foreach (var handlerFactories in GetHandlerFactories(eventType))
{
foreach (var handlerFactory in handlerFactories.EventHandlerFactories)
{
var eventHandler = handlerFactory.GetHandler();
try
{
if (eventHandler == null)
{
throw new Exception($"Registered event handler for event type {handlerFactories.EventType.Name} does not implement IEventHandler<{handlerFactories.EventType.Name}> interface!");
}
var handlerType = typeof(IEventHandler <>).MakeGenericType(handlerFactories.EventType);
var method = handlerType.GetMethod(
"HandleEvent",
BindingFlags.Public | BindingFlags.Instance,
null,
new[] { handlerFactories.EventType },
null
);
method.Invoke(eventHandler, new object[] { eventData });
}
catch (TargetInvocationException ex)
{
exceptions.Add(ex.InnerException);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
finally
{
handlerFactory.ReleaseHandler(eventHandler);
}
}
}
//Implements generic argument inheritance. See IEventDataWithInheritableGenericArgument
if (eventType.IsGenericType &&
eventType.GetGenericArguments().Length == 1 &&
typeof(IEventDataWithInheritableGenericArgument).IsAssignableFrom(eventType))
{
var genericArg = eventType.GetGenericArguments()[0];
var baseArg = genericArg.BaseType;
if (baseArg != null)
{
var baseEventType = eventType.GetGenericTypeDefinition().MakeGenericType(baseArg);
var constructorArgs = ((IEventDataWithInheritableGenericArgument)eventData).GetConstructorArgs();
var baseEventData = (IEventData)Activator.CreateInstance(baseEventType, constructorArgs);
baseEventData.EventTime = eventData.EventTime;
Trigger(baseEventType, eventData.EventSource, baseEventData);
}
}
}
public DomainEventEntry(object sourceEntity, IEventData eventData)
{
SourceEntity = sourceEntity;
EventData = eventData;
}
protected override void OnEvent(IEventData eventData, SendParameters sendParameters)
{
_serverPeer.OnEvent(eventData, sendParameters);
}
