public static void Broadcast(Unit unit, IActorMessage message)
{
foreach (var u in unit.GetBeSeeUnits())
{
SendToClient(u.GetParent <Unit>(), message);
}
}
public static void Broadcast(IActorMessage message)
{
Unit[] units = Game.Scene.GetComponent <UnitComponent>().GetAll();
//actor位置发送组件
ActorMessageSenderComponent actorLocationSenderComponent = Game.Scene.GetComponent <ActorMessageSenderComponent>();
//遍历每一个单位
foreach (Unit unit in units)
{
//获取到它们的网关组件 里面存储的是网关服务器里的Session Id 用于跟客户端进行通信的
UnitGateComponent unitGateComponent = unit.GetComponent <UnitGateComponent>();
if (unitGateComponent.IsDisconnect)
{
continue;
}
//通过网关sessionID找到 玩家是在哪个网关服务器(进程)
ActorMessageSender actorMessageSender = actorLocationSenderComponent.Get(unitGateComponent.GateSessionActorId);
//内部就去进行创建会话实体 连接到网关.. 将消息发送给网关 网关那边去处理一下就好了..
//不过demo里并没有看到网关有处理这条协议
actorMessageSender.Send(message);
//建议:其实进程之间的通信,是通过socket来实现的,那维护好对应的socket不就行了
//最好省去各种由Id找到另一个Id的逻辑,不利于应对后续的变化
}
}
public void SendMessage(IActorMessage message)
{
// EthanDebug
//if(message is M2C_MapUnitCreate m2C_MapUnitCreate)
//{
// for(int i = 0; i < ReceviceMambers.Count; i++)
// {
// m2C_MapUnitCreate.MapUnitInfo.DebugId = IdGenerater.GenerateId();
// var rev = ReceviceMambers[i];
// BsonDocument doc = new BsonDocument
// {
// { "Block.room.Id" , Block?.room?.Id },
// { "Block.roomId" , Block?.roomId },
// { "Block.blockId" , Block?.blockId },
// { "rev.Id" , rev?.Id },
// { "rev.MapAppId" , IdGenerater.GetAppId(rev == null ? 0 : rev.Id) },
// { "rev.Uid" , rev?.Uid },
// { "rev.RoomId" , rev?.RoomId },
// { "rev.Room.Id" , rev?.Room?.Id },
// { "rev.Block.room.Id" , rev?.Block?.room?.Id },
// { "rev.Block.roomId" , rev?.Block?.roomId },
// { "rev.Block.blockId" , rev?.Block?.blockId },
// { "sendToList", ReceviceMambers.Select(e => $"MapUnitId:{e.Id}, Uid:{e.Uid}, BlockId:{e.Block?.blockId}").ToJson() }
// };
// Log.Trace($"DebugId[{m2C_MapUnitCreate.MapUnitInfo.DebugId}]> {doc.ToJson()}");
// }
//}
MapMessageHelper.BroadcastTarget(message, ReceviceMambers);
}
public static void SendToClient(Unit unit, IActorMessage message)
{
if (unit.GetComponent <UnitGateComponent>() != null)
{
SendActor(unit.GetComponent <UnitGateComponent>().GateSessionActorId, message);
}
}
public async Task Handle(Session session, Entity entity, IActorMessage actorMessage)
{
ActorResponse actorResponse = new ActorResponse
{
RpcId = actorMessage.RpcId
};
try
{
// 发送给客户端
Session clientSession = entity as Session;
actorMessage.ActorId = 0;
clientSession.Send(actorMessage);
session.Reply(actorResponse);
await Task.CompletedTask;
}
catch (Exception e)
{
actorResponse.Tag = ErrorCode.ERR_SessionActorError;
actorResponse.Message = $"session actor error {e}";
session.Reply(actorResponse);
throw;
}
}
public void AddMessage(IActorMessage msg)
{
try
{
EventData eventData = SendBytesToEventHub.BuildMessage <MsgType>(msg);
EventHubClient.Send(eventData);
if (null == msg.Status)
{
msg.Status = new TaskCompletionSource <IActorMessage>();
}
msg.Status?.SetResult(new EventHubMessage(eventData));
}
catch (Exception ex)
{
Exception foundEx = null;
var handler = this.FindExceptionHandler(_exceptionTypeToHandler, ex, out foundEx);
if (null != handler)
{
handler.Invoke(foundEx);
}
if (null != msg.Status && !msg.Status.Task.IsCanceled)
{
msg.Status.TrySetException(ex);
}
}
}
public static void Broadcast(IActorMessage message)
{
//广播事件
Ship[] ships = Game.Scene.GetComponent <ShipComponent>().GetAll();
ActorMessageSenderComponent actorLocationSenderComponent = Game.Scene.GetComponent <ActorMessageSenderComponent>();
foreach (Ship ship in ships)
{
ShipGateComponent shipGateComponent = ship.GetComponent <ShipGateComponent>();
if (shipGateComponent.IsDisconnect)
{
continue;
}
ActorMessageSender actorMessageSender = actorLocationSenderComponent.Get(shipGateComponent.GateSessionActorId);
actorMessageSender.Send(message);
}
//Unit[] units = Game.Scene.GetComponent<UnitComponent>().GetAll();
//ActorMessageSenderComponent actorLocationSenderComponent = Game.Scene.GetComponent<ActorMessageSenderComponent>();
//foreach (Unit unit in units)
//{
// UnitGateComponent unitGateComponent = unit.GetComponent<UnitGateComponent>();
// if (unitGateComponent.IsDisconnect)
// {
// continue;
// }
// ActorMessageSender actorMessageSender = actorLocationSenderComponent.Get(unitGateComponent.GateSessionActorId);
// actorMessageSender.Send(message);
//}
}
public static async ETVoid HandleIActorMessage(Session session, IActorMessage iActorMessage)
{
long replyId = IdGenerater.GetProcessId(iActorMessage.ActorId);
iActorMessage.ActorId = iActorMessage.ActorId & IdGenerater.HeadMask | IdGenerater.Head;
Entity entity = Game.EventSystem.Get(iActorMessage.ActorId);
if (entity == null)
{
Log.Error($"not found actor: {MongoHelper.ToJson(iActorMessage)}");
return;
}
MailBoxComponent mailBoxComponent = entity.GetComponent <MailBoxComponent>();
if (mailBoxComponent == null)
{
Log.Error($"actor not add MailBoxComponent: {entity.GetType().Name} {iActorMessage}");
return;
}
Session ss = NetInnerComponent.Instance.Get(replyId);
await mailBoxComponent.Handle(ss, iActorMessage);
}
private void ProcessIActorMessageMessagePump(object state)
{
bool useThreadPool = ((bool)state);
IActorMessage msg = null;
_actorRegistered.WaitOne();
_actorRegistered.Set();
for (;;)
{
msg = GetNextMessage();
if (ShouldExit())
{
return;
}
if (null == msg)
{
continue;
}
if (typeof(ControlMessages.HangUp) == msg.GetType())
{
if (null != msg.Status && !msg.Status.Task.IsCompleted)
{
msg.Status.SetResult(msg);
}
//this.Disable();
return;
}
Interlocked.Increment(ref tellingCount);
if (useThreadPool)
{
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(ProcessIActorMessageOnThreadPoolFcn), msg);
}
else
{
IActor actor = null;
try
{
actor = GetActorForMessage(msg);
if (null == actor)
{
throw new NoActorForMessageTypeException(msg.GetType().FullName);
}
ProcessIActorMessage(ref actor, msg);
}
catch (Exception ex)
{
CheckForAndRunExceptionHandler(ex, actor, msg);
}
}
}
}
//给房间内的所有玩家广播消息
public static void BroadcastMssagePlayers(this FiveStarRoom fiveStarRoom, IActorMessage iActorMessage)
{
foreach (var player in fiveStarRoom.FiveStarPlayerDic.Values)
{
player.SendMessageUser(iActorMessage);
}
}
public static void Send(this ActorMessageSender self, IActorMessage message)
{
Session session = Game.Scene.GetComponent <NetInnerComponent>().Get(self.Address);
message.ActorId = self.ActorId;
session.Send(message);
}
//给房间内的所有玩家广播消息
public static void BroadcastMssagePlayers(this JoyLdsRoom joyLdsRoom, IActorMessage iActorMessage)
{
foreach (var player in joyLdsRoom.pJoyLdsPlayerDic.Values)
{
player.SendMessageUser(iActorMessage);
}
}
public static async ETTask Handle(this MailBoxComponent self, Session session, IActorMessage message)
{
using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Mailbox, message.ActorId))
{
switch (self.MailboxType)
{
case MailboxType.GateSession:
IActorMessage iActorMessage = message as IActorMessage;
// 发送给客户端
Session clientSession = self.Parent as Session;
iActorMessage.ActorId = 0;
clientSession.Send(iActorMessage);
break;
case MailboxType.MessageDispatcher:
await ActorMessageDispatcherComponent.Instance.Handle(self.Parent, session, message);
break;
case MailboxType.UnOrderMessageDispatcher:
self.HandleInner(session, message).Coroutine();
break;
}
}
}
public async Task Handle(Session session, Entity entity, IActorMessage actorRequest)
{
try
{
Request request = actorRequest as Request;
if (request == null)
{
Log.Error($"消息类型转换错误: {actorRequest.GetType().FullName} to {typeof (Request).Name}");
return;
}
E e = entity as E;
if (e == null)
{
Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
return;
}
int rpcId = request.RpcId;
await this.Run(e, request, response =>
{
// 等回调回来,session可以已经断开了,所以需要判断session id是否为0
if (session.IsDisposed)
{
return;
}
response.RpcId = rpcId;
session.Reply(response);
});
}
catch (Exception e)
{
throw new Exception($"解释消息失败: {actorRequest.GetType().FullName}", e);
}
}
public async Task Handle(Session session, Entity entity, IActorMessage actorRequest)
{
Message msg = actorRequest as Message;
if (msg == null)
{
Log.Error($"消息类型转换错误: {actorRequest.GetType().FullName} to {typeof (Message).Name}");
return;
}
E e = entity as E;
if (e == null)
{
Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
return;
}
await this.Run(e, msg);
// 等回调回来,session可以已经断开了,所以需要判断session id是否为0
if (session.IsDisposed)
{
return;
}
ActorResponse response = new ActorResponse
{
RpcId = actorRequest.RpcId
};
session.Reply(response);
}
public async Task Handle(Session session, Entity entity, IActorMessage actorRequest)
{
Message msg = actorRequest as Message;
if (msg == null)
{
Log.Error($"消息类型转换错误: {actorRequest.GetType().FullName} to {typeof (Message).Name}");
return;
}
E e = entity as E;
if (e == null)
{
Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
return;
}
int rpcId = actorRequest.RpcId;
ActorResponse response = new ActorResponse
{
RpcId = rpcId
};
session.Reply(response);
await this.Run(e, msg);
}
protected bool ProcessIActorMessage(ref IActor actor, IActorMessage msg)
{
System.Diagnostics.Debug.Assert(null != actor);
if (null != msg.Status && msg.Status.Task.IsCanceled)
{
return(true);
}
if (actor is IHasMailbox)
{
actor.OnMessageRecieved(msg);
}
else
{
actor.OnMessageRecieved(msg);
if (null != msg.Status && !msg.Status.Task.IsCanceled)
{
if (msg.Message is IActorMessage)
{
msg.Status.TrySetResult((IActorMessage)msg.Message);
}
else
{
msg.Status.TrySetResult(msg);
}
}
}
return(true);
}
//广播消息
public static void BroadcastActorMessage(this MatchRoom matchRoom, IActorMessage iActorMessage)
{
foreach (var player in matchRoom.PlayerInfoDic)
{
player.Value.User.SendeSessionClientActor(iActorMessage);
}
}
/// <summary>
/// 后来增加群发 , 发给指定的客户端群
/// </summary>
/// <param name="message"></param>
/// <param name="playerUnitId"></param>
public static void Broadcast(IActorMessage message, long[] playerUnitIds)
{
foreach (long pi in playerUnitIds)
{
Broadcast(message, pi);
}
}
public static void SendSessionClientActor(this User user, IActorMessage message)
{
if (user.GetComponent <UserGateActorIdComponent>() != null)
{
long actorId = user.GetComponent <UserGateActorIdComponent>().ActorId;
ActorHelp.SendActor(actorId, message);
}
}
internal static DirectoryQueueMessage BuildMessage(IActorMessage msg)
{
DirectoryQueueMessage cloudMessage = new DirectoryQueueMessage();
byte[] msgBytes = TempSerialization.GetBytes <MsgType>(msg);
cloudMessage.SetMessageContent(msgBytes);
return(cloudMessage);
}
public static void Send(this ActorProxy self, IActorMessage message)
{
ActorTask task = new ActorTask {
message = message, proxy = self
};
self.Add(task);
}
protected virtual IActor GetActorForMessage(IActorMessage msg)
{
IActor actor = null;
_messageTypeToActor.TryGetValue(msg.GetType(), out actor);
return(actor);
}
public bool Print(IActorMessage message)
{
Console.WriteLine("Sleeping for 10 seconds");
System.Threading.Thread.Sleep(100000);
Console.WriteLine(((IActorMessage)message).Message.ToString());
return(true);
}
public async Task Handle(Session session, Entity entity, IActorMessage actorRequest)
{
if (!this.handlers.TryGetValue(actorRequest.GetType(), out IMActorHandler handler))
{
throw new Exception($"not found message handler: {MongoHelper.ToJson(actorRequest)}");
}
await handler.Handle(session, entity, actorRequest);
}
public static void SendeActor(long actorId, IActorMessage iActorMessage)
{
if (actorId == 0)
{
return;
}
ActorMessageSender actorSender = Game.Scene.GetComponent<ActorMessageSenderComponent>().Get(actorId);
actorSender.Send(iActorMessage);
}
public static void Broadcast(Unit unit, IActorMessage message)
{
Dictionary <long, AOIEntity> dict = unit.GetBeSeePlayers();
foreach (AOIEntity u in dict.Values)
{
SendToClient(u.Unit, message);
}
}
public void AddMessage(IActorMessage msg)
{
if (msg is ControlMessages.HangUp)
{
if (!recieveMessagesOnly)
{
if (null != msg.Status && !msg.Status.Task.IsCompleted)
{
msg.Status.SetResult(msg);
}
return;
}
hangUp = (msg as ControlMessages.HangUp);
Kill();
return;
}
if (recieveMessagesOnly)
{
throw new Telegraphy.Net.OperatorCannotSendMessagesException();
}
// Serialize the message first
try
{
if (msg is MsgType)
{
SerializeAndSend(msg, Queue, (MsgType)msg);
}
else if ((msg as IActorMessage).Message is MsgType)
{
SerializeAndSend(msg, Queue, (MsgType)(msg as IActorMessage).Message);
}
else
{
throw new DontKnowHowToSerializeTypeException(msg.GetType().ToString());
}
if (null != msg.Status && !msg.Status.Task.IsCanceled)
{
msg.Status.TrySetResult(msg);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.GetType() + ":" + ex.Message + ex.StackTrace);
Exception foundEx = null;
var handler = this.FindExceptionHandler(_exceptionTypeToHandler, ex, out foundEx);
if (null != handler)
{
handler.Invoke(foundEx);
}
}
}
/// <summary>
/// 发送协议给Actor
/// </summary>
/// <param name="actorId">注册Actor的InstanceId</param>
/// <param name="message"></param>
public static void Send(Unit u, IActorMessage message)
{
UnitGateComponent unitGateComponent = u.GetComponent <UnitGateComponent>();
if (unitGateComponent.IsDisconnect)
{
return;
}
ActorMessageSenderComponent.Instance.Send(unitGateComponent.GateSessionActorId, message);
}
public static void Send(this ActorMessageSender self, IActorMessage message)
{
Log.Info($"ActorMessageSenderHelper:{self.Address}");
//连接网关内网服务器
Session session = Game.Scene.GetComponent <NetInnerComponent>().Get(self.Address);
message.ActorId = self.ActorId;
//发送数据
session.Send(message);
}
