protected override async Task Run(Room unit, Prompt_RT message, Action <Prompt_RE> reply)
{
Prompt_RE response = new Prompt_RE();
try
{
Gamer gamer = unit.Get(message.PlayerID);
if (gamer != null)
{
List <Card> handCards = new List <Card>(gamer.GetComponent <HandCardsComponent>().GetAll());
CardsHelper.SortCards(handCards);
if (gamer.Id == unit.GetComponent <OrderControllerComponent>().Biggest)
{
response.Cards = handCards.Where(card => card.CardWeight == handCards[handCards.Count - 1].CardWeight).ToArray();
}
else
{
DeskCardsCacheComponent deskCardsCache = unit.GetComponent <DeskCardsCacheComponent>();
List <Card[]> result = await CardsHelper.GetPrompt(handCards, deskCardsCache, deskCardsCache.Rule);
if (result.Count > 0)
{
response.Cards = result[RandomHelper.RandomNumber(0, result.Count)];
}
}
}
reply(response);
}
catch (Exception e)
{
ReplyError(response, e, reply);
}
}
/// <summary>
/// 发牌
/// </summary>
/// <returns></returns>
public static Card Deal(this DeskCardsCacheComponent self)
{
Card card = self.library[self.CardsCount - 1];
self.library.Remove(card);
return(card);
}
/// <summary>
/// 发地主牌
/// </summary>
/// <param name="self"></param>
/// <param name="id"></param>
public static void CardsOnTable(this GameControllerComponent self, long id)
{
LandlordsRoom room = self.GetParent <LandlordsRoom>();
DeskCardsCacheComponent deskCardsCache = room.GetComponent <DeskCardsCacheComponent>();
OrderControllerComponent orderController = room.GetComponent <OrderControllerComponent>();
HandCardsComponent handCards = room.GetGamerFromUserID(id).GetComponent <HandCardsComponent>();
orderController.Start(id);
for (int i = 0; i < 3; i++)
{
Card card = deskCardsCache.Deal();
handCards.AddCard(card);
}
//更新玩家身份
foreach (var gamer in room.gamers)
{
Identity gamerIdentity = gamer.UserID == id ? Identity.Landlord : Identity.Farmer;
self.UpdateInIdentity(gamer, gamerIdentity);
}
//广播地主消息
room.Broadcast(new Actor_SetLandlord_Ntt()
{
UserID = id, LordCards = To.RepeatedField(deskCardsCache.LordCards)
});
//广播地主先手出牌消息
room.Broadcast(new Actor_AuthorityPlayCard_Ntt()
{
UserID = id, IsFirst = true
});
}
protected override async Task Run(Gamer gamer, Actor_GamerPrompt_Req message, Action <Actor_GamerPrompt_Ack> reply)
{
Actor_GamerPrompt_Ack response = new Actor_GamerPrompt_Ack();
try
{
Room room = Game.Scene.GetComponent <RoomComponent>().Get(gamer.RoomID);
OrderControllerComponent orderController = room.GetComponent <OrderControllerComponent>();
DeskCardsCacheComponent deskCardsCache = room.GetComponent <DeskCardsCacheComponent>();
List <Card> handCards = new List <Card>(gamer.GetComponent <HandCardsComponent>().GetAll());
CardsHelper.SortCards(handCards);
if (gamer.UserID == orderController.Biggest)
{
response.Cards.AddRange(handCards.Where(card => card.CardWeight == handCards[handCards.Count - 1].CardWeight).ToArray());
}
else
{
List <IList <Card> > result = await CardsHelper.GetPrompt(handCards, deskCardsCache, deskCardsCache.Rule);
if (result.Count > 0)
{
response.Cards.AddRange(result[RandomHelper.RandomNumber(0, result.Count)]);
}
}
reply(response);
}
catch (Exception e)
{
ReplyError(response, e, reply);
}
}
/// <summary>
/// 发地主牌
/// </summary>
/// <param name="self"></param>
/// <param name="id"></param>
public static void CardsOnTable(this GameControllerComponent self, long id)
{
Room room = self.GetEntity <Room>();
DeskCardsCacheComponent deskCardsCache = room.GetComponent <DeskCardsCacheComponent>();
OrderControllerComponent orderController = room.GetComponent <OrderControllerComponent>();
HandCardsComponent handCards = room.Get(id).GetComponent <HandCardsComponent>();
orderController.Start(id);
for (int i = 0; i < 3; i++)
{
Card card = deskCardsCache.Deal();
handCards.AddCard(card);
}
//更新玩家身份
foreach (var gamer in room.GetAll())
{
Identity gamerIdentity = gamer.Id == id ? Identity.Landlord : Identity.Farmer;
self.UpdateInIdentity(gamer, gamerIdentity);
}
//广播地主消息
room.Broadcast(new SelectLord()
{
PlayerId = id, LordCards = deskCardsCache.LordCards.ToArray()
});
//广播地主先手出牌消息
room.Broadcast(new AuthorityPlayCard()
{
PlayerId = id, IsFirst = true
});
}
/// <summary>
/// 清空牌桌
/// </summary>
/// <param name="self"></param>
public static void Clear(this DeskCardsCacheComponent self)
{
DeckComponent deck = self.Entity.GetComponent <DeckComponent>();
while (self.CardsCount > 0)
{
Card card = self.library[self.CardsCount - 1];
self.library.Remove(card);
deck.AddCard(card);
}
self.Rule = CardsType.None;
}
/// <summary>
/// 场上的所有牌回到牌库中
/// </summary>
/// <param name="self"></param>
public static void BackToDeck(this GameControllerComponent self)
{
Room room = self.GetEntity <Room>();
DeckComponent deckComponent = room.GetComponent <DeckComponent>();
DeskCardsCacheComponent deskCardsCache = room.GetComponent <DeskCardsCacheComponent>();
//回收牌桌卡牌
deskCardsCache.Clear();
deskCardsCache.LordCards.Clear();
//回收玩家手牌
foreach (var gamer in room.GetAll())
{
HandCardsComponent handCards = gamer.GetComponent <HandCardsComponent>();
while (handCards.CardsCount > 0)
{
Card card = handCards.Library[handCards.CardsCount - 1];
handCards.PopCard(card);
deckComponent.AddCard(card);
}
}
}
/// <summary>
/// 发牌
/// </summary>
/// <param name="id"></param>
public static void DealTo(this GameControllerComponent self, long id)
{
Room room = self.GetEntity <Room>();
Card card = room.GetComponent <DeckComponent>().Deal();
if (id == room.Id)
{
DeskCardsCacheComponent deskCardsCache = room.GetComponent <DeskCardsCacheComponent>();
deskCardsCache.AddCard(card);
deskCardsCache.LordCards.Add(card);
}
else
{
foreach (var gamer in room.GetAll())
{
if (id == gamer.Id)
{
gamer.GetComponent <HandCardsComponent>().AddCard(card);
break;
}
}
}
}
protected override async Task Run(Gamer gamer, Actor_GamerPlayCard_Req message, Action <Actor_GamerPlayCard_Ack> reply)
{
Actor_GamerPlayCard_Ack response = new Actor_GamerPlayCard_Ack();
try
{
Room room = Game.Scene.GetComponent <RoomComponent>().Get(gamer.RoomID);
GameControllerComponent gameController = room.GetComponent <GameControllerComponent>();
DeskCardsCacheComponent deskCardsCache = room.GetComponent <DeskCardsCacheComponent>();
OrderControllerComponent orderController = room.GetComponent <OrderControllerComponent>();
//检测是否符合出牌规则
if (CardsHelper.PopEnable(message.Cards, out CardsType type))
{
//当前出牌牌型是否比牌桌上牌型的权重更大
bool isWeightGreater = CardsHelper.GetWeight(message.Cards, type) > deskCardsCache.GetTotalWeight();
//当前出牌牌型是否和牌桌上牌型的数量一样
bool isSameCardsNum = message.Cards.count == deskCardsCache.GetAll().Length;
//当前出牌玩家是否是上局最大出牌者
bool isBiggest = orderController.Biggest == orderController.CurrentAuthority;
//当前牌桌牌型是否是顺子
bool isStraight = deskCardsCache.Rule == CardsType.Straight || deskCardsCache.Rule == CardsType.DoubleStraight || deskCardsCache.Rule == CardsType.TripleStraight;
//当前出牌牌型是否和牌桌上牌型一样
bool isSameCardsType = type == deskCardsCache.Rule;
if (isBiggest || //先手出牌玩家
type == CardsType.JokerBoom || //王炸
type == CardsType.Boom && isWeightGreater || //更大的炸弹
isSameCardsType && isStraight && isSameCardsNum && isWeightGreater || //更大的顺子
isSameCardsType && isWeightGreater) //更大的同类型牌
{
if (type == CardsType.JokerBoom)
{
//王炸翻4倍
gameController.Multiples *= 4;
room.Broadcast(new Actor_SetMultiples_Ntt()
{
Multiples = gameController.Multiples
});
}
else if (type == CardsType.Boom)
{
//炸弹翻2倍
gameController.Multiples *= 2;
room.Broadcast(new Actor_SetMultiples_Ntt()
{
Multiples = gameController.Multiples
});
}
}
else
{
response.Error = ErrorCode.ERR_PlayCardError;
reply(response);
return;
}
}
else
{
response.Error = ErrorCode.ERR_PlayCardError;
reply(response);
return;
}
//如果符合将牌从手牌移到出牌缓存区
deskCardsCache.Clear();
deskCardsCache.Rule = type;
HandCardsComponent handCards = gamer.GetComponent <HandCardsComponent>();
foreach (var card in message.Cards)
{
handCards.PopCard(card);
deskCardsCache.AddCard(card);
}
reply(response);
//转发玩家出牌消息
room.Broadcast(new Actor_GamerPlayCard_Ntt()
{
UserID = gamer.UserID, Cards = message.Cards
});
//游戏控制器继续游戏
gameController.Continue(gamer);
}
catch (Exception e)
{
ReplyError(response, e, reply);
}
}
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);
}
}
/// <summary>
/// 手牌排序
/// </summary>
/// <param name="self"></param>
public static void Sort(this DeskCardsCacheComponent self)
{
CardsHelper.SortCards(self.library);
}
protected override Task Run(Room unit, PlayCards_RT message, Action <PlayCards_RE> reply)
{
PlayCards_RE response = new PlayCards_RE();
try
{
Gamer gamer = unit.Get(message.PlayerID);
if (gamer == null)
{
response.Error = ErrorCode.ERR_PlayCardError;
reply(response);
return(Task.CompletedTask);
}
GameControllerComponent gameController = unit.GetComponent <GameControllerComponent>();
DeskCardsCacheComponent deskCardsCache = unit.GetComponent <DeskCardsCacheComponent>();
OrderControllerComponent orderController = unit.GetComponent <OrderControllerComponent>();
//检测是否符合出牌规则
if (CardsHelper.PopEnable(message.Cards, out CardsType type))
{
if (orderController.Biggest == orderController.CurrentAuthority ||
type == CardsType.JokerBoom ||
type == CardsType.Boom && CardsHelper.GetWeight(message.Cards, type) > deskCardsCache.GetTotalWeight() ||
(deskCardsCache.Rule == CardsType.Straight || deskCardsCache.Rule == CardsType.DoubleStraight || deskCardsCache.Rule == CardsType.TripleStraight) && type == deskCardsCache.Rule && message.Cards.Length == deskCardsCache.GetAll().Length&& CardsHelper.GetWeight(message.Cards, type) > deskCardsCache.GetTotalWeight() ||
type == deskCardsCache.Rule && CardsHelper.GetWeight(message.Cards, type) > deskCardsCache.GetTotalWeight())
{
if (type == CardsType.JokerBoom)
{
gameController.Multiples *= 4;
unit.Broadcast(new GameMultiples()
{
Multiples = gameController.Multiples
});
}
else if (type == CardsType.Boom)
{
gameController.Multiples *= 2;
unit.Broadcast(new GameMultiples()
{
Multiples = gameController.Multiples
});
}
}
else
{
response.Error = ErrorCode.ERR_PlayCardError;
reply(response);
return(Task.CompletedTask);
}
}
else
{
response.Error = ErrorCode.ERR_PlayCardError;
reply(response);
return(Task.CompletedTask);
}
//如果符合将牌从手牌移到出牌缓存区
deskCardsCache.Clear();
deskCardsCache.Rule = type;
HandCardsComponent handCards = gamer.GetComponent <HandCardsComponent>();
foreach (var card in message.Cards)
{
handCards.PopCard(card);
deskCardsCache.AddCard(card);
}
//转发玩家出牌消息
unit.Broadcast(new GamerPlayCards()
{
PlayerID = gamer.Id, Cards = message.Cards
});
if (handCards.CardsCount == 0)
{
Identity winnerIdentity = unit.Get(orderController.Biggest).GetComponent <HandCardsComponent>().AccessIdentity;
Dictionary <long, long> gamersScore = new Dictionary <long, long>();
foreach (var _gamer in unit.GetAll())
{
_gamer.RemoveComponent <AutoPlayCardsComponent>();
gamersScore.Add(_gamer.Id, gameController.GetScore(_gamer, winnerIdentity));
//玩家剩余出牌
if (_gamer.Id != message.PlayerID)
{
Card[] _gamerCards = _gamer.GetComponent <HandCardsComponent>().GetAll();
unit.Broadcast(new GamerPlayCards()
{
PlayerID = _gamer.Id, Cards = _gamerCards
});
}
}
//游戏结束结算
gameController.GameOver(gamersScore);
//广播游戏结束消息
unit.Broadcast(new Gameover()
{
Winner = winnerIdentity,
BasePointPerMatch = gameController.BasePointPerMatch,
Multiples = gameController.Multiples,
GamersScore = gamersScore
});
}
else
{
//轮到下位玩家出牌
orderController.Biggest = gamer.Id;
orderController.Turn();
unit.Broadcast(new AuthorityPlayCard()
{
PlayerID = orderController.CurrentAuthority, IsFirst = false
});
}
reply(response);
}
catch (Exception e)
{
ReplyError(response, e, reply);
}
return(Task.CompletedTask);
}
/// <summary>
/// 获取牌桌所有牌
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static Card[] GetAll(this DeskCardsCacheComponent self)
{
return(self.library.ToArray());
}
/// <summary>
/// 获取总权值
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static int GetTotalWeight(this DeskCardsCacheComponent self)
{
return(CardsHelper.GetWeight(self.library.ToArray(), self.Rule));
}
/// <summary>
/// 提示出牌
/// </summary>
/// <param name="cards"></param>
/// <returns></returns>
public static async Task <List <IList <Card> > > GetPrompt(List <Card> cards, DeskCardsCacheComponent deskCardsCache, CardsType type)
{
List <IList <Card> > result = new List <IList <Card> >();
IList <Card> deskCards = deskCardsCache.GetAll();
int weight = deskCardsCache.GetTotalWeight();
if (type == CardsType.JokerBoom)
{
return(result);
}
//检索王炸
if (cards.Count >= 2)
{
IList <Card> groupCards = new Card[2];
groupCards[0] = cards[0];
groupCards[1] = cards[1];
if (IsJokerBoom(groupCards))
{
result.Add(groupCards);
}
}
//检索炸弹
for (int i = cards.Count - 1; i >= 3; i--)
{
IList <Card> groupCards = new Card[4];
groupCards[0] = cards[i - 3];
groupCards[1] = cards[i - 2];
groupCards[2] = cards[i - 1];
groupCards[3] = cards[i];
if (IsBoom(groupCards) && GetWeight(groupCards, CardsType.Boom) > weight)
{
result.Add(groupCards);
}
}
switch (type)
{
case CardsType.OnlyThree:
for (int i = cards.Count - 1; i >= 2; i--)
{
if (cards[i].CardWeight <= deskCards[deskCards.Count - 1].CardWeight)
{
continue;
}
IList <Card> groupCards = new Card[3];
groupCards[0] = cards[i - 2];
groupCards[1] = cards[i - 1];
groupCards[2] = cards[i];
if (IsOnlyThree(groupCards) && GetWeight(groupCards, type) > weight)
{
result.Add(groupCards);
}
}
break;
case CardsType.ThreeAndOne:
if (cards.Count >= 4)
{
for (int i = cards.Count - 1; i >= 2; i--)
{
if (cards[i].CardWeight <= deskCards[deskCards.Count - 1].CardWeight)
{
continue;
}
List <Card> other = new List <Card>(cards);
other.RemoveRange(i - 2, 3);
IList <Card> groupCards = new Card[4];
groupCards[0] = cards[i - 2];
groupCards[1] = cards[i - 1];
groupCards[2] = cards[i];
groupCards[3] = other[RandomHelper.RandomNumber(0, other.Count)];
if (IsThreeAndOne(groupCards) && GetWeight(groupCards, type) > weight)
{
result.Add(groupCards);
}
}
}
break;
case CardsType.ThreeAndTwo:
if (cards.Count >= 5)
{
for (int i = cards.Count - 1; i >= 2; i--)
{
if (cards[i].CardWeight <= deskCards[deskCards.Count - 1].CardWeight)
{
continue;
}
List <Card> other = new List <Card>(cards);
other.RemoveRange(i - 2, 3);
List <IList <Card> > otherDouble = await GetPrompt(other, deskCardsCache, CardsType.Double);
if (otherDouble.Count > 0)
{
IList <Card> randomDouble = otherDouble[RandomHelper.RandomNumber(0, otherDouble.Count)];
IList <Card> groupCards = new Card[5];
groupCards[0] = cards[i - 2];
groupCards[1] = cards[i - 1];
groupCards[2] = cards[i];
groupCards[3] = randomDouble[0];
groupCards[4] = randomDouble[1];
if (IsThreeAndTwo(groupCards) && GetWeight(groupCards, type) > weight)
{
result.Add(groupCards);
}
}
}
}
break;
case CardsType.Straight:
/*
* 7 6 5 4 3
* 8 7 6 5 4
*
* */
if (cards.Count >= deskCards.Count)
{
for (int i = cards.Count - 1; i >= deskCards.Count - 1; i--)
{
if (cards[i].CardWeight <= deskCards[deskCards.Count - 1].CardWeight)
{
continue;
}
//是否全部搜索完成
bool isTrue = true;
IList <Card> groupCards = new Card[deskCards.Count];
for (int j = 0; j < deskCards.Count; j++)
{
//搜索连续权重牌
Card findCard = cards.Where(card => (int)card.CardWeight == (int)cards[i].CardWeight + j).FirstOrDefault();
if (findCard == null)
{
isTrue = false;
break;
}
groupCards[deskCards.Count - 1 - j] = findCard;
}
if (isTrue && IsStraight(groupCards) && GetWeight(groupCards, type) > weight)
{
result.Add(groupCards);
}
}
}
break;
case CardsType.DoubleStraight:
/*
* 5 5 4 4 3 3
* 6 6 5 5 4 4
*
* */
if (cards.Count >= deskCards.Count)
{
for (int i = cards.Count - 1; i >= deskCards.Count - 1; i--)
{
if (cards[i].CardWeight <= deskCards[deskCards.Count - 1].CardWeight)
{
continue;
}
//是否全部搜索完成
bool isTrue = true;
IList <Card> groupCards = new Card[deskCards.Count];
for (int j = 0; j < deskCards.Count; j += 2)
{
//搜索连续权重牌
IList <Card> findCards = cards.Where(card => (int)card.CardWeight == (int)cards[i].CardWeight + (j / 2)).ToArray();
if (findCards.Count < 2)
{
isTrue = false;
break;
}
groupCards[deskCards.Count - 2 - j] = findCards[0];
groupCards[deskCards.Count - 1 - j] = findCards[1];
}
if (isTrue && IsDoubleStraight(groupCards) && GetWeight(groupCards, type) > weight)
{
result.Add(groupCards);
}
}
}
break;
case CardsType.TripleStraight:
if (cards.Count >= deskCards.Count)
{
for (int i = cards.Count - 1; i >= deskCards.Count - 1; i--)
{
if (cards[i].CardWeight <= deskCards[deskCards.Count - 1].CardWeight)
{
continue;
}
//是否全部搜索完成
bool isTrue = true;
IList <Card> groupCards = new Card[deskCards.Count];
for (int j = 0; j < deskCards.Count; j += 3)
{
//搜索连续权重牌
IList <Card> findCards = cards.Where(card => (int)card.CardWeight == (int)cards[i].CardWeight + (j / 3)).ToArray();
if (findCards.Count < 3)
{
isTrue = false;
break;
}
groupCards[deskCards.Count - 3 - j] = findCards[0];
groupCards[deskCards.Count - 2 - j] = findCards[1];
groupCards[deskCards.Count - 1 - j] = findCards[2];
}
if (isTrue && IsTripleStraight(groupCards) && GetWeight(groupCards, type) > weight)
{
result.Add(groupCards);
}
}
}
break;
case CardsType.Double:
if (cards.Count >= 2)
{
for (int i = cards.Count - 1; i >= 1; i--)
{
IList <Card> groupCards = new Card[2];
groupCards[0] = cards[i - 1];
groupCards[1] = cards[i];
if (IsDouble(groupCards) && GetWeight(groupCards, type) > weight)
{
result.Add(groupCards);
}
}
}
break;
case CardsType.Single:
if (cards.Count >= 1)
{
for (int i = cards.Count - 1; i >= 0; i--)
{
if (cards[i].CardWeight <= deskCards[deskCards.Count - 1].CardWeight)
{
continue;
}
IList <Card> groupCards = new Card[1];
groupCards[0] = cards[i];
if (IsSingle(groupCards) && GetWeight(groupCards, type) > weight)
{
result.Add(groupCards);
}
}
}
break;
default:
break;
}
return(result);
}
/// <summary>
/// 向牌库中添加牌
/// </summary>
/// <param name="card"></param>
public static void AddCard(this DeskCardsCacheComponent self, Card card)
{
self.library.Add(card);
}
protected override async Task Run(Room room, Actor_PlayerEnterRoom_Req message, Action <Actor_PlayerEnterRoom_Ack> reply)
{
Actor_PlayerEnterRoom_Ack response = new Actor_PlayerEnterRoom_Ack();
try
{
Gamer gamer = room.Get(message.UserID);
if (gamer == null)
{
//创建房间玩家对象
gamer = GamerFactory.Create(message.PlayerID, message.UserID);
await gamer.AddComponent <MailBoxComponent>().AddLocation();
gamer.AddComponent <UnitGateComponent, long>(message.SessionID);
//加入到房间
room.Add(gamer);
Actor_GamerEnterRoom_Ntt broadcastMessage = new Actor_GamerEnterRoom_Ntt();
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
{
//玩家重连
gamer.isOffline = false;
gamer.PlayerID = message.PlayerID;
gamer.GetComponent <UnitGateComponent>().GateSessionActorId = message.SessionID;
//玩家重连移除托管组件
gamer.RemoveComponent <TrusteeshipComponent>();
Actor_GamerEnterRoom_Ntt broadcastMessage = new Actor_GamerEnterRoom_Ntt();
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);
}
//发送房间玩家信息
ActorMessageSender actorProxy = gamer.GetComponent <UnitGateComponent>().GetActorMessageSender();
actorProxy.Send(broadcastMessage);
List <GamerCardNum> gamersCardNum = new List <GamerCardNum>();
List <GamerState> gamersState = new List <GamerState>();
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>();
gamersCardNum.Add(new GamerCardNum()
{
UserID = _gamer.UserID,
Num = _gamer.GetComponent <HandCardsComponent>().GetAll().Length
});
gamersState.Add(new GamerState()
{
UserID = _gamer.UserID,
Identity = (byte)handCards.AccessIdentity,
GrabLandlordState = orderController.GamerLandlordState.ContainsKey(_gamer.UserID)
? orderController.GamerLandlordState[_gamer.UserID]
: false
});
}
//发送游戏开始消息
Actor_GameStart_Ntt gameStartNotice = new Actor_GameStart_Ntt()
{
HandCards = gamer.GetComponent <HandCardsComponent>().GetAll(),
GamersCardNum = gamersCardNum
};
actorProxy.Send(gameStartNotice);
Card[] lordCards = null;
if (gamer.GetComponent <HandCardsComponent>().AccessIdentity == Identity.None)
{
//广播先手玩家
actorProxy.Send(new Actor_AuthorityGrabLandlord_Ntt()
{
UserID = orderController.CurrentAuthority
});
}
else
{
if (gamer.UserID == orderController.CurrentAuthority)
{
//发送可以出牌消息
bool isFirst = gamer.UserID == orderController.Biggest;
actorProxy.Send(new Actor_AuthorityPlayCard_Ntt()
{
UserID = orderController.CurrentAuthority, IsFirst = isFirst
});
}
lordCards = deskCardsCache.LordCards.ToArray();
}
//发送重连数据
Actor_GamerReconnect_Ntt reconnectNotice = new Actor_GamerReconnect_Ntt()
{
Multiples = room.GetComponent <GameControllerComponent>().Multiples,
GamersState = gamersState,
DeskCards = new KeyValuePair <long, Card[]>(orderController.Biggest, deskCardsCache.library.ToArray()),
LordCards = lordCards,
};
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);
}
