public bool IsValidMove(CoreDurakGame core, GameMove move, ref string reason)
{
if (core.GameState.GetValueListInt(Names.WINNING_PLAYERS).Contains(move.Player.ID))
{
reason = "You have already won!";
return(false);
}
else if (move.Move == null)
{
return(true);
}
else if (core.GameState.GetValueListInt(Names.THROWES_WITHOUT_CARDS).Contains(move.Player.ID))
{
reason = "You haven`t cards, wait for the next round";
return(false);
}
else if (!move.Player.Hand.Contains(move.Move))
{
reason = "Card is not in players hand";
return(false);
}
else
{
return(true);
}
}
public bool ShouldInvoke(CoreDurakGame core, Player player)
{
var playerId = player.ID;
if (core.GameState.GetValueBool(Names.IS_GAME_OVER) &&
core.GameState.GetValueListInt(Names.WINNING_PLAYERS).Contains(playerId))
{
return(false);
}
var defendingID = core.GameState.GetValueInt(Names.DEFENDING_PLAYER);
var currentRoundDefending = core.GameState.GetValueInt(Names.CURRENT_ROUND_DEFENDING);
var attackingCard = core.GameState.GetValueCard(Names.ATTACKING_CARD, currentRoundDefending);
if (playerId != defendingID)
{
return(true);
}
else if (attackingCard != null)
{
return(true);
}
else
{
return(false);
}
}
public void InitState(CoreDurakGame core)
{
var players = core.ConnectedServer.Players;
var attackingID = Utils.FindIDWithLeastTrump(players, core.GameState.GetValueCard(Names.TRUMP_CARD).Suit);
var defendingID = Utils.FindIDAttackingOrDefending(players, core.ConnectedServer.SupportedPlayerCount, attackingID + 1);
var forfeitingPlayers = new Dictionary <int, bool>();
core.ConnectedServer.Players.Values
.Select(p => p.ID)
.Where(i => i != defendingID)
.ToList()
.ForEach(i => forfeitingPlayers.Add(i, false));
core.GameState.Set(Names.IS_ATTACKING, true);
core.GameState.Set(Names.DEFENDER_FORFEIT, false);
core.GameState.Set(Names.AMOUNT_CARD_DEFENDER, 6);
core.GameState.Set(Names.CARDS_CAN_THROWN, 6);
core.GameState.Set(Names.DEFENDER_TIMER_FINISHED, false);
core.GameState.Set(Names.ATTACKING_PLAYER, attackingID);
core.GameState.Set(Names.DEFENDING_PLAYER, defendingID);
core.GameState.Set(Names.THROWING_PLAYERS, forfeitingPlayers);
core.GameState.Set(Names.THROWES_WITHOUT_CARDS, new List <int>());
core.GameState.Set(Names.WINNING_PLAYERS, new List <int>());
core.GameState.Set(Names.DISCARD, new CardCollection());
core.GameState.Set(Names.TEMP_DISCARD, new CardCollection());
for (int index = 0; index < 6; index++)
{
core.GameState.Set <Card>(Names.DEFENDING_CARD, index, null);
core.GameState.Set <Card>(Names.ATTACKING_CARD, index, null);
}
}
public void ValidateState(CoreDurakGame core)
{
var throwingRound = core.GameState.GetValueInt(Names.CURRENT_ROUND_THROWING);
var defendingRound = core.GameState.GetValueInt(Names.CURRENT_ROUND_DEFENDING);
if (!core.GameState.GetValueBool(Names.DEFENDER_FORFEIT) && throwingRound - defendingRound == 0 &&
core.GameState.GetValueDictIntBool(Names.THROWING_PLAYERS).All(p => p.Value == true))
{
var discard = core.GameState.GetValueCardCollection(Names.DISCARD);
var tempDiscard = core.GameState.GetValueCardCollection(Names.TEMP_DISCARD);
for (int index = 0; index < throwingRound; index++)
{
if (core.GameState.GetValueCard(Names.ATTACKING_CARD, index) != null)
{
discard.Add(core.GameState.GetValueCard(Names.ATTACKING_CARD, index));
}
if (core.GameState.GetValueCard(Names.DEFENDING_CARD, index) != null)
{
discard.Add(core.GameState.GetValueCard(Names.DEFENDING_CARD, index));
}
core.GameState.Set <Card>(Names.ATTACKING_CARD, index, null);
core.GameState.Set <Card>(Names.DEFENDING_CARD, index, null);
}
discard.Concat(tempDiscard);
core.GameState.Set(Names.TEMP_DISCARD, new CardCollection());
core.GameState.Set(Names.DISCARD, discard);
Utils.MoveNextDuel(core);
}
}
public void TrySetState(StateParameter parameter, CoreDurakGame core, Player sender)
{
if (parameter.Name == Names.AMOUNT_INIT_CARDS && parameter.ParameterType == StateParameter.Type.Int && sender.IsHost)
{
core.GameState.Set(Names.AMOUNT_INIT_CARDS, parameter.GetValueInt(), true);
}
}
public bool IsValidMove(CoreDurakGame core, GameMove move, ref string reason)
{
var throwingPlayers = core.GameState.GetValueDictIntBool(Names.THROWING_PLAYERS);
if (throwingPlayers.Keys.Contains(move.Player.ID) &&
!core.GameState.GetValueBool(Names.IS_ATTACKING))
{
if (throwingPlayers[move.Player.ID])
{
reason = "You already clicked FORFEIT";
return(false);
}
if (move.Move == null)
{
return(true);
}
var throwingRound = core.GameState.GetValueInt(Names.CURRENT_ROUND_THROWING);
var cardsCanThrown = core.GameState.GetValueInt(Names.CARDS_CAN_THROWN);
var tempDiscard = core.GameState.GetValueCardCollection(Names.TEMP_DISCARD);
if (cardsCanThrown <= 0)
{
reason = "The player does not have enough cards to beat off more";
return(false);
}
for (int index = 0; index < throwingRound; index++)
{
if (move.Move.Value == core.GameState.GetValueCard(Names.ATTACKING_CARD, index)?.Value ||
move.Move.Value == core.GameState.GetValueCard(Names.DEFENDING_CARD, index)?.Value)
{
return(true);
}
}
foreach (var card in tempDiscard)
{
if (move.Move.Value == card.Value)
{
return(true);
}
}
reason = "You must play a card with a rank that has already been played";
return(false);
}
else
{
return(true);
}
}
private void CreateConnectedServer(CoreDurakGame core)
{
core.ConnectedServer = new ServerTag(
Properties.Settings.Default.DefaultServerName,
Properties.Settings.Default.DefaultServerDescription,
Properties.Settings.Default.DefaultServerPassword,
Properties.Settings.Default.DefaultMaxPlayers)
{
IPAddress = NetUtils.GetAddress(),
Port = gameServer.Port,
State = ServerState.InLobby,
};
}
public bool IsValidMove(CoreDurakGame core, GameMove move, ref string reason)
{
if (move.Move == null)
{
return(true);
}
if (core.GameState.GetValueInt(Names.DEFENDING_PLAYER) == move.Player.ID)
{
var throwingRound = core.GameState.GetValueInt(Names.CURRENT_ROUND_THROWING);
var defendingRound = core.GameState.GetValueInt(Names.CURRENT_ROUND_DEFENDING);
var attackingCard = core.GameState.GetValueCard(Names.ATTACKING_CARD, defendingRound);
var trumpSuit = core.GameState.GetValueCard(Names.TRUMP_CARD).Suit;
if (throwingRound - defendingRound <= 0)
{
reason = "This is not your turn";
return(false);
}
else if (core.GameState.GetValueBool(Names.DEFENDER_FORFEIT))
{
reason = "You already clicked FORFEIT";
return(false);
}
else if (move.Move.Value > attackingCard.Value)
{
if (move.Move.Suit == attackingCard.Suit || move.Move.Suit == trumpSuit)
{
return(true);
}
else
{
reason = "You must play a card of a higher rank of the same suit, or a trump card";
return(false);
}
}
else if (move.Move.Suit == trumpSuit && attackingCard.Suit != trumpSuit)
{
return(true);
}
else
{
reason = "You must play a card of a higher rank";
return(false);
}
}
else
{
return(true);
}
}
public bool IsValidMove(CoreDurakGame core, GameMove move, ref string reason)
{
if (core.GameState.GetValueInt(Names.DEFENDING_PLAYER) == move.Player.ID)
{
return(true);
}
var throwingRound = core.GameState.GetValueInt(Names.CURRENT_ROUND_THROWING);
var defendingRound = core.GameState.GetValueInt(Names.CURRENT_ROUND_DEFENDING);
if (throwingRound % 6 != 0)
{
return(true);
}
else if (throwingRound - defendingRound == 0 || core.GameState.GetValueBool(Names.DEFENDER_FORFEIT))
{
var tempDiscard = core.GameState.GetValueCardCollection(Names.TEMP_DISCARD);
for (var index = 0; index < throwingRound; index++)
{
var attackingCard = core.GameState.GetValueCard(Names.ATTACKING_CARD, index);
if (attackingCard != null)
{
tempDiscard.Add(core.GameState.GetValueCard(Names.ATTACKING_CARD, index));
}
var defendingCard = core.GameState.GetValueCard(Names.DEFENDING_CARD, index);
if (defendingCard != null)
{
tempDiscard.Add(core.GameState.GetValueCard(Names.DEFENDING_CARD, index));
}
core.GameState.Set <Card>(Names.ATTACKING_CARD, index, null);
core.GameState.Set <Card>(Names.DEFENDING_CARD, index, null);
}
core.GameState.Set(Names.TEMP_DISCARD, tempDiscard);
core.GameState.Set(Names.CURRENT_ROUND_THROWING, 0);
core.GameState.Set(Names.CURRENT_ROUND_DEFENDING, 0);
return(true);
}
reason = "Wait until the player fight off the remaining cards and clears the table";
return(false);
}
public bool IsValidMove(CoreDurakGame core, GameMove move, ref string reason)
{
if (move.Player.ID == core.GameState.GetValueInt(Names.ATTACKING_PLAYER))
{
return(true);
}
else if (core.GameState.GetValueDictIntBool(Names.THROWING_PLAYERS).Keys.Contains(move.Player.ID) &&
!core.GameState.GetValueBool(Names.IS_ATTACKING))
{
return(true);
}
else if (move.Player.ID == core.GameState.GetValueInt(Names.DEFENDING_PLAYER))
{
return(true);
}
reason = "It is not your turn to " + (core.GameState.GetValueBool(Names.IS_ATTACKING) ? "attack." : "defend.");
return(false);
}
public void InitState(CoreDurakGame core)
{
Deck deck;
var numInitCards = core.GameState.GetValueInt(Names.AMOUNT_INIT_CARDS);
if (numInitCards == 20)
{
deck = new Deck(CardValue.Ten, CardValue.Ace);
}
else if (numInitCards == 52)
{
deck = new Deck(CardValue.Two, CardValue.Ace);
}
else
{
deck = new Deck(CardValue.Six, CardValue.Ace);
}
core.GameState.Set(Names.TRUMP_CARD, deck.Draw());
foreach (var player in core.ConnectedServer.Players.Values)
{
for (var i = 0; i < 6; i++)
{
if (deck.Cards.Count > 0)
{
player.Hand.Add(deck.Draw());
}
else if (!core.GameState.GetValueBool(Names.TRUMP_CARD_USED))
{
player.Hand.Add(core.GameState.GetValueCard(Names.TRUMP_CARD));
core.GameState.Set(Names.TRUMP_CARD_USED, true);
}
}
}
core.GameState.Set(Names.DECK, deck.Cards);
core.GameState.Set(Names.DECK_COUNT, deck.Cards.Count);
}
public void ValidateState(CoreDurakGame core)
{
if (core.GameState.GetValueBool(Names.DEFENDER_FORFEIT) &&
(core.GameState.GetValueBool(Names.DEFENDER_TIMER_FINISHED) ||
core.GameState.GetValueDictIntBool(Names.THROWING_PLAYERS).All(p => p.Value == true)))
{
var round = core.GameState.GetValueInt(Names.CURRENT_ROUND_THROWING);
var defender = core.ConnectedServer.Players[core.GameState.GetValueInt(Names.DEFENDING_PLAYER)];
var tempDiscard = core.GameState.GetValueCardCollection(Names.TEMP_DISCARD);
for (int index = 0; index < round; index++)
{
var attackingCard = core.GameState.GetValueCard(Names.ATTACKING_CARD, index);
if (attackingCard != null)
{
defender.Hand.Add(attackingCard);
}
var defendingCard = core.GameState.GetValueCard(Names.DEFENDING_CARD, index);
if (defendingCard != null)
{
defender.Hand.Add(defendingCard);
}
core.GameState.Set <Card>(Names.ATTACKING_CARD, index, null);
core.GameState.Set <Card>(Names.DEFENDING_CARD, index, null);
}
foreach (var card in tempDiscard)
{
defender.Hand.Add(card);
}
tempDiscard.Clear();
core.GameState.Set(Names.TEMP_DISCARD, tempDiscard);
Utils.MoveNextDuel(core);
}
}
public void ValidateState(CoreDurakGame core)
{
if (core.GameState.GetValueBool(Names.DEFENDER_HAVE_NOT_CARDS))
{
var round = core.GameState.GetValueInt(Names.CURRENT_ROUND_THROWING);
var discard = core.GameState.GetValueCardCollection(Names.DISCARD);
var tempDiscard = core.GameState.GetValueCardCollection(Names.TEMP_DISCARD);
for (int index = 0; index < round; index++)
{
var attackingCard = core.GameState.GetValueCard(Names.ATTACKING_CARD, index);
if (attackingCard != null)
{
discard.Add(core.GameState.GetValueCard(Names.ATTACKING_CARD, index));
}
var defendingCard = core.GameState.GetValueCard(Names.DEFENDING_CARD, index);
if (defendingCard != null)
{
discard.Add(core.GameState.GetValueCard(Names.DEFENDING_CARD, index));
}
core.GameState.Set <Card>(Names.ATTACKING_CARD, index, null);
core.GameState.Set <Card>(Names.DEFENDING_CARD, index, null);
}
if (tempDiscard != null)
{
discard.Concat(tempDiscard);
}
tempDiscard.Clear();
core.GameState.Set(Names.TEMP_DISCARD, tempDiscard);
core.GameState.Set(Names.DISCARD, discard);
Utils.MoveNextDuel(core);
}
}
public bool IsValidMove(CoreDurakGame core, GameMove move, ref string reason)
{
if (core.GameState.GetValueBool(Names.IS_ATTACKING))
{
if (move.Move == null && move.Player.ID == core.GameState.GetValueInt(Names.ATTACKING_PLAYER))
{
reason = "Attacker cannot forfeit!";
return(false);
}
if (move.Move == null)
{
reason = "Now is the attacker's turn!";
return(false);
}
else
{
return(true);
}
}
else
{
return(true);
}
}
private async void CardTakingCounter(CoreDurakGame core)
{
TaskScheduler sync;
if (core.IsSinglePlayerMode)
{
sync = TaskScheduler.FromCurrentSynchronizationContext();
}
else
{
sync = TaskScheduler.Default;
}
await Task.Factory.StartNew(() =>
{
for (int i = 0; i < 100; i++)
{
if (!core.GameState.GetValueBool(Names.DEFENDER_FORFEIT))
{
return(false);
}
Thread.Sleep(100);
}
return(true);
})
.ContinueWith(antecedent =>
{
if (antecedent.Result)
{
PlayerServer.Mutex?.WaitOne();
core.GameState.Set(Names.DEFENDER_TIMER_FINISHED, true);
core.CheckStateRules();
PlayerServer.Mutex?.ReleaseMutex();
}
}, sync);
}
public void Propose(Dictionary <Card, float> proposals, CoreDurakGame core, Player botplayer)
{
var state = core.GameState;
var trumpSuit = state.GetValueCard(Names.TRUMP_CARD).Suit;
Card[] keys = proposals.Keys.ToArray();
if (botplayer.ID != core.GameState.GetValueInt(Names.DEFENDING_PLAYER))
{
foreach (var key in keys)
{
if (key.Suit != trumpSuit)
{
proposals[key] += .25f;
}
if (state.GetValueBool(Names.IS_ATTACKING))
{
proposals[key] += .25f - (key.CardValue / 100.0f);
}
if (state.GetValueInt(Names.CURRENT_ROUND_THROWING) != 0)
{
for (int i = 0; i >= state.GetValueInt(Names.CURRENT_ROUND_THROWING); i++)
{
if (state.GetValueCard(Names.ATTACKING_CARD, i).Value != key.Value ||
state.GetValueCard(Names.DEFENDING_CARD, i).Value != key.Value ||
key.Suit == trumpSuit)
{
proposals[key] = 0.0f;
}
}
}
}
}
else
{
var attackingCard = state.GetValueCard(Names.ATTACKING_CARD, state.GetValueInt(Names.CURRENT_ROUND_DEFENDING));
foreach (Card key in keys)
{
if (key.Suit == trumpSuit | key.Suit == attackingCard.Suit)
{
proposals[key] += .25f;
if (key.Suit != trumpSuit)
{
proposals[key] += .25f;
}
if (key.Value > attackingCard.Value)
{
proposals[key] += .25f - (key.CardValue / 100.0f);
}
else if (key.Value < attackingCard.Value && key.Suit == attackingCard.Suit)
{
proposals[key] = 0.0f;
}
}
}
}
}
public static void MoveNextDuel(CoreDurakGame core)
{
var state = core.GameState;
var players = core.ConnectedServer.Players;
if (!state.GetValueBool(Names.IS_GAME_OVER))
{
var forfeitingPlayers = core.GameState.GetValueDictIntBool(Names.THROWING_PLAYERS);
var winningPlayers = core.GameState.GetValueListInt(Names.WINNING_PLAYERS);
var deck = new Deck(state.GetValueCardCollection(Names.DECK));
DealCards(state, players, winningPlayers, deck);
var activePlayers = players.Values.Where(X => X.Hand.Count > 0).Count();
var isDefenderForfeit = state.GetValueBool(Names.DEFENDER_FORFEIT);
if (activePlayers > 1)
{
state.Set(Names.IS_ATTACKING, true);
state.Set(Names.DEFENDER_FORFEIT, false);
state.Set(Names.DEFENDER_HAVE_NOT_CARDS, false);
state.Set(Names.DEFENDER_TIMER_FINISHED, false);
state.Set(Names.CURRENT_ROUND_THROWING, 0);
state.Set(Names.CURRENT_ROUND_DEFENDING, 0);
state.Set(Names.THROWING_PLAYERS, forfeitingPlayers);
state.Set(Names.WINNING_PLAYERS, winningPlayers);
state.Set(Names.THROWES_WITHOUT_CARDS, new List <int>());
var supportedPlayerCount = core.ConnectedServer.SupportedPlayerCount;
var tempDefendingID = state.GetValueInt(Names.DEFENDING_PLAYER);
var attackingID = FindIDAttackingOrDefending(players, supportedPlayerCount, isDefenderForfeit ? tempDefendingID + 1 : tempDefendingID);
var defendingID = FindIDAttackingOrDefending(players, supportedPlayerCount, attackingID + 1);
forfeitingPlayers.Clear();
players.Values.Select(p => p.ID)
.Except(state.GetValueListInt(Names.WINNING_PLAYERS))
.Where(i => i != defendingID)
.ToList()
.ForEach(i => forfeitingPlayers.Add(i, false));
state.Set(Names.DECK, deck.Cards);
state.Set(Names.ATTACKING_PLAYER, attackingID);
state.Set(Names.DEFENDING_PLAYER, defendingID);
state.Set(Names.AMOUNT_CARD_DEFENDER, core.ConnectedServer.Players[defendingID].Hand.Count);
state.Set(Names.CARDS_CAN_THROWN, core.ConnectedServer.Players[defendingID].Hand.Count);
state.Set(Names.DECK_COUNT, deck.Cards.Count);
state.Set(Names.THROWING_PLAYERS, forfeitingPlayers);
}
else
{
if (activePlayers == 1)
{
state.Set(Names.LOSER_ID, players.Values.First(X => X.Hand.Count > 0).ID);
state.Set(Names.IS_TIE, false);
state.Set(Names.IS_GAME_OVER, true);
}
else if (activePlayers == 0)
{
state.Set(Names.IS_TIE, true);
state.Set(Names.IS_GAME_OVER, true);
}
}
}
}
public void UpdateState(CoreDurakGame core, GameMove move)
{
if (move.Move != null)
{
move.Player.Hand.Remove(move.Move);
}
else
{
core.GameState.Set(Names.PLAYER_FORFEIT, move.Player.ID);
}
var throwingRound = core.GameState.GetValueInt(Names.CURRENT_ROUND_THROWING);
var defendingID = core.GameState.GetValueInt(Names.DEFENDING_PLAYER);
var forfeitingPlayers = core.GameState.GetValueDictIntBool(Names.THROWING_PLAYERS);
var throwesWithoutCards = core.GameState.GetValueListInt(Names.THROWES_WITHOUT_CARDS);
var cardsCanThrown = core.GameState.GetValueInt(Names.CARDS_CAN_THROWN);
if (core.GameState.GetValueBool(Names.IS_ATTACKING))
{
core.GameState.Set(Names.IS_ATTACKING, false);
core.GameState.Set(Names.ATTACKING_CARD, throwingRound, move.Move);
core.GameState.Set(Names.CURRENT_ROUND_THROWING, ++throwingRound);
core.GameState.Set(Names.CARDS_CAN_THROWN, --cardsCanThrown);
}
else if (move.Player.ID != defendingID)
{
if (move.Move == null)
{
forfeitingPlayers[move.Player.ID] = true;
}
else if (move.Move != null && !forfeitingPlayers[move.Player.ID])
{
forfeitingPlayers.Keys.ToList().ForEach(v => forfeitingPlayers[v] = false);
core.GameState.Set(Names.ATTACKING_CARD, throwingRound, move.Move);
core.GameState.Set(Names.CURRENT_ROUND_THROWING, ++throwingRound);
core.GameState.Set(Names.CARDS_CAN_THROWN, --cardsCanThrown);
}
core.GameState.Set(Names.THROWING_PLAYERS, forfeitingPlayers);
}
if (move.Player.ID == defendingID)
{
var defenderForfeit = core.GameState.GetValueBool(Names.DEFENDER_FORFEIT);
var defendingRound = core.GameState.GetValueInt(Names.CURRENT_ROUND_DEFENDING);
if (move.Player.Hand.Count == 0)
{
core.GameState.Set(Names.DEFENDER_HAVE_NOT_CARDS, true);
}
else if (move.Move == null && !defenderForfeit)
{
core.GameState.Set(Names.DEFENDER_FORFEIT, true);
CardTakingCounter(core);
return;
}
else if (move.Move != null && !defenderForfeit)
{
if (throwesWithoutCards != null && throwesWithoutCards.Count != 0)
{
forfeitingPlayers.Keys.Except(throwesWithoutCards).ToList().ForEach(v => forfeitingPlayers[v] = false);
}
else
{
forfeitingPlayers.Keys.ToList().ForEach(v => forfeitingPlayers[v] = false);
}
core.GameState.Set(Names.THROWING_PLAYERS, forfeitingPlayers);
core.GameState.Set(Names.REMOVE_ALL_FORFEITS, true);
core.GameState.Set(Names.DEFENDING_CARD, defendingRound, move.Move);
core.GameState.Set(Names.CURRENT_ROUND_DEFENDING, ++defendingRound);
core.GameState.Set(Names.AMOUNT_CARD_DEFENDER, move.Player.Hand.Count);
}
}
if (move.Player.Hand.Count == 0 && move.Player.ID != defendingID)
{
throwesWithoutCards.Add(move.Player.ID);
core.GameState.Set(Names.THROWES_WITHOUT_CARDS, throwesWithoutCards);
forfeitingPlayers[move.Player.ID] = true;
core.GameState.Set(Names.THROWING_PLAYERS, forfeitingPlayers);
}
}
public void SetClient(CoreDurakGame coreGame)
{
core = coreGame;
AddEvents();
foreach (var player in core.ConnectedServer.Players.Values)
{
if (player != null && player.ID != core.Player.ID)
{
var id = player.ID == 0 ? core.Player.ID : player.ID;
var tag = new PlayerUITag();
switch (id)
{
case 1:
tag.Panel = pnlPlayer1;
tag.Name = lblPlayer1;
tag.Name.Text = player.Name;
tag.PlayerID = lblIDPlayer1;
tag.PlayerID.Text = player.ID.ToString();
tag.CardCount = lblCardsLeftPlayer1;
tag.CardCount.Text = player.Hand.Count.ToString();
tag.Card = pbxPlayer1;
tag.Kick = btnKickPlayer1;
tag.BotGame = pbxBotGamePlayer1;
tag.Digress = pbxDigressedPlayer1;
tag.Leave = pbxLeavedPlayer1;
tag.Win = lblWinPlayer1;
tag.MutedPlayer = pbxMutedPlayer1;
tag.RadioButton = rbnPlayer1;
break;
#region DRY case 2-5
case 2:
tag.Panel = pnlPlayer2;
tag.Name = lblPlayer2;
tag.Name.Text = player.Name;
tag.PlayerID = lblIDPlayer2;
tag.PlayerID.Text = player.ID.ToString();
tag.CardCount = lblCardsLeftPlayer2;
tag.CardCount.Text = player.Hand.Count.ToString();
tag.Card = pbxPlayer2;
tag.Kick = btnKickPlayer2;
tag.BotGame = pbxBotGamePlayer2;
tag.Digress = pbxDigressedPlayer2;
tag.Leave = pbxLeavedPlayer2;
tag.Win = lblWinPlayer2;
tag.MutedPlayer = pbxMutedPlayer2;
tag.RadioButton = rbnPlayer2;
break;
case 3:
tag.Panel = pnlPlayer3;
tag.Name = lblPlayer3;
tag.Name.Text = player.Name;
tag.PlayerID = lblIDPlayer3;
tag.PlayerID.Text = player.ID.ToString();
tag.CardCount = lblCardsLeftPlayer3;
tag.CardCount.Text = player.Hand.Count.ToString();
tag.Card = pbxPlayer3;
tag.Kick = btnKickPlayer3;
tag.BotGame = pbxBotGamePlayer3;
tag.Digress = pbxDigressedPlayer3;
tag.Leave = pbxLeavedPlayer3;
tag.Win = lblWinPlayer3;
tag.MutedPlayer = pbxMutedPlayer3;
tag.RadioButton = rbnPlayer3;
break;
case 4:
tag.Panel = pnlPlayer4;
tag.Name = lblPlayer4;
tag.Name.Text = player.Name;
tag.PlayerID = lblIDPlayer4;
tag.PlayerID.Text = player.ID.ToString();
tag.CardCount = lblCardsLeftPlayer4;
tag.CardCount.Text = player.Hand.Count.ToString();
tag.Card = pbxPlayer4;
tag.Kick = btnKickPlayer4;
tag.BotGame = pbxBotGamePlayer4;
tag.Digress = pbxDigressedPlayer4;
tag.Leave = pbxLeavedPlayer4;
tag.Win = lblWinPlayer4;
tag.MutedPlayer = pbxMutedPlayer4;
tag.RadioButton = rbnPlayer4;
break;
case 5:
tag.Panel = pnlPlayer5;
tag.Name = lblPlayer5;
tag.Name.Text = player.Name;
tag.PlayerID = lblIDPlayer5;
tag.PlayerID.Text = player.ID.ToString();
tag.CardCount = lblCardsLeftPlayer5;
tag.CardCount.Text = player.Hand.Count.ToString();
tag.Card = pbxPlayer5;
tag.Kick = btnKickPlayer5;
tag.BotGame = pbxBotGamePlayer5;
tag.Digress = pbxDigressedPlayer5;
tag.Leave = pbxLeavedPlayer5;
tag.Win = lblWinPlayer5;
tag.MutedPlayer = pbxMutedPlayer5;
tag.RadioButton = rbnPlayer5;
break;
#endregion
}
playerUIs.Add(player, tag);
tag.Panel.Visible = true;
}
}
var myTag = new PlayerUITag()
{
PlayerID = lblIDPlayer,
Panel = pnlMyView,
SwordShieldDagger = pbxSwordShieldDagger,
BotGame = pbxBotGame,
Digress = pbxDigressed,
Win = lblWinPlayer
};
myTag.PlayerID.Text = core.Player.ID.ToString();
playerUIs.Add(core.Player, myTag);
cplPlayersHand.Player = core.Player;
cplPlayersHand.UpdatePlayer();
DetermineKickButtons();
core.ConnectedServer.Players
.Where(p => p.Value.IsBot && p.Value.IsDigress)
.ToList()
?.ForEach(p => PlayerDigressed(p.Key, p.Value.IsBot, p.Value.IsDigress));
}
