Fake Player

[mancioshell]

Hi,
thank you for this awesome projects. I was looking for something similar for a long time.

I have studied docs and i'm trying to realize an implementation of an italian card game (tresette). Tipically this game is played in 4 players divided in pairs. I have already completed the basic game, but there is a variation in 3 players, where there is also a fake player (the dead) which plays in pair (all the match) with one of the players.
The fake player moves, are made by this player.

Is there any best practice to create a turn order which permit the player in pairs with the dead to play 2 times in a round?

Constraints:

• The round is over when 4 card are on the table:
  endIf: (G, ctx) => G.table.length === 4

• Any player can play only one card and automatically end the turn.

• The dead plays between the other players pair.
  Example: Player1, Player2, The Dead, Player3. Player1 is in pair with The Dead.

• The winner of the round, will be the player which move first next round.

Actually in 4 players i have implemented this custom turn order:

order: { first: (G, ctx) => G.lastWinner ? G.lastWinner : (G.lastDealer + 1) % ctx.numPlayers, next: (G, ctx) => { return (ctx.playOrderPos + 1) % ctx.numPlayers; }, }

Thank you in advance.

[delucis]

Hi @mancioshell!

Would it work for you to have a 3-player turn order like this?

1 - 2 - 1 - 3

edit: Wait! My first answer won’t work 😅

Instead it’s probably easiest to use a custom play order:

order: {
  playOrder: (G, ctx) => ctx.numPlayers === 3 ? ['0', '1', '0', '2'] : ['0', '1', '2', '3'],
},

The tricky thing here is that with 4 players the teams are 0 + 2 and 1 + 3, but with 3 players the teams are 0 and 1 + 2.

[delucis]

Ahhh! Sorry, I misunderstood that bit. I have a feeling this should still be possible with a combination of the different turn.order options, but I’m not confident I fully understand all the rules, to be able to advise further.

[mancioshell]

Ahhh! Sorry, I misunderstood that bit. I have a feeling this should still be possible with a combination of the different turn.order options, but I’m not confident I fully understand all the rules, to be able to advise further.

Ok. I'll try to summirize the basic rules (for 4 players);

A game is composed of a series of match. The game is played with a deck of 40 cards.
Every match the 4 players (divided in 2 teams) have 10 cards to play.
A match is composed of 10 rounds. Every round the players in turn play 1 and only 1 card. The round is over when all the players have played 1 card.
The first player of a round is the winner of the last round (Except for the first round, where the first player is the first player next the dealer).
A match ends when all the players have played all the cards.
At the end of the match, every team compute its own score (the score in this particular match plus the sum of the scores from previous matches). If the score of one of the teams exceeds a particular threshold, the game is over and the team which exceeds the treshold win the game. Otherwise new match starts with a new dealer (the next player of the last dealer).

Game with 3 players have the same rules, except one of the players (the dealer) play a match with a fake player (the dead). The dead's deck is face up (every player can see the cards of the dead). Dead's round is played by the the dealer. Every match the teammate of the dead change.

I hope I was as clear as possible, if not let me know.
Thank you in advance!

[mancioshell]

@delucis Maybe i have founded a solution, but this involves to alter G state inside next function. But i think is not possible because i receive this error in the console:

ERROR: TypeError: Cannot assign to read only property 'playedTurn' of object '#<Object>'

[cwatsonc]

@mancioshell I have a card game and found it easier to model stages within a "turn" -- the key is who is dealer in that round. From dealer you can infer first lead -- from trick captured you can infer next lead. Stages are perfect for this as they are more flexible than turns and static turn orders you might dynamically concoct. In English card games matches are "hands" and plays are "tricks". For any hand the left of dealer is the first to lead; subsequent tricks in the hand are led by the winner of the last trick.

phase 1 - pregame -- stuff you do before the first deal (e.g. select dealer by drawing cards)
phase 2 - thePlay

turn 1. (dealer one)
stage A - deal cards
stage B - bids
stage C - tricks
stage D - Score
turn 2. (dealer two)
repeat stages...

Phase 3: endgame

Model this without a UI to get the state changes working as expected -- use the debugger to fire specific events -- once done UI is easy to develop around a specific state model.

[cwatsonc]

also take a look at Freeboardgames.org where card games are well supported and developed on bgio. In particular the card faces described in tresette can be found in other contributions there. Several implementations of "trick taking games" are modeled there for your discovery.