We're working on improving the political poker game experience. In the meantime, check out our other poker resources and games!
🌍 Political Poker Table
Round: Pre-Flop
Pot: $0
Current Turn: You
Community Cards
🂠
🂠
🂠
🂠
🂠
$0
Main Pot
🂠
🂠
👤
YOU
$1000
$0
Your turn
🂠
🂠
🇻🇪
Maduro
$1000
$0
Waiting
🂠
🂠
🇷🇺
Putin
$1000
$0
Waiting
🂠
🂠
🇺🇸
Trump
$1000
$0
Waiting
🂠
🂠
🇨🇳
Xi
$1000
$0
Waiting
🂠
🂠
🇰🇵
Kim
$1000
$0
Waiting
📋 Game Action
Welcome to Political Poker! Click "New Hand" to begin the international showdown.
🎉 You Won!
You took down the pot worth $0!
Total Won: $0
Hands Played: 0
-->
🎯 Political Poker Rules
Standard Texas Hold'em
Play follows regular poker rules, but each leader has unique personality and playing style.
Funny Consequences
When leaders lose, they react in character with hilarious animations and quotes.
Strategic Depth
Each opponent plays differently - adapt your strategy to counter their style!
Share Victories
Share your wins against world leaders on social media for maximum laughs.
📤 Share Your Political Poker Victories
Beat a world leader? Share the hilarious moment!
class PoliticalPokerTable {
constructor() {
this.players = [
{ id: 'human', name: 'You', cards: [], stack: 1000, bet: 0, folded: false, position: 0 },
{ id: 'maduro', name: 'Maduro', cards: [], stack: 1000, bet: 0, folded: false, position: 1 },
{ id: 'putin', name: 'Putin', cards: [], stack: 1000, bet: 0, folded: false, position: 2 },
{ id: 'trump', name: 'Trump', cards: [], stack: 1000, bet: 0, folded: false, position: 3 },
{ id: 'xi', name: 'Xi', cards: [], stack: 1000, bet: 0, folded: false, position: 4 },
{ id: 'kim', name: 'Kim', cards: [], stack: 1000, bet: 0, folded: false, position: 5 }
];
this.communityCards = [];
this.pot = 0;
this.currentPlayerIndex = 0;
this.dealerPosition = 5; // Kim is dealer initially
this.smallBlind = 5;
this.bigBlind = 10;
this.currentBet = 0;
this.gamePhase = 'waiting'; // waiting, preflop, flop, turn, river, showdown
this.roundBets = 0;
this.lastRaisePlayer = -1;
this.totalWon = 0;
this.handsPlayed = 0;
this.leaders = this.initializeLeaders();
this.initializeUI();
}
initializeLeaders() {
return {
maduro: {
name: 'Nicolas Maduro',
avatar: '🇻🇪',
playingStyle: 'dramatic',
quotes: [
"This is imperialist sabotage!",
"The bourgeoisie fears my poker skills!",
"Socialism will triumph at this table!",
"Comrades, this is unfair aggression!"
],
losingAnimation: 'maduro-losing',
losingQuote: "The imperialists have cheated me!"
},
putin: {
name: 'Vladimir Putin',
avatar: '🇷🇺',
playingStyle: 'strategic',
quotes: [
"In chess and poker, one must think ahead.",
"Patience is the key to victory.",
"This requires careful calculation.",
"Strategic thinking always prevails."
],
losingAnimation: 'putin-losing',
losingQuote: "Even masters sometimes lose battles."
},
trump: {
name: 'Donald Trump',
avatar: '🇺🇸',
playingStyle: 'aggressive',
quotes: [
"This game is huge! Tremendous!",
"Nobody makes better poker plays than me!",
"FAKE NEWS! This hand is rigged!",
"We're going to win so much!"
],
losingAnimation: 'trump-losing',
losingQuote: "This is a witch hunt! Totally unfair!"
},
xi: {
name: 'Xi Jinping',
avatar: '🇨🇳',
playingStyle: 'patient',
quotes: [
"Through persistent struggle, victory comes.",
"Long-term strategy is essential.",
"Patience brings its own rewards.",
"The dragon never rushes."
],
losingAnimation: 'xi-losing',
losingQuote: "Even great journeys have setbacks."
},
kim: {
name: 'Kim Jong-un',
avatar: '🇰🇵',
playingStyle: 'unpredictable',
quotes: [
"This calls for a demonstration!",
"Our capabilities are unmatched!",
"Strategic surprise is our weapon!",
"Maximum pressure tactics!"
],
losingAnimation: 'kim-losing',
losingQuote: "This requires a stronger response!"
}
};
}
initializeUI() {
this.updateAllStacks();
this.updateGameInfo();
}
postBlinds() {
const smallBlindPos = (this.dealerPosition + 1) % 6;
const bigBlindPos = (this.dealerPosition + 2) % 6;
// Small blind
this.placeBet(smallBlindPos, this.smallBlind);
this.players[smallBlindPos].stack -= this.smallBlind;
this.players[smallBlindPos].bet = this.smallBlind;
this.addLogEntry(`${this.players[smallBlindPos].name} posts small blind $${this.smallBlind}`);
// Big blind
this.placeBet(bigBlindPos, this.bigBlind);
this.players[bigBlindPos].stack -= this.bigBlind;
this.players[bigBlindPos].bet = this.bigBlind;
this.addLogEntry(`${this.players[bigBlindPos].name} posts big blind $${this.bigBlind}`);
this.currentBet = this.bigBlind;
this.updateAllStacks();
}
dealHoleCards() {
const deck = this.createDeck();
this.shuffleDeck(deck);
// Deal 2 cards to each player
for (let cardIndex = 0; cardIndex < 2; cardIndex++) {
for (let playerIndex = 0; playerIndex < 6; playerIndex++) {
const card = deck.pop();
this.players[playerIndex].cards.push(card);
// Update UI for human player immediately
if (playerIndex === 0) {
setTimeout(() => {
const cardElement = document.querySelector(`#human-cards .card-placeholder:nth-child(${cardIndex + 1})`);
cardElement.textContent = card.value + card.suit;
cardElement.style.color = card.suit === '♥' || card.suit === '♦' ? '#dc143c' : '#000';
cardElement.classList.add('card-revealed');
}, (cardIndex * 300) + (playerIndex * 100));
}
}
}
this.addLogEntry("Hole cards dealt to all players.");
}
createDeck() {
const suits = ['♠', '♥', '♦', '♣'];
const values = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'];
const deck = [];
for (let suit of suits) {
for (let value of values) {
deck.push({ suit, value });
}
}
return deck;
}
shuffleDeck(deck) {
for (let i = deck.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[deck[i], deck[j]] = [deck[j], deck[i]];
}
}
getNextActivePlayer(startIndex) {
for (let i = 1; i <= 6; i++) {
const nextIndex = (startIndex + i) % 6;
if (!this.players[nextIndex].folded) {
return nextIndex;
}
}
return 0; // Fallback
}
updateCurrentTurn() {
const currentPlayer = this.players[this.currentPlayerIndex];
document.getElementById('current-turn').textContent = currentPlayer.name;
// Highlight current player
document.querySelectorAll('.player-position').forEach(el => el.classList.remove('active'));
document.getElementById(`player-${currentPlayer.id}`).classList.add('active');
}
addLogEntry(message) {
const logElement = document.getElementById('log-entries');
const entry = document.createElement('div');
entry.className = 'log-entry';
entry.textContent = message;
logElement.appendChild(entry);
logElement.scrollTop = logElement.scrollHeight;
}
enablePlayerControls() {
if (this.currentPlayerIndex === 0) { // Human player's turn
const callAmount = this.currentBet - this.players[0].bet;
const canCheck = callAmount === 0;
document.getElementById('fold-btn').disabled = false;
document.getElementById('call-btn').disabled = false;
document.getElementById('raise-btn').disabled = false;
document.getElementById('check-btn').disabled = !canCheck;
document.getElementById('call-btn').textContent = canCheck ? 'Check' : `Call $${callAmount}`;
}
}
disablePlayerControls() {
document.getElementById('fold-btn').disabled = true;
document.getElementById('call-btn').disabled = true;
document.getElementById('raise-btn').disabled = true;
document.getElementById('check-btn').disabled = true;
}
startNewHand() {
// Reset game state
this.players.forEach(player => {
player.cards = [];
player.bet = 0;
player.folded = false;
});
this.communityCards = [];
this.pot = 0;
this.currentBet = 0;
this.roundBets = 0;
this.lastRaisePlayer = -1;
this.gamePhase = 'preflop';
// Clear all cards visually
document.querySelectorAll('.card-placeholder').forEach(card => {
card.textContent = '🂠';
card.style.color = '#000';
card.classList.remove('card-revealed');
});
// Clear all bets and quotes
this.players.forEach(player => {
document.getElementById(`${player.id}-bet`).textContent = '$0';
document.getElementById(`${player.id}-quote`).textContent = '';
document.getElementById(`${player.id}-status`).textContent = 'Waiting';
});
// Post blinds
this.postBlinds();
// Deal hole cards
this.dealHoleCards();
// Set initial betting order
this.currentPlayerIndex = this.getNextActivePlayer((this.dealerPosition + 3) % 6); // UTG
this.roundBets = 0;
this.updateGameInfo();
this.updateCurrentTurn();
this.addLogEntry("New hand started! Blinds posted, cards dealt.");
this.enablePlayerControls();
// Start AI actions after a brief delay
setTimeout(() => this.processBettingRound(), 1000);
}
processBettingRound() {
if (this.currentPlayerIndex === 0) {
// Human player's turn - wait for input
this.updateCurrentTurn();
return;
}
// AI player's turn
this.processAIAction();
}
processAIAction() {
const currentPlayer = this.players[this.currentPlayerIndex];
const leaderData = this.leaders[currentPlayer.id];
if (!leaderData) return; // Human player
// Calculate AI action based on playing style
const action = this.calculateAIAction(currentPlayer, leaderData);
// Execute action
this.executeAIAction(currentPlayer, action, leaderData);
// Move to next player
this.currentPlayerIndex = this.getNextActivePlayer(this.currentPlayerIndex);
// Continue if there are more players to act
if (this.shouldContinueBetting()) {
setTimeout(() => this.processBettingRound(), 1500);
} else {
this.endBettingRound();
}
}
calculateAIAction(player, leaderData) {
const handStrength = this.evaluateHandStrength(player.cards, this.communityCards);
const randomFactor = Math.random();
switch (leaderData.playingStyle) {
case 'dramatic':
if (handStrength > 0.7) return { type: 'raise', amount: Math.floor(randomFactor * 40) + 20 };
if (handStrength > 0.4) return { type: 'call' };
if (randomFactor > 0.6) return { type: 'raise', amount: 15 }; // Dramatic bluff
return { type: 'fold' };
case 'strategic':
if (handStrength > 0.8) return { type: 'raise', amount: Math.floor(randomFactor * 30) + 15 };
if (handStrength > 0.6) return { type: 'call' };
if (this.gamePhase === 'preflop' && randomFactor > 0.7) return { type: 'raise', amount: 12 };
return { type: 'fold' };
case 'aggressive':
if (handStrength > 0.5) return { type: 'raise', amount: Math.floor(randomFactor * 50) + 25 };
if (handStrength > 0.3) return { type: 'raise', amount: Math.floor(randomFactor * 25) + 10 };
if (randomFactor > 0.4) return { type: 'raise', amount: 8 }; // Aggression
return { type: 'call' };
case 'patient':
if (handStrength > 0.9) return { type: 'raise', amount: Math.floor(randomFactor * 35) + 20 };
if (handStrength > 0.7) return { type: 'call' };
if (this.gamePhase !== 'preflop' && randomFactor > 0.8) return { type: 'raise', amount: 15 };
return { type: 'fold' };
case 'unpredictable':
const actions = ['fold', 'call', 'raise'];
const action = actions[Math.floor(randomFactor * 3)];
if (action === 'raise') {
return { type: 'raise', amount: Math.floor(randomFactor * 60) + 20 };
}
return { type: action };
default:
return handStrength > 0.5 ? { type: 'call' } : { type: 'fold' };
}
}
executeAIAction(player, action, leaderData) {
const callAmount = this.currentBet - player.bet;
switch (action.type) {
case 'fold':
player.folded = true;
this.addLogEntry(`${player.name} folds.`);
document.getElementById(`${player.id}-status`).textContent = 'Folded';
document.getElementById(`${player.id}-quote`).textContent = `"${leaderData.quotes[Math.floor(Math.random() * leaderData.quotes.length)]}"`;
break;
case 'call':
if (callAmount > 0) {
this.placeBet(this.currentPlayerIndex, callAmount);
player.stack -= callAmount;
player.bet += callAmount;
this.addLogEntry(`${player.name} calls $${callAmount}.`);
} else {
this.addLogEntry(`${player.name} checks.`);
}
document.getElementById(`${player.id}-quote`).textContent = `"${leaderData.quotes[Math.floor(Math.random() * leaderData.quotes.length)]}"`;
break;
case 'raise':
const raiseAmount = action.amount;
const totalBet = callAmount + raiseAmount;
this.placeBet(this.currentPlayerIndex, totalBet);
player.stack -= totalBet;
player.bet += totalBet;
this.currentBet = player.bet;
this.lastRaisePlayer = this.currentPlayerIndex;
this.roundBets = 0; // Reset for new betting round
this.addLogEntry(`${player.name} raises to $${this.currentBet}!`);
document.getElementById(`${player.id}-quote`).textContent = `"Maximum pressure! ${raiseAmount} chip escalation!"`;
break;
}
this.updateAllStacks();
this.updateGameInfo();
}
evaluateHandStrength(holeCards, communityCards) {
// Simplified hand strength evaluation (0-1 scale)
if (holeCards.length === 0) return 0;
const allCards = [...holeCards, ...communityCards];
let strength = 0;
// Premium hands
if (holeCards.length === 2 && holeCards[0].value === holeCards[1].value) {
const pairValue = ['2','3','4','5','6','7','8','9','10','J','Q','K','A'].indexOf(holeCards[0].value);
strength = 0.5 + (pairValue / 13) * 0.5;
} else if (holeCards.some(card => card.value === 'A') && holeCards.some(card => card.value === 'K')) {
strength = 0.7;
}
// Community cards improve strength
if (communityCards.length >= 3) {
// Check for flush possibilities
const suits = allCards.map(card => card.suit);
const suitCounts = {};
suits.forEach(suit => suitCounts[suit] = (suitCounts[suit] || 0) + 1);
if (Object.values(suitCounts).some(count => count >= 4)) {
strength += 0.3;
}
}
return Math.min(strength, 1);
}
playerAction(actionType) {
const callAmount = this.currentBet - this.players[0].bet;
switch (actionType) {
case 'fold':
this.players[0].folded = true;
this.addLogEntry("You fold.");
document.getElementById('human-status').textContent = 'Folded';
this.endBettingRound();
return;
case 'call':
if (callAmount > 0) {
this.placeBet(0, callAmount);
this.players[0].stack -= callAmount;
this.players[0].bet += callAmount;
this.addLogEntry(`You call $${callAmount}.`);
} else {
this.addLogEntry("You check.");
}
break;
case 'raise':
const raiseInput = document.getElementById('raise-amount');
const raiseAmount = parseInt(raiseInput.value) || 20;
const totalBet = callAmount + raiseAmount;
if (totalBet <= this.players[0].stack) {
this.placeBet(0, totalBet);
this.players[0].stack -= totalBet;
this.players[0].bet += totalBet;
this.currentBet = this.players[0].bet;
this.lastRaisePlayer = 0;
this.roundBets = 0;
this.addLogEntry(`You raise to $${this.currentBet}!`);
} else {
alert("You don't have enough chips!");
return;
}
break;
case 'check':
if (this.currentBet === this.players[0].bet) {
this.addLogEntry("You check.");
} else {
return; // Can't check
}
break;
}
this.updateAllStacks();
this.updateGameInfo();
// Move to next player
this.currentPlayerIndex = this.getNextActivePlayer(this.currentPlayerIndex);
// Continue with AI actions
this.disablePlayerControls();
setTimeout(() => {
if (this.shouldContinueBetting()) {
this.processBettingRound();
} else {
this.endBettingRound();
}
}, 500);
}
shouldContinueBetting() {
const activePlayers = this.players.filter(p => !p.folded);
if (activePlayers.length <= 1) return false;
// Check if all active players have acted and matched the current bet
const playersWhoNeedToAct = activePlayers.filter(p =>
p.bet < this.currentBet ||
(this.roundBets > 0 && p.id !== this.players[this.lastRaisePlayer]?.id)
);
return playersWhoNeedToAct.length > 0;
}
endBettingRound() {
// Reset round-specific variables
this.roundBets = 0;
this.lastRaisePlayer = -1;
// Move to next game phase
if (this.gamePhase === 'preflop') {
this.gamePhase = 'flop';
this.dealFlop();
} else if (this.gamePhase === 'flop') {
this.gamePhase = 'turn';
this.dealTurn();
} else if (this.gamePhase === 'turn') {
this.gamePhase = 'river';
this.dealRiver();
} else if (this.gamePhase === 'river') {
this.showdown();
return;
}
// Start new betting round
this.currentPlayerIndex = this.getNextActivePlayer(this.dealerPosition); // SB acts first post-flop
setTimeout(() => this.processBettingRound(), 1000);
}
dealFlop() {
this.addLogEntry("Dealing the flop...");
for (let i = 0; i < 3; i++) {
this.communityCards.push(this.getRandomCard());
}
this.revealCommunityCards(['flop1', 'flop2', 'flop3']);
}
dealTurn() {
this.addLogEntry("Dealing the turn...");
this.communityCards.push(this.getRandomCard());
this.revealCommunityCards(['turn']);
}
dealRiver() {
this.addLogEntry("Dealing the river...");
this.communityCards.push(this.getRandomCard());
this.revealCommunityCards(['river']);
}
getRandomCard() {
const suits = ['♠', '♥', '♦', '♣'];
const values = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'];
return {
suit: suits[Math.floor(Math.random() * suits.length)],
value: values[Math.floor(Math.random() * values.length)]
};
}
revealCommunityCards(cardIds) {
cardIds.forEach((id, index) => {
setTimeout(() => {
const cardElement = document.getElementById(id);
const cardIndex = this.communityCards.length - cardIds.length + index;
const card = this.communityCards[cardIndex];
cardElement.textContent = card.value + card.suit;
cardElement.style.color = card.suit === '♥' || card.suit === '♦' ? '#dc143c' : '#000';
cardElement.classList.add('card-revealed');
}, index * 500);
});
}
showdown() {
this.addLogEntry("Showdown! Revealing all cards...");
// Reveal all remaining players' cards
this.players.forEach((player, index) => {
if (!player.folded && index !== 0) { // Don't re-reveal human cards
const cardElements = document.querySelectorAll(`#${player.id}-cards .card-placeholder`);
cardElements.forEach((cardElement, cardIndex) => {
setTimeout(() => {
const card = player.cards[cardIndex];
cardElement.textContent = card.value + card.suit;
cardElement.style.color = card.suit === '♥' || card.suit === '♦' ? '#dc143c' : '#000';
cardElement.classList.add('card-revealed');
}, (index * 300) + (cardIndex * 200));
});
}
});
// Determine winner (simplified - in real poker this would evaluate actual hands)
setTimeout(() => {
const activePlayers = this.players.filter(p => !p.folded);
const winner = activePlayers[Math.floor(Math.random() * activePlayers.length)];
if (winner.id === 'human') {
this.showVictory(winner);
} else {
this.showLeaderLosing(winner);
}
}, 2000);
}
showVictory(winner) {
this.handsPlayed++;
this.totalWon += this.pot;
winner.stack += this.pot;
document.getElementById('victory-amount').textContent = this.pot;
document.getElementById('total-won').textContent = this.totalWon;
document.getElementById('hands-played').textContent = this.handsPlayed;
document.getElementById('victory-overlay').style.display = 'flex';
this.addLogEntry(`🎉 You win $${this.pot}! Total winnings: $${this.totalWon}`);
}
showLeaderLosing(winner) {
const leaderData = this.leaders[winner.id];
winner.stack += this.pot;
// Create losing animation overlay
const overlay = document.createElement('div');
overlay.className = 'losing-overlay';
overlay.innerHTML = `
${leaderData.avatar}
${leaderData.name} Loses!
"${leaderData.losingQuote}"
`;
document.body.appendChild(overlay);
this.addLogEntry(`${leaderData.name} loses! ${leaderData.losingQuote}`);
}
continueAfterLosing() {
document.querySelector('.losing-overlay').remove();
}
continuePlaying() {
document.getElementById('victory-overlay').style.display = 'none';
this.updateAllStacks();
}
placeBet(playerIndex, amount) {
this.pot += amount;
this.roundBets++;
}
}
// Global game instance
let politicalTable;
// Initialize game when page loads
document.addEventListener('DOMContentLoaded', function() {
politicalTable = new PoliticalPokerTable();
});
// Global functions
function startNewHand() {
politicalTable.startNewHand();
}
function playerAction(action) {
politicalTable.playerAction(action);
}
function resetTable() {
politicalTable.resetTable();
}
function continuePlaying() {
politicalTable.continuePlaying();
}
function shareVictory() {
const text = `I just won at Political Poker against world leaders! 🎭 Check it out:`;
const url = window.location.href;
if (navigator.share) {
navigator.share({
title: 'Political Poker Victory!',
text: text,
url: url
});
} else {
window.open(`https://twitter.com/intent/tweet?text=${encodeURIComponent(text)}&url=${encodeURIComponent(url)}`, '_blank');
}
}