public static async void Start(this TrusteeshipComponent self)
{
//玩家所在房间
Room room = Game.Scene.GetComponent <RoomComponent>().Get(self.GetParent <Gamer>().RoomID);
OrderControllerComponent orderController = room.GetComponent <OrderControllerComponent>();
Gamer gamer = self.GetParent <Gamer>();
bool isStartPlayCard = false;
while (true)
{
await Game.Scene.GetComponent <TimerComponent>().WaitAsync(1000);
if (self.IsDisposed)
{
return;
}
if (gamer.UserID != orderController?.CurrentAuthority)
{
continue;
}
//自动出牌开关,用于托管延迟出牌
isStartPlayCard = !isStartPlayCard;
if (isStartPlayCard)
{
continue;
}
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(gamer.Id);
//当还没抢地主时随机抢地主
if (gamer.GetComponent <HandCardsComponent>().AccessIdentity == Identity.None)
{
int randomSelect = RandomHelper.RandomNumber(0, 2);
actorProxy.Send(new Actor_GamerGrabLandlordSelect_Ntt()
{
IsGrab = randomSelect == 0
});
self.Playing = false;
continue;
}
//自动提示出牌
Actor_GamerPrompt_Ack response = await actorProxy.Call(new Actor_GamerPrompt_Req()) as Actor_GamerPrompt_Ack;
if (response.Error > 0 || response.Cards == null)
{
actorProxy.Send(new Actor_GamerDontPlay_Ntt());
}
else
{
await actorProxy.Call(new Actor_GamerPlayCard_Req()
{
Cards = response.Cards
});
}
}
}
/// <summary>
/// 加入房间
/// </summary>
/// <param name="self"></param>
/// <param name="room"></param>
/// <param name="matcher"></param>
public static async void JoinRoom(this MatchComponent self, Room room, Matcher matcher)
{
//玩家加入房间，移除匹配队列
self.Playing[matcher.UserID] = room.Id;
self.MatchSuccessQueue.Enqueue(matcher);
//向房间服务器发送玩家进入请求
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(room.Id);
Actor_PlayerEnterRoom_Ack actor_PlayerEnterRoom_Ack = await actorProxy.Call(new Actor_PlayerEnterRoom_Req()
{
PlayerID = matcher.PlayerID,
UserID = matcher.UserID,
SessionID = matcher.GateSessionID
}) as Actor_PlayerEnterRoom_Ack;
Gamer gamer = GamerFactory.Create(matcher.PlayerID, matcher.UserID, actor_PlayerEnterRoom_Ack.GamerID);
room.Add(gamer);
//向玩家发送匹配成功消息
ActorProxyComponent actorProxyComponent = Game.Scene.GetComponent <ActorProxyComponent>();
ActorProxy gamerActorProxy = actorProxyComponent.Get(gamer.PlayerID);
gamerActorProxy.Send(new Actor_MatchSucess_Ntt()
{
GamerID = gamer.Id
});
}
public async void Dispatch(Session session, Opcode opcode, int offset, byte[] messageBytes, AMessage message)
{
// gate session收到actor消息直接转发给actor自己去处理
if (message is AActorMessage)
{
long unitId = session.GetComponent <SessionPlayerComponent>().Player.mBaseInfo.roleId;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(unitId);
actorProxy.Send(message);
return;
}
// gate session收到actor rpc消息，先向actor 发送rpc请求，再将请求结果返回客户端
if (message is AActorRequest aActorRequest)
{
long unitId = session.GetComponent <SessionPlayerComponent>().Player.mBaseInfo.roleId;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(unitId);
uint rpcId = aActorRequest.RpcId;
AResponse response = await actorProxy.Call <AResponse>(aActorRequest);
response.RpcId = rpcId;
session.Reply(response);
return;
}
if (message != null)
{
Game.Scene.GetComponent <MessageDispatherComponent>().Handle(session, message);
return;
}
throw new Exception($"message type error: {message.GetType().FullName}");
}
public override void Dispose()
{
if (this.Id == 0)
{
return;
}
base.Dispose();
//向登录服务器发送玩家断开消息
string realmAddress = Game.Scene.GetComponent <StartConfigComponent>().RealmConfig.GetComponent <InnerConfig>().Address;
Session realmSession = Game.Scene.GetComponent <NetInnerComponent>().Get(realmAddress);
realmSession.Send(new PlayerDisconnect()
{
UserID = Player.UserID
});
//如果在匹配中或游戏中发送退出消息
if (Player.ActorID != 0)
{
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(Player.ActorID);
actorProxy.Send(new PlayerQuit()
{
PlayerID = Player.Id
});
}
Game.Scene.GetComponent <PlayerComponent>()?.Remove(this.Player.Id);
}
public async void Dispatch(Session session, PacketInfo packetInfo)
{
Type messageType = Game.Scene.GetComponent <OpcodeTypeComponent>().GetType(packetInfo.Header.Opcode);
IMessage message = (IMessage)session.Network.MessagePacker.DeserializeFrom(messageType, packetInfo.Bytes, packetInfo.Index, packetInfo.Length);
// gate session收到actor消息直接转发给actor自己去处理
if (message is IActorMessage)
{
long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(unitId);
actorProxy.Send(message);
return;
}
// gate session收到actor rpc消息，先向actor 发送rpc请求，再将请求结果返回客户端
if (message is IActorRequest aActorRequest)
{
long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(unitId);
IResponse response = await actorProxy.Call(aActorRequest);
session.Reply(packetInfo.Header.RpcId, response);
return;
}
if (message != null)
{
Game.Scene.GetComponent <MessageDispatherComponent>().Handle(session, packetInfo.Header.RpcId, message);
return;
}
throw new Exception($"message type error: {message.GetType().FullName}");
}
public static async void Update(this AutoPlayCardsComponent self)
{
if (!self.Playing)
{
OrderControllerComponent orderController = self.GamerRoom.GetComponent <OrderControllerComponent>();
if (self.Entity.Id == orderController.CurrentAuthority)
{
self.Playing = true;
await Game.Scene.GetComponent <TimerComponent>().WaitAsync(1000);
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(self.GamerRoom.Id);
//当还没抢地主时随机抢地主
if (self.Entity.GetComponent <HandCardsComponent>().AccessIdentity == Identity.None)
{
int randomSelect = RandomHelper.RandomNumber(0, 2);
actorProxy.Send(new GrabLordSelect()
{
PlayerId = self.Entity.Id, IsGrab = randomSelect == 0
});
self.Playing = false;
return;
}
PromptRe promptRE = await actorProxy.Call <PromptRe>(new PromptRt()
{
PlayerId = self.Entity.Id
});
if (promptRE.Error > 0 || promptRE.Cards == null)
{
actorProxy.Send(new Discard()
{
PlayerId = self.Entity.Id
});
}
else
{
await actorProxy.Call <PlayCardsRe>(new PlayCardsRt()
{
PlayerId = self.Entity.Id, Cards = promptRE.Cards
});
}
self.Playing = false;
}
}
}
public async void Dispatch(Session session, Packet packet)
{
ushort opcode = packet.Opcode();
Type messageType = session.Network.Entity.GetComponent <OpcodeTypeComponent>().GetType(opcode);
object message = session.Network.MessagePacker.DeserializeFrom(messageType, packet.Bytes, Packet.Index, packet.Length - Packet.Index);
//Log.Debug($"recv: {JsonHelper.ToJson(message)}");
switch (message)
{
case IFrameMessage iFrameMessage: // 如果是帧消息，构造成OneFrameMessage发给对应的unit
{
long actorId = session.GetComponent <SessionUserComponent>().User.ActorID;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(actorId);
// 这里设置了帧消息的id，防止客户端伪造
iFrameMessage.Id = actorId;
OneFrameMessage oneFrameMessage = new OneFrameMessage
{
Op = opcode,
AMessage = session.Network.MessagePacker.SerializeToByteArray(iFrameMessage)
};
actorProxy.Send(oneFrameMessage);
return;
}
case IActorRequest iActorRequest: // gate session收到actor rpc消息，先向actor 发送rpc请求，再将请求结果返回客户端
{
long actorId = session.GetComponent <SessionUserComponent>().User.ActorID;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(actorId);
int rpcId = iActorRequest.RpcId; // 这里要保存客户端的rpcId
IResponse response = await actorProxy.Call(iActorRequest);
response.RpcId = rpcId;
session.Reply(response);
return;
}
case IActorMessage iActorMessage: // gate session收到actor消息直接转发给actor自己去处理
{
long actorId = session.GetComponent <SessionUserComponent>().User.ActorID;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(actorId);
actorProxy.Send(iActorMessage);
return;
}
}
if (message != null)
{
Game.Scene.GetComponent <MessageDispatherComponent>().Handle(session, new MessageInfo(opcode, message));
return;
}
throw new Exception($"message type error: {message.GetType().FullName}");
}
/// <summary>
/// 准备开始游戏
/// </summary>
/// <param name="self"></param>
public static void ReadyStartGame(this GameControllerComponent self)
{
Room room = self.GetParent <Room>();
Gamer[] gamers = room.GetAll();
//房间内有3名玩家且全部准备则开始游戏
if (room.Count == 3 && gamers.Where(g => g.IsReady).Count() == 3)
{
//同步匹配服务器开始游戏
room.State = RoomState.Game;
MapHelper.SendMessage(new MP2MH_SyncRoomState()
{
RoomID = room.Id, State = room.State
});
//初始玩家开始状态
foreach (var _gamer in gamers)
{
if (_gamer.GetComponent <HandCardsComponent>() == null)
{
_gamer.AddComponent <HandCardsComponent>();
}
_gamer.IsReady = false;
}
GameControllerComponent gameController = room.GetComponent <GameControllerComponent>();
//洗牌发牌
gameController.DealCards();
Dictionary <long, int> gamerCardsNum = new Dictionary <long, int>();
Array.ForEach(gamers, (g) =>
{
HandCardsComponent handCards = g.GetComponent <HandCardsComponent>();
//重置玩家身份
handCards.AccessIdentity = Identity.None;
//记录玩家手牌数
gamerCardsNum.Add(g.UserID, handCards.CardsCount);
});
//发送玩家手牌和其他玩家手牌数
foreach (var _gamer in gamers)
{
ActorProxy actorProxy = _gamer.GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(new M2C_GameStart()
{
GamerCards = _gamer.GetComponent <HandCardsComponent>().GetAll(),
GamerCardsNum = gamerCardsNum
});
}
//随机先手玩家
gameController.RandomFirstAuthority();
Log.Info($"房间{room.Id}开始游戏");
}
}
/// <summary>
/// 游戏结束
/// </summary>
/// <param name="self"></param>
public static async void GameOver(this GameControllerComponent self, Dictionary <long, long> gamersScore, Identity winnerIdentity)
{
Room room = self.GetParent <Room>();
Gamer[] gamers = room.GetAll();
//清理所有卡牌
self.BackToDeck();
room.GetComponent <DeskCardsCacheComponent>().Clear();
//同步匹配服务器结束游戏
room.State = RoomState.Ready;
MapHelper.SendMessage(new MP2MH_SyncRoomState()
{
RoomID = room.Id, State = room.State
});
Dictionary <long, long> gamersMoney = new Dictionary <long, long>();
foreach (Gamer gamer in gamers)
{
//结算玩家余额
long gamerMoney = await self.StatisticalIntegral(gamer, gamersScore[gamer.UserID]);
gamersMoney[gamer.UserID] = gamerMoney;
}
//广播游戏结束消息
room.Broadcast(new M2C_Gameover()
{
Winner = (int)winnerIdentity,
BasePointPerMatch = self.BasePointPerMatch,
Multiples = self.Multiples,
GamersScore = gamersScore
});
//清理玩家
foreach (var _gamer in gamers)
{
//踢出离线玩家
if (_gamer.isOffline)
{
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(_gamer.Id);
await actorProxy.Call(new G2M_PlayerExitRoom());
}
//踢出余额不足玩家
else if (gamersMoney[_gamer.UserID] < self.MinThreshold)
{
ActorProxy actorProxy = _gamer.GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(new M2C_GamerMoneyLess()
{
UserID = _gamer.UserID
});
}
}
}
protected override async void Run(Session session, JoinMatch_RT message, Action <JoinMatch_RE> reply)
{
JoinMatch_RE response = new JoinMatch_RE();
try
{
MatchComponent matchComponent = Game.Scene.GetComponent <MatchComponent>();
if (matchComponent.Playing.ContainsKey(message.UserID))
{
//重连房间
long roomId = matchComponent.Playing[message.UserID];
RoomManagerComponent roomManager = Game.Scene.GetComponent <RoomManagerComponent>();
Room room = roomManager.Get(roomId);
foreach (var gamer in room.GetAll())
{
if (gamer.UserID == message.UserID)
{
long pastId = gamer.Id;
gamer.Id = message.PlayerID;
room.Replace(pastId, gamer);
break;
}
}
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(roomId);
actorProxy.Send(new PlayerReconnect()
{
PlayerID = message.PlayerID, UserID = message.UserID, GateSessionID = message.GateSessionID
});
response.ActorID = roomId;
reply(response);
return;
}
//创建匹配玩家
Matcher matcher = EntityFactory.Create <Matcher, long>(message.PlayerID);
matcher.UserID = message.UserID;
matcher.GateSessionID = message.GateSessionID;
matcher.GateAppID = message.GateAppID;
await matcher.AddComponent <ActorComponent>().AddLocation();
//加入匹配队列
Game.Scene.GetComponent <MatcherComponent>().Add(matcher);
Log.Info($"玩家{message.PlayerID}加入匹配队列");
response.ActorID = matcher.Id;
reply(response);
}
catch (Exception e)
{
ReplyError(response, e, reply);
}
}
/// <summary>
/// 广播消息
/// </summary>
/// <param name="message"></param>
public static void Broadcast(this Room self, IActorMessage message)
{
foreach (Gamer gamer in self.gamers)
{
if (gamer == null || gamer.isOffline)
{
continue;
}
ActorProxy actorProxy = gamer.GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(message);
}
}
public async void Dispatch(Session session, Packet packet)
{
ushort opcode = packet.Opcode();
Type messageType = Game.Scene.GetComponent <OpcodeTypeComponent>().GetType(opcode);
object message = session.Network.MessagePacker.DeserializeFrom(messageType, packet.Bytes, Packet.Index, packet.Length - Packet.Index);
// 如果是帧指令消息，构造成OneFrameMessage发给对应的unit
if (message is IFrameMessage)
{
long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(unitId);
// 这里设置了帧消息的id，防止客户端伪造
IFrameMessage iFrameMessage = (IFrameMessage)message;
iFrameMessage.Id = unitId;
OneFrameMessage oneFrameMessage = new OneFrameMessage();
oneFrameMessage.Op = opcode;
oneFrameMessage.AMessage = session.Network.MessagePacker.SerializeToByteArray(iFrameMessage);
actorProxy.Send(oneFrameMessage);
return;
}
// gate session收到actor消息直接转发给actor自己去处理
if (message is IActorMessage)
{
long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(unitId);
actorProxy.Send((IMessage)message);
return;
}
// gate session收到actor rpc消息，先向actor 发送rpc请求，再将请求结果返回客户端
if (message is IActorRequest aActorRequest)
{
long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(unitId);
IResponse response = await actorProxy.Call(aActorRequest);
session.Reply(response);
return;
}
if (message != null)
{
Game.Scene.GetComponent <MessageDispatherComponent>().Handle(session, new MessageInfo(opcode, message));
return;
}
throw new Exception($"message type error: {message.GetType().FullName}");
}
protected override async void Run(Session session, G2M_PlayerEnterMatch message, Action <M2G_PlayerEnterMatch> reply)
{
M2G_PlayerEnterMatch response = new M2G_PlayerEnterMatch();
try
{
MatchComponent matchComponent = Game.Scene.GetComponent <MatchComponent>();
ActorProxyComponent actorProxyComponent = Game.Scene.GetComponent <ActorProxyComponent>();
if (matchComponent.Playing.ContainsKey(message.UserID))
{
//todo 重连逻辑
MatchRoomComponent matchRoomComponent = Game.Scene.GetComponent <MatchRoomComponent>();
long roomId = matchComponent.Playing[message.UserID];
Room room = matchRoomComponent.Get(roomId);
Gamer gamer = room.Get(message.UserID);
//重置GateActorID
gamer.PlayerID = message.PlayerID;
//重连房间
ActorProxy actorProxy = actorProxyComponent.Get(roomId);
await actorProxy.Call(new MH2MP_PlayerEnterRoom()
{
PlayerID = message.PlayerID,
UserID = message.UserID,
SessionID = message.SessionID
});
//向玩家发送匹配成功消息
ActorProxy gamerActorProxy = actorProxyComponent.Get(gamer.PlayerID);
gamerActorProxy.Send(new M2G_MatchSucess()
{
GamerID = gamer.Id
});
}
else
{
//创建匹配玩家
Matcher matcher = MatcherFactory.Create(message.PlayerID, message.UserID, message.SessionID);
}
reply(response);
}
catch (Exception e)
{
ReplyError(response, e, reply);
}
}
protected override void Run(Session session, Quit message)
{
Player player = Game.Scene.GetComponent <PlayerComponent>().Get(message.PlayerId);
if (player != null)
{
//向Actor对象发送退出消息
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(player.ActorId);
actorProxy.Send(new PlayerQuitDdz()
{
PlayerId = player.Id
});
player.ActorId = 0;
}
}
/// <summary>
/// 游戏结束
/// </summary>
/// <param name="self"></param>
public static async void GameOver(this GameControllerComponent self, Dictionary <long, long> gamersSorce)
{
Room room = self.GetEntity <Room>();
//清理所有卡牌
self.BackToDeck();
room.GetComponent <DeskCardsCacheComponent>().Clear();
//同步匹配服务器结束游戏
room.State = RoomState.Ready;
DDZHelper.SendMessage(new SyncRoomState()
{
RoomId = room.Id, State = room.State
});
Gamer[] gamers = room.GetAll();
for (int i = 0; i < gamers.Length; i++)
{
long gamerMoney = await self.StatisticalIntegral(gamers[i], gamersSorce[gamers[i].Id]);
bool isKickOut = gamers[i].isOffline;
//玩家余额低于最低门槛
if (gamerMoney < self.MinThreshold)
{
ActorProxy actorProxy = gamers[i].GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(new GamerMoneyLess()
{
PlayerId = gamers[i].Id
});
isKickOut = true;
}
//踢出玩家
if (isKickOut)
{
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(self.Entity.Id);
actorProxy.Send(new PlayerQuitDdz()
{
PlayerId = gamers[i].Id
});
}
}
}
protected override void Run(Session session, MatchSuccess message)
{
Player player = Game.Scene.GetComponent <PlayerComponent>().Get(message.PlayerId);
if (player == null)
{
return;
}
//设置玩家的Actor消息直接发送给房间对象
player.ActorId = message.RoomId;
//向玩家发送房间密匙
ActorProxy actorProxy = player.GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(new RoomKey()
{
Key = message.Key
});
}
protected override async Task Run(Gamer gamer, C2M_Trusteeship message)
{
Room room = Game.Scene.GetComponent <RoomComponent>().Get(gamer.RoomID);
//是否已经托管
bool isTrusteeship = gamer.GetComponent <TrusteeshipComponent>() != null;
if (message.isTrusteeship && !isTrusteeship)
{
gamer.AddComponent <TrusteeshipComponent>();
Log.Info($"玩家{gamer.UserID}切换为自动模式");
}
else if (isTrusteeship)
{
gamer.RemoveComponent <TrusteeshipComponent>();
Log.Info($"玩家{gamer.UserID}切换为手动模式");
}
//这里由服务端设置消息UserID用于转发
C2M_Trusteeship transpond = new C2M_Trusteeship();
transpond.isTrusteeship = message.isTrusteeship;
transpond.UserID = gamer.UserID;
//转发消息
room.Broadcast(transpond);
if (isTrusteeship)
{
OrderControllerComponent orderController = room.GetComponent <OrderControllerComponent>();
if (gamer.UserID == orderController.CurrentAuthority)
{
bool isFirst = gamer.UserID == orderController.Biggest;
ActorProxy actorProxy = gamer.GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(new M2C_AuthorityPlayCard()
{
UserID = orderController.CurrentAuthority, IsFirst = isFirst
});
}
}
await Task.CompletedTask;
}
protected override Task Run(Room entity, GrabLordSelect message)
{
OrderControllerComponent orderController = entity.GetComponent <OrderControllerComponent>();
GameControllerComponent gameController = entity.GetComponent <GameControllerComponent>();
if (orderController.CurrentAuthority == message.PlayerId)
{
if (message.IsGrab)
{
orderController.Biggest = message.PlayerId;
gameController.Multiples *= 2;
entity.Broadcast(new GameMultiples()
{
Multiples = gameController.Multiples
});
}
//转发消息
entity.Broadcast(message);
if (orderController.SelectLordIndex >= entity.Count)
{
/*
* 地主：√ 农民1：× 农民2：×
* 地主：× 农民1：√ 农民2：√
* 地主：√ 农民1：√ 农民2：√ 地主2：√
*
* */
if (orderController.Biggest == 0)
{
//没人抢地主则重新发牌
gameController.BackToDeck();
gameController.DealCards();
//发送玩家手牌
Gamer[] gamers = entity.GetAll();
Dictionary <long, int> gamerCardsNum = new Dictionary <long, int>();
Array.ForEach(gamers, gamer => gamerCardsNum.Add(gamer.Id, gamer.GetComponent <HandCardsComponent>().GetAll().Length));
Array.ForEach(gamers, gamer =>
{
ActorProxy actorProxy = gamer.GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(new GameStart()
{
GamerCards = gamer.GetComponent <HandCardsComponent>().GetAll(),
GamerCardsNum = gamerCardsNum
});
});
//随机先手玩家
gameController.RandomFirstAuthority();
return(Task.CompletedTask);
}
else if ((orderController.SelectLordIndex == entity.Count &&
((orderController.Biggest != orderController.FirstAuthority.Key && !orderController.FirstAuthority.Value) ||
orderController.Biggest == orderController.FirstAuthority.Key)) ||
orderController.SelectLordIndex > entity.Count)
{
gameController.CardsOnTable(orderController.Biggest);
return(Task.CompletedTask);
}
}
//当所有玩家都抢地主时先手玩家还有一次抢地主的机会
if (message.PlayerId == orderController.FirstAuthority.Key && message.IsGrab)
{
orderController.FirstAuthority = new KeyValuePair <long, bool>(message.PlayerId, true);
}
orderController.Turn();
orderController.SelectLordIndex++;
entity.Broadcast(new SelectAuthority()
{
PlayerId = orderController.CurrentAuthority
});
}
return(Task.CompletedTask);
}
protected override async Task Run(Gamer gamer, Actor_GamerGrabLandlordSelect_Ntt message)
{
Room room = Game.Scene.GetComponent <RoomComponent>().Get(gamer.RoomID);
OrderControllerComponent orderController = room.GetComponent <OrderControllerComponent>();
GameControllerComponent gameController = room.GetComponent <GameControllerComponent>();
if (orderController.CurrentAuthority == gamer.UserID)
{
//保存抢地主状态
orderController.GamerLandlordState[gamer.UserID] = message.IsGrab;
if (message.IsGrab)
{
orderController.Biggest = gamer.UserID;
gameController.Multiples *= 2;
room.Broadcast(new Actor_SetMultiples_Ntt()
{
Multiples = gameController.Multiples
});
}
//转发消息
Actor_GamerGrabLandlordSelect_Ntt transpond = new Actor_GamerGrabLandlordSelect_Ntt();
transpond.IsGrab = message.IsGrab;
transpond.UserID = gamer.UserID;
room.Broadcast(transpond);
if (orderController.SelectLordIndex >= room.Count)
{
/*
* 地主：√ 农民1：× 农民2：×
* 地主：× 农民1：√ 农民2：√
* 地主：√ 农民1：√ 农民2：√ 地主：√
*
* */
if (orderController.Biggest == 0)
{
//没人抢地主则重新发牌
gameController.BackToDeck();
gameController.DealCards();
//发送玩家手牌
Gamer[] gamers = room.GetAll();
Dictionary <long, int> gamerCardsNum = new Dictionary <long, int>();
Array.ForEach(gamers, _gamer => gamerCardsNum.Add(_gamer.UserID, _gamer.GetComponent <HandCardsComponent>().GetAll().Length));
Array.ForEach(gamers, _gamer =>
{
ActorProxy actorProxy = _gamer.GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(new Actor_GameStart_Ntt()
{
GamerCards = _gamer.GetComponent <HandCardsComponent>().GetAll(),
GamerCardsNum = gamerCardsNum
});
});
//随机先手玩家
gameController.RandomFirstAuthority();
return;
}
else if ((orderController.SelectLordIndex == room.Count &&
((orderController.Biggest != orderController.FirstAuthority.Key && !orderController.FirstAuthority.Value) ||
orderController.Biggest == orderController.FirstAuthority.Key)) ||
orderController.SelectLordIndex > room.Count)
{
gameController.CardsOnTable(orderController.Biggest);
return;
}
}
//当所有玩家都抢地主时先手玩家还有一次抢地主的机会
if (gamer.UserID == orderController.FirstAuthority.Key && message.IsGrab)
{
orderController.FirstAuthority = new KeyValuePair <long, bool>(gamer.UserID, true);
}
orderController.Turn();
orderController.SelectLordIndex++;
room.Broadcast(new Actor_AuthorityGrabLandlord_Ntt()
{
UserID = orderController.CurrentAuthority
});
}
await Task.CompletedTask;
}
protected override Task Run(Room entity, PlayerReady message)
{
Gamer gamer = entity.Get(message.PlayerID);
if (gamer != null)
{
gamer.IsReady = true;
Gamer[] gamers = entity.GetAll();
//转发玩家准备消息
entity.Broadcast(message);
Log.Info($"玩家{gamer.Id}准备");
//房间内有3名玩家且全部准备则开始游戏
if (entity.Count == 3 && gamers.Where(g => g.IsReady).Count() == 3)
{
//同步匹配服务器开始游戏
entity.State = RoomState.Game;
MapHelper.SendMessage(new SyncRoomState()
{
RoomID = entity.Id, State = entity.State
});
//初始玩家开始状态
foreach (var _gamer in gamers)
{
if (_gamer.GetComponent <HandCardsComponent>() == null)
{
_gamer.AddComponent <HandCardsComponent>();
}
_gamer.IsReady = false;
}
GameControllerComponent gameController = entity.GetComponent <GameControllerComponent>();
//洗牌发牌
gameController.DealCards();
Dictionary <long, int> gamerCardsNum = new Dictionary <long, int>();
Array.ForEach(gamers, (g) =>
{
HandCardsComponent handCards = g.GetComponent <HandCardsComponent>();
//重置玩家身份
handCards.AccessIdentity = Identity.None;
//记录玩家手牌数
gamerCardsNum.Add(g.Id, handCards.CardsCount);
});
//发送玩家手牌和其他玩家手牌数
foreach (var _gamer in gamers)
{
ActorProxy actorProxy = _gamer.GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(new GameStart()
{
GamerCards = _gamer.GetComponent <HandCardsComponent>().GetAll(),
GamerCardsNum = gamerCardsNum
});
}
//随机先手玩家
gameController.RandomFirstAuthority();
Log.Info($"房间{entity.Id}开始游戏");
}
}
return(Task.CompletedTask);
}
protected override async Task Run(Room room, MH2MP_PlayerEnterRoom message, Action <MP2MH_PlayerEnterRoom> reply)
{
MP2MH_PlayerEnterRoom response = new MP2MH_PlayerEnterRoom();
try
{
Gamer gamer = room.Get(message.UserID);
if (gamer == null)
{
//创建房间玩家对象
gamer = GamerFactory.Create(message.PlayerID, message.UserID);
await gamer.AddComponent <ActorComponent>().AddLocation();
gamer.AddComponent <UnitGateComponent, long>(message.SessionID);
//加入到房间
room.Add(gamer);
M2C_GamerEnterRoom broadcastMessage = new M2C_GamerEnterRoom();
foreach (Gamer _gamer in room.GetAll())
{
if (_gamer == null)
{
//添加空位
broadcastMessage.Gamers.Add(null);
continue;
}
//添加玩家信息
GamerInfo info = new GamerInfo()
{
UserID = _gamer.UserID, IsReady = _gamer.IsReady
};
broadcastMessage.Gamers.Add(info);
}
//广播房间内玩家消息
room.Broadcast(broadcastMessage);
Log.Info($"玩家{message.UserID}进入房间");
}
else
{
//玩家重连 todo处理牛牛玩家重连逻辑
gamer.isOffline = false;
gamer.PlayerID = message.PlayerID;
gamer.GetComponent <UnitGateComponent>().GateSessionId = message.SessionID;
//玩家重连移除托管组件
gamer.RemoveComponent <TrusteeshipComponent>();
M2C_GamerEnterRoom broadcastMessage = new M2C_GamerEnterRoom();
foreach (Gamer _gamer in room.GetAll())
{
if (_gamer == null)
{
//添加空位
broadcastMessage.Gamers.Add(null);
continue;
}
//添加玩家信息
GamerInfo info = new GamerInfo()
{
UserID = _gamer.UserID, IsReady = _gamer.IsReady
};
broadcastMessage.Gamers.Add(info);
}
//发送房间玩家信息
ActorProxy actorProxy = gamer.GetComponent <UnitGateComponent>().GetActorProxy();
actorProxy.Send(broadcastMessage);
Dictionary <long, Identity> gamersIdentity = new Dictionary <long, Identity>();
Dictionary <long, int> gamersCardsNum = new Dictionary <long, int>();
GameControllerComponent gameController = room.GetComponent <GameControllerComponent>();
OrderControllerComponent orderController = room.GetComponent <OrderControllerComponent>();
DeskCardsCacheComponent deskCardsCache = room.GetComponent <DeskCardsCacheComponent>();
foreach (Gamer _gamer in room.GetAll())
{
HandCardsComponent handCards = _gamer.GetComponent <HandCardsComponent>();
gamersCardsNum.Add(_gamer.UserID, handCards.CardsCount);
gamersIdentity.Add(_gamer.UserID, handCards.AccessIdentity);
}
//发送游戏开始消息
M2C_GameStart gameStartNotice = new M2C_GameStart()
{
GamerCards = gamer.GetComponent <HandCardsComponent>().GetAll(),
GamerCardsNum = gamersCardsNum
};
actorProxy.Send(gameStartNotice);
Card[] lordCards = null;
if (gamer.GetComponent <HandCardsComponent>().AccessIdentity == Identity.None)
{
//广播先手玩家
actorProxy.Send(new M2C_AuthorityGrabLandlord()
{
UserID = orderController.CurrentAuthority
});
}
else
{
if (gamer.UserID == orderController.CurrentAuthority)
{
//发送可以出牌消息
bool isFirst = gamer.UserID == orderController.Biggest;
actorProxy.Send(new M2C_AuthorityPlayCard()
{
UserID = orderController.CurrentAuthority, IsFirst = isFirst
});
}
lordCards = deskCardsCache.LordCards.ToArray();
}
//发送重连数据
M2C_GamerReconnect_ANtt reconnectNotice = new M2C_GamerReconnect_ANtt()
{
Multiples = room.GetComponent <GameControllerComponent>().Multiples,
GamersIdentity = gamersIdentity,
DeskCards = new KeyValuePair <long, Card[]>(orderController.Biggest, deskCardsCache.library.ToArray()),
LordCards = lordCards,
GamerGrabLandlordState = orderController.GamerLandlordState
};
actorProxy.Send(reconnectNotice);
Log.Info($"玩家{message.UserID}重连");
}
response.GamerID = gamer.Id;
reply(response);
}
catch (Exception e)
{
ReplyError(response, e, reply);
}
}
protected override Task Run(Room entity, PlayerReconnect message)
{
Gamer gamer = entity.GetAll().Where(g => g.UserId == message.UserId).FirstOrDefault();
if (gamer != null)
{
long pastId = gamer.Id;
gamer.Id = message.PlayerId;
gamer.isOffline = false;
entity.Replace(pastId, gamer);
gamer.RemoveComponent <AutoPlayCardsComponent>();
UnitGateComponent unitGateComponent = gamer.GetComponent <UnitGateComponent>();
unitGateComponent.GateSessionId = message.GateSessionId;
ActorProxy actorProxy = unitGateComponent.GetActorProxy();
OrderControllerComponent orderController = entity.GetComponent <OrderControllerComponent>();
DeskCardsCacheComponent deskCardsCache = entity.GetComponent <DeskCardsCacheComponent>();
GameControllerComponent gameController = entity.GetComponent <GameControllerComponent>();
//替换过期玩家ID
if (orderController.FirstAuthority.Key == pastId)
{
orderController.FirstAuthority = new KeyValuePair <long, bool>(gamer.Id, orderController.FirstAuthority.Value);
}
if (orderController.Biggest == pastId)
{
orderController.Biggest = gamer.Id;
}
if (orderController.CurrentAuthority == pastId)
{
orderController.CurrentAuthority = gamer.Id;
}
entity.Broadcast(new GamerReenter()
{
PastId = pastId, NewId = gamer.Id
});
//发送房间玩家信息
Gamer[] gamers = entity.GetAll();
GamerInfo[] gamersInfo = new GamerInfo[gamers.Length];
for (int i = 0; i < gamers.Length; i++)
{
gamersInfo[i] = new GamerInfo();
gamersInfo[i].PlayerId = gamers[i].Id;
gamersInfo[i].UserId = gamers[i].UserId;
gamersInfo[i].IsReady = gamers[i].IsReady;
}
actorProxy.Send(new GamerEnter()
{
RoomId = entity.Id, GamersInfo = gamersInfo
});
Dictionary <long, int> gamerCardsNum = new Dictionary <long, int>();
Dictionary <long, Identity> gamersIdentity = new Dictionary <long, Identity>();
Array.ForEach(gamers, (g) =>
{
HandCardsComponent handCards = g.GetComponent <HandCardsComponent>();
gamerCardsNum.Add(g.Id, handCards.CardsCount);
gamersIdentity.Add(g.Id, handCards.AccessIdentity);
});
//发送玩家手牌
actorProxy.Send(new GameStart()
{
GamerCards = gamer.GetComponent <HandCardsComponent>().GetAll(),
GamerCardsNum = gamerCardsNum
});
Card[] lordCards = null;
if (gamer.GetComponent <HandCardsComponent>().AccessIdentity == Identity.None)
{
//广播先手玩家
entity.Broadcast(new SelectAuthority()
{
PlayerId = orderController.CurrentAuthority
});
}
else
{
lordCards = deskCardsCache.LordCards.ToArray();
}
//发送重连消息
actorProxy.Send(new GamerReconnect()
{
PlayerId = gamer.Id,
Multiples = gameController.Multiples,
GamersIdentity = gamersIdentity,
LordCards = lordCards,
DeskCards = new KeyValuePair <long, Card[]>(orderController.Biggest, deskCardsCache.library.ToArray())
});
//发送当前出牌者消息
bool isFirst = orderController.Biggest == orderController.CurrentAuthority;
actorProxy.Send(new AuthorityPlayCard()
{
PlayerId = orderController.CurrentAuthority, IsFirst = isFirst
});
Log.Info($"玩家{gamer.Id}重连");
}
return(Task.CompletedTask);
}
