DeSqBlocki
1289 lines
23 KiB
JavaScript
1289 lines
23 KiB
JavaScript
const {
|
|
EmbedBuilder
|
|
} = require("discord.js");
|
|
|
|
const {
|
|
getProfileCollections,
|
|
getDefaultStats,
|
|
trackProfileEvent,
|
|
trackGameActivity
|
|
} = require("./profileSystem");
|
|
|
|
const {
|
|
getUnixTime
|
|
} = require("./cookieEconomy");
|
|
|
|
|
|
const POKER_GAME_KEY =
|
|
"poker";
|
|
|
|
const PROFILE_HAND_HISTORY_LIMIT =
|
|
100;
|
|
|
|
const PROFILE_ACTION_HISTORY_LIMIT =
|
|
250;
|
|
|
|
|
|
const ACTION_STAT_PATHS = {
|
|
fold:
|
|
"games.poker.folds",
|
|
check:
|
|
"games.poker.checks",
|
|
call:
|
|
"games.poker.calls",
|
|
bet:
|
|
"games.poker.bets",
|
|
raise:
|
|
"games.poker.raises",
|
|
all_in:
|
|
"games.poker.allInActions"
|
|
};
|
|
|
|
|
|
const HAND_RANK_STAT_PATHS = {
|
|
"High Card":
|
|
"games.poker.handRanks.highCard",
|
|
Pair:
|
|
"games.poker.handRanks.pair",
|
|
"Two Pair":
|
|
"games.poker.handRanks.twoPair",
|
|
"Three of a Kind":
|
|
"games.poker.handRanks.threeOfAKind",
|
|
Straight:
|
|
"games.poker.handRanks.straight",
|
|
Flush:
|
|
"games.poker.handRanks.flush",
|
|
"Full House":
|
|
"games.poker.handRanks.fullHouse",
|
|
"Four of a Kind":
|
|
"games.poker.handRanks.fourOfAKind",
|
|
"Straight Flush":
|
|
"games.poker.handRanks.straightFlush",
|
|
"Royal Flush":
|
|
"games.poker.handRanks.royalFlush"
|
|
};
|
|
|
|
|
|
async function ensurePokerProfileDocument(
|
|
userId,
|
|
guildId
|
|
) {
|
|
const {
|
|
stats
|
|
} =
|
|
getProfileCollections();
|
|
|
|
await stats.updateOne(
|
|
{
|
|
userId,
|
|
guildId
|
|
},
|
|
{
|
|
$setOnInsert:
|
|
getDefaultStats(
|
|
userId,
|
|
guildId
|
|
)
|
|
},
|
|
{
|
|
upsert: true
|
|
}
|
|
);
|
|
}
|
|
|
|
|
|
function getPokerHandId(
|
|
game
|
|
) {
|
|
if (
|
|
!game?.gameId
|
|
||
|
|
!Number.isSafeInteger(
|
|
Number(
|
|
game?.data?.handNumber
|
|
)
|
|
)
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
return (
|
|
`${game.gameId}:hand:${Number(game.data.handNumber)}`
|
|
);
|
|
}
|
|
|
|
|
|
function getPokerActionId(
|
|
game
|
|
) {
|
|
if (
|
|
!game?.gameId
|
|
||
|
|
!Number.isSafeInteger(
|
|
Number(game.version)
|
|
)
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
return (
|
|
`${game.gameId}:action:v${Number(game.version)}`
|
|
);
|
|
}
|
|
|
|
|
|
function normalizeActionType(
|
|
action
|
|
) {
|
|
return String(
|
|
action?.type ?? ""
|
|
).toLowerCase();
|
|
}
|
|
|
|
|
|
function normalizeCardRank(
|
|
card
|
|
) {
|
|
return String(
|
|
card?.rank ?? ""
|
|
).toUpperCase();
|
|
}
|
|
|
|
|
|
function isPocketAces(
|
|
holeCards
|
|
) {
|
|
return (
|
|
Array.isArray(holeCards)
|
|
&&
|
|
holeCards.length === 2
|
|
&&
|
|
holeCards.every(
|
|
card =>
|
|
normalizeCardRank(card) ===
|
|
"A"
|
|
)
|
|
);
|
|
}
|
|
|
|
|
|
function isSevenDeuce(
|
|
holeCards
|
|
) {
|
|
if (
|
|
!Array.isArray(holeCards)
|
|
||
|
|
holeCards.length !== 2
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
const ranks =
|
|
holeCards
|
|
.map(
|
|
normalizeCardRank
|
|
)
|
|
.sort();
|
|
|
|
return (
|
|
ranks[0] === "2"
|
|
&&
|
|
ranks[1] === "7"
|
|
);
|
|
}
|
|
|
|
|
|
function getPotSizeFromResult(
|
|
result
|
|
) {
|
|
return Object.values(
|
|
result?.payouts ?? {}
|
|
).reduce(
|
|
(sum, value) =>
|
|
sum +
|
|
Number(value ?? 0),
|
|
0
|
|
);
|
|
}
|
|
|
|
|
|
function getPlayerOutcome(
|
|
game,
|
|
handPlayer
|
|
) {
|
|
const hand =
|
|
game?.data?.hand;
|
|
|
|
const result =
|
|
hand?.result ??
|
|
game?.data?.lastHandResult;
|
|
|
|
const winnerSeats =
|
|
Array.isArray(
|
|
result?.winnerSeats
|
|
)
|
|
? result.winnerSeats
|
|
: [];
|
|
|
|
const isWinner =
|
|
winnerSeats.includes(
|
|
handPlayer.seat
|
|
);
|
|
|
|
const isSplitWinner =
|
|
isWinner
|
|
&&
|
|
winnerSeats.length > 1;
|
|
|
|
const finalStack =
|
|
Number(
|
|
handPlayer.stack ?? 0
|
|
);
|
|
|
|
const startingStack =
|
|
Number(
|
|
handPlayer.startingStack ?? 0
|
|
);
|
|
|
|
const profit =
|
|
finalStack -
|
|
startingStack;
|
|
|
|
const potSize =
|
|
getPotSizeFromResult(
|
|
result
|
|
);
|
|
|
|
let resultName =
|
|
"loss";
|
|
|
|
if (isSplitWinner) {
|
|
resultName =
|
|
"push";
|
|
}
|
|
|
|
else if (isWinner) {
|
|
resultName =
|
|
"win";
|
|
}
|
|
|
|
const reachedShowdown =
|
|
result?.type ===
|
|
"showdown"
|
|
&&
|
|
handPlayer.folded !==
|
|
true;
|
|
|
|
return {
|
|
result,
|
|
winnerSeats,
|
|
isWinner,
|
|
isSplitWinner,
|
|
resultName,
|
|
profit,
|
|
potSize,
|
|
reachedShowdown,
|
|
allIn:
|
|
handPlayer.allIn ===
|
|
true,
|
|
handRank:
|
|
handPlayer.handRank ??
|
|
null,
|
|
pocketAces:
|
|
isPocketAces(
|
|
handPlayer.holeCards
|
|
),
|
|
sevenDeuce:
|
|
isSevenDeuce(
|
|
handPlayer.holeCards
|
|
),
|
|
foldWin:
|
|
isWinner
|
|
&&
|
|
result?.type ===
|
|
"fold",
|
|
fullTableWin:
|
|
isWinner
|
|
&&
|
|
Array.isArray(hand?.players)
|
|
&&
|
|
hand.players.length === 6
|
|
};
|
|
}
|
|
|
|
|
|
async function recordPokerActionProfile(
|
|
game,
|
|
userId,
|
|
action
|
|
) {
|
|
const guildId =
|
|
game?.guildId;
|
|
|
|
const actionType =
|
|
normalizeActionType(
|
|
action
|
|
);
|
|
|
|
const statPath =
|
|
ACTION_STAT_PATHS[
|
|
actionType
|
|
];
|
|
|
|
const actionId =
|
|
getPokerActionId(
|
|
game
|
|
);
|
|
|
|
if (
|
|
!guildId
|
|
||
|
|
!userId
|
|
||
|
|
!statPath
|
|
||
|
|
!actionId
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
await ensurePokerProfileDocument(
|
|
String(userId),
|
|
String(guildId)
|
|
);
|
|
|
|
const {
|
|
stats
|
|
} =
|
|
getProfileCollections();
|
|
|
|
const result =
|
|
await stats.updateOne(
|
|
{
|
|
userId:
|
|
String(userId),
|
|
guildId:
|
|
String(guildId),
|
|
"games.poker.processedActions": {
|
|
$ne:
|
|
actionId
|
|
}
|
|
},
|
|
{
|
|
$inc: {
|
|
[statPath]:
|
|
1
|
|
},
|
|
$push: {
|
|
"games.poker.processedActions": {
|
|
$each: [
|
|
actionId
|
|
],
|
|
$slice:
|
|
-PROFILE_ACTION_HISTORY_LIMIT
|
|
}
|
|
}
|
|
}
|
|
);
|
|
|
|
return (
|
|
result.modifiedCount ===
|
|
1
|
|
);
|
|
}
|
|
|
|
|
|
async function repairProfileBestStreaks(
|
|
userId,
|
|
guildId
|
|
) {
|
|
const {
|
|
stats
|
|
} =
|
|
getProfileCollections();
|
|
|
|
const current =
|
|
await stats.findOne(
|
|
{
|
|
userId,
|
|
guildId
|
|
},
|
|
{
|
|
projection: {
|
|
"games.poker.currentWinStreak":
|
|
1,
|
|
"games.poker.currentLossStreak":
|
|
1,
|
|
"streaks.currentWin":
|
|
1,
|
|
"streaks.currentLoss":
|
|
1
|
|
}
|
|
}
|
|
);
|
|
|
|
await stats.updateOne(
|
|
{
|
|
userId,
|
|
guildId
|
|
},
|
|
{
|
|
$max: {
|
|
"games.poker.bestWinStreak":
|
|
Number(
|
|
current
|
|
?.games
|
|
?.poker
|
|
?.currentWinStreak ??
|
|
0
|
|
),
|
|
"games.poker.bestLossStreak":
|
|
Number(
|
|
current
|
|
?.games
|
|
?.poker
|
|
?.currentLossStreak ??
|
|
0
|
|
),
|
|
"streaks.bestWin":
|
|
Number(
|
|
current
|
|
?.streaks
|
|
?.currentWin ??
|
|
0
|
|
),
|
|
"streaks.bestLoss":
|
|
Number(
|
|
current
|
|
?.streaks
|
|
?.currentLoss ??
|
|
0
|
|
)
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
|
|
async function recordPokerHandForPlayer(
|
|
game,
|
|
handPlayer
|
|
) {
|
|
const guildId =
|
|
String(
|
|
game.guildId
|
|
);
|
|
|
|
const userId =
|
|
String(
|
|
handPlayer.userId
|
|
);
|
|
|
|
const handId =
|
|
getPokerHandId(
|
|
game
|
|
);
|
|
|
|
if (!handId) {
|
|
return {
|
|
processed: false,
|
|
userId,
|
|
reason:
|
|
"INVALID_HAND_ID"
|
|
};
|
|
}
|
|
|
|
await ensurePokerProfileDocument(
|
|
userId,
|
|
guildId
|
|
);
|
|
|
|
const outcome =
|
|
getPlayerOutcome(
|
|
game,
|
|
handPlayer
|
|
);
|
|
|
|
const inc = {
|
|
"games.total.played":
|
|
1,
|
|
"games.poker.played":
|
|
1,
|
|
"games.poker.handsPlayed":
|
|
1
|
|
};
|
|
|
|
if (
|
|
outcome.resultName ===
|
|
"win"
|
|
) {
|
|
inc[
|
|
"games.total.won"
|
|
] = 1;
|
|
|
|
inc[
|
|
"games.poker.won"
|
|
] = 1;
|
|
|
|
inc[
|
|
"games.poker.handsWon"
|
|
] = 1;
|
|
}
|
|
|
|
else if (
|
|
outcome.resultName ===
|
|
"loss"
|
|
) {
|
|
inc[
|
|
"games.total.lost"
|
|
] = 1;
|
|
|
|
inc[
|
|
"games.poker.lost"
|
|
] = 1;
|
|
|
|
inc[
|
|
"games.poker.handsLost"
|
|
] = 1;
|
|
}
|
|
|
|
else {
|
|
inc[
|
|
"games.total.pushed"
|
|
] = 1;
|
|
|
|
inc[
|
|
"games.poker.pushed"
|
|
] = 1;
|
|
|
|
inc[
|
|
"games.poker.handsPushed"
|
|
] = 1;
|
|
}
|
|
|
|
const set = {};
|
|
|
|
if (
|
|
outcome.resultName ===
|
|
"win"
|
|
) {
|
|
inc[
|
|
"games.poker.currentWinStreak"
|
|
] = 1;
|
|
|
|
inc[
|
|
"streaks.currentWin"
|
|
] = 1;
|
|
|
|
set[
|
|
"games.poker.currentLossStreak"
|
|
] = 0;
|
|
|
|
set[
|
|
"streaks.currentLoss"
|
|
] = 0;
|
|
}
|
|
|
|
else if (
|
|
outcome.resultName ===
|
|
"loss"
|
|
) {
|
|
inc[
|
|
"games.poker.currentLossStreak"
|
|
] = 1;
|
|
|
|
inc[
|
|
"streaks.currentLoss"
|
|
] = 1;
|
|
|
|
set[
|
|
"games.poker.currentWinStreak"
|
|
] = 0;
|
|
|
|
set[
|
|
"streaks.currentWin"
|
|
] = 0;
|
|
}
|
|
|
|
if (
|
|
outcome.profit > 0
|
|
) {
|
|
inc[
|
|
"games.poker.cookiesWon"
|
|
] =
|
|
outcome.profit;
|
|
|
|
inc[
|
|
"economy.cookiesObtainedTotal"
|
|
] =
|
|
outcome.profit;
|
|
}
|
|
|
|
else if (
|
|
outcome.profit < 0
|
|
) {
|
|
const loss =
|
|
Math.abs(
|
|
outcome.profit
|
|
);
|
|
|
|
inc[
|
|
"games.poker.cookiesLost"
|
|
] =
|
|
loss;
|
|
|
|
inc[
|
|
"economy.cookiesLostTotal"
|
|
] =
|
|
loss;
|
|
}
|
|
|
|
if (
|
|
outcome.reachedShowdown
|
|
) {
|
|
inc[
|
|
"games.poker.showdowns"
|
|
] = 1;
|
|
|
|
if (outcome.isWinner) {
|
|
inc[
|
|
"games.poker.showdownWins"
|
|
] = 1;
|
|
}
|
|
}
|
|
|
|
if (
|
|
outcome.allIn
|
|
) {
|
|
inc[
|
|
"games.poker.allIns"
|
|
] = 1;
|
|
|
|
if (outcome.isWinner) {
|
|
inc[
|
|
"games.poker.allInWins"
|
|
] = 1;
|
|
}
|
|
}
|
|
|
|
if (
|
|
outcome.foldWin
|
|
) {
|
|
inc[
|
|
"games.poker.foldWins"
|
|
] = 1;
|
|
}
|
|
|
|
if (
|
|
outcome.fullTableWin
|
|
) {
|
|
inc[
|
|
"games.poker.fullTableWins"
|
|
] = 1;
|
|
}
|
|
|
|
if (
|
|
outcome.isWinner
|
|
&&
|
|
outcome.pocketAces
|
|
) {
|
|
inc[
|
|
"games.poker.pocketAcesWins"
|
|
] = 1;
|
|
}
|
|
|
|
if (
|
|
outcome.isWinner
|
|
&&
|
|
outcome.sevenDeuce
|
|
) {
|
|
inc[
|
|
"games.poker.sevenDeuceWins"
|
|
] = 1;
|
|
}
|
|
|
|
const handRankPath =
|
|
HAND_RANK_STAT_PATHS[
|
|
outcome.handRank?.name
|
|
];
|
|
|
|
if (
|
|
outcome.reachedShowdown
|
|
&&
|
|
handRankPath
|
|
) {
|
|
inc[
|
|
handRankPath
|
|
] = 1;
|
|
}
|
|
|
|
const {
|
|
stats
|
|
} =
|
|
getProfileCollections();
|
|
|
|
const update = {
|
|
$inc:
|
|
inc,
|
|
...(Object.keys(set).length
|
|
? {
|
|
$set:
|
|
set
|
|
}
|
|
: {}),
|
|
$push: {
|
|
"games.poker.processedHands": {
|
|
$each: [
|
|
handId
|
|
],
|
|
$slice:
|
|
-PROFILE_HAND_HISTORY_LIMIT
|
|
}
|
|
}
|
|
};
|
|
|
|
if (outcome.isWinner) {
|
|
update.$max = {
|
|
"games.poker.largestPotWon":
|
|
outcome.potSize
|
|
};
|
|
}
|
|
|
|
const write =
|
|
await stats.updateOne(
|
|
{
|
|
userId,
|
|
guildId,
|
|
"games.poker.processedHands": {
|
|
$ne:
|
|
handId
|
|
}
|
|
},
|
|
update
|
|
);
|
|
|
|
if (
|
|
write.modifiedCount !==
|
|
1
|
|
) {
|
|
await repairProfileBestStreaks(
|
|
userId,
|
|
guildId
|
|
);
|
|
|
|
return {
|
|
processed: false,
|
|
userId,
|
|
handId,
|
|
outcome
|
|
};
|
|
}
|
|
|
|
await repairProfileBestStreaks(
|
|
userId,
|
|
guildId
|
|
);
|
|
|
|
try {
|
|
await trackGameActivity(
|
|
userId,
|
|
guildId
|
|
);
|
|
}
|
|
|
|
catch (error) {
|
|
console.error(
|
|
`[PokerProfile] Activity tracking failed for ${userId}:`,
|
|
error
|
|
);
|
|
}
|
|
|
|
return {
|
|
processed: true,
|
|
userId,
|
|
handId,
|
|
outcome
|
|
};
|
|
}
|
|
|
|
|
|
async function recordPokerHandProfiles(
|
|
game
|
|
) {
|
|
const hand =
|
|
game?.data?.hand;
|
|
|
|
if (
|
|
!hand
|
|
||
|
|
hand.state !==
|
|
"PAYOUT"
|
|
||
|
|
!hand.result
|
|
||
|
|
!Array.isArray(
|
|
hand.players
|
|
)
|
|
) {
|
|
return [];
|
|
}
|
|
|
|
const results = [];
|
|
|
|
for (
|
|
const handPlayer
|
|
of hand.players
|
|
) {
|
|
try {
|
|
results.push(
|
|
await recordPokerHandForPlayer(
|
|
game,
|
|
handPlayer
|
|
)
|
|
);
|
|
}
|
|
|
|
catch (error) {
|
|
console.error(
|
|
`[PokerProfile] Failed to record hand ${getPokerHandId(game) ?? "unknown"} for ${handPlayer.userId}:`,
|
|
error
|
|
);
|
|
|
|
results.push({
|
|
processed: false,
|
|
userId:
|
|
String(
|
|
handPlayer.userId
|
|
),
|
|
error
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
|
|
async function claimPokerBadge(
|
|
context,
|
|
userId,
|
|
badgeId,
|
|
metadata = null
|
|
) {
|
|
const guildId =
|
|
context?.guildId;
|
|
|
|
if (!guildId) {
|
|
return false;
|
|
}
|
|
|
|
const {
|
|
badges
|
|
} =
|
|
getProfileCollections();
|
|
|
|
const set = {
|
|
ownerId:
|
|
String(userId),
|
|
unlockedAt:
|
|
getUnixTime()
|
|
};
|
|
|
|
if (
|
|
metadata
|
|
&&
|
|
typeof metadata ===
|
|
"object"
|
|
) {
|
|
set.metadata =
|
|
metadata;
|
|
}
|
|
|
|
const badge =
|
|
await badges.findOneAndUpdate(
|
|
{
|
|
guildId:
|
|
String(guildId),
|
|
badgeId,
|
|
ownerId:
|
|
null
|
|
},
|
|
{
|
|
$set:
|
|
set
|
|
},
|
|
{
|
|
returnDocument:
|
|
"after"
|
|
}
|
|
);
|
|
|
|
if (
|
|
!badge
|
|
||
|
|
badge.ownerId !==
|
|
String(userId)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
if (
|
|
!context.channel
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
await context.channel.send({
|
|
embeds: [
|
|
new EmbedBuilder()
|
|
.setTitle(
|
|
"🏅 Unique Badge Claimed!"
|
|
)
|
|
.setDescription(
|
|
[
|
|
`${badge.emoji ?? "♠️"} **${badge.name ?? badge.badgeId}**`,
|
|
"",
|
|
`<@${userId}> claimed a guild-unique Poker badge!`,
|
|
"",
|
|
badge.description ??
|
|
"A unique Poker badge has been claimed.",
|
|
"",
|
|
"*This badge can no longer be earned by another player.*"
|
|
].join("\n")
|
|
)
|
|
.setFooter({
|
|
text:
|
|
`badge:${badge.badgeId}`
|
|
})
|
|
.setTimestamp()
|
|
]
|
|
});
|
|
}
|
|
|
|
catch (error) {
|
|
console.error(
|
|
`[PokerBadge] Failed to announce ${badgeId} for ${userId}:`,
|
|
error
|
|
);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
async function evaluatePokerBadges(
|
|
context,
|
|
userId,
|
|
outcome
|
|
) {
|
|
const {
|
|
stats
|
|
} =
|
|
getProfileCollections();
|
|
|
|
const document =
|
|
await stats.findOne({
|
|
userId:
|
|
String(userId),
|
|
guildId:
|
|
String(context.guildId)
|
|
});
|
|
|
|
const poker =
|
|
document?.games?.poker ?? {};
|
|
|
|
if (
|
|
Number(
|
|
poker.won ?? 0
|
|
) >= 1
|
|
) {
|
|
await claimPokerBadge(
|
|
context,
|
|
userId,
|
|
"first_poker_win"
|
|
);
|
|
}
|
|
|
|
if (
|
|
Number(
|
|
poker.allInWins ?? 0
|
|
) >= 1
|
|
) {
|
|
await claimPokerBadge(
|
|
context,
|
|
userId,
|
|
"first_poker_allin_win"
|
|
);
|
|
}
|
|
|
|
if (
|
|
Number(
|
|
poker.pocketAcesWins ?? 0
|
|
) >= 1
|
|
) {
|
|
await claimPokerBadge(
|
|
context,
|
|
userId,
|
|
"first_poker_pocket_aces_win"
|
|
);
|
|
}
|
|
|
|
if (
|
|
Number(
|
|
poker.handRanks
|
|
?.royalFlush ?? 0
|
|
) >= 1
|
|
) {
|
|
await claimPokerBadge(
|
|
context,
|
|
userId,
|
|
"first_poker_royal_flush"
|
|
);
|
|
}
|
|
|
|
if (
|
|
Number(
|
|
poker.fullTableWins ?? 0
|
|
) >= 1
|
|
) {
|
|
await claimPokerBadge(
|
|
context,
|
|
userId,
|
|
"first_poker_full_table_win"
|
|
);
|
|
}
|
|
|
|
if (
|
|
Number(
|
|
poker.largestPotWon ?? 0
|
|
) >= 5000
|
|
) {
|
|
await claimPokerBadge(
|
|
context,
|
|
userId,
|
|
"first_poker_5000_pot",
|
|
{
|
|
pot:
|
|
outcome?.potSize ??
|
|
poker.largestPotWon
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
async function claimPokerAnnouncement(
|
|
game,
|
|
userId
|
|
) {
|
|
const handId =
|
|
getPokerHandId(
|
|
game
|
|
);
|
|
|
|
if (!handId) {
|
|
return false;
|
|
}
|
|
|
|
const {
|
|
stats
|
|
} =
|
|
getProfileCollections();
|
|
|
|
const result =
|
|
await stats.updateOne(
|
|
{
|
|
userId:
|
|
String(userId),
|
|
guildId:
|
|
String(game.guildId),
|
|
"games.poker.announcedHands": {
|
|
$ne:
|
|
handId
|
|
}
|
|
},
|
|
{
|
|
$push: {
|
|
"games.poker.announcedHands": {
|
|
$each: [
|
|
handId
|
|
],
|
|
$slice:
|
|
-PROFILE_HAND_HISTORY_LIMIT
|
|
}
|
|
}
|
|
}
|
|
);
|
|
|
|
return (
|
|
result.modifiedCount ===
|
|
1
|
|
);
|
|
}
|
|
|
|
|
|
async function announcePokerHandProgress(
|
|
context,
|
|
game
|
|
) {
|
|
if (
|
|
!context?.guildId
|
|
||
|
|
!game?.data?.hand
|
|
||
|
|
game.data.hand.state !==
|
|
"PAYOUT"
|
|
||
|
|
!Array.isArray(
|
|
game.data.hand.players
|
|
)
|
|
) {
|
|
return [];
|
|
}
|
|
|
|
const results = [];
|
|
|
|
for (
|
|
const handPlayer
|
|
of game.data.hand.players
|
|
) {
|
|
const userId =
|
|
String(
|
|
handPlayer.userId
|
|
);
|
|
|
|
try {
|
|
const claimed =
|
|
await claimPokerAnnouncement(
|
|
game,
|
|
userId
|
|
);
|
|
|
|
if (!claimed) {
|
|
continue;
|
|
}
|
|
|
|
const outcome =
|
|
getPlayerOutcome(
|
|
game,
|
|
handPlayer
|
|
);
|
|
|
|
await trackProfileEvent(
|
|
context,
|
|
userId,
|
|
{
|
|
type:
|
|
"profile_refresh",
|
|
source:
|
|
"poker",
|
|
game:
|
|
POKER_GAME_KEY,
|
|
result:
|
|
outcome.resultName,
|
|
profit:
|
|
outcome.profit,
|
|
allIn:
|
|
outcome.allIn,
|
|
handRank:
|
|
outcome.handRank?.name ??
|
|
null,
|
|
pocketAces:
|
|
outcome.pocketAces,
|
|
sevenDeuce:
|
|
outcome.sevenDeuce,
|
|
foldWin:
|
|
outcome.foldWin,
|
|
fullTableWin:
|
|
outcome.fullTableWin,
|
|
pot:
|
|
outcome.potSize
|
|
}
|
|
);
|
|
|
|
await evaluatePokerBadges(
|
|
context,
|
|
userId,
|
|
outcome
|
|
);
|
|
|
|
results.push({
|
|
userId,
|
|
announced: true
|
|
});
|
|
}
|
|
|
|
catch (error) {
|
|
console.error(
|
|
`[PokerProfile] Failed to refresh achievements/badges for ${userId}:`,
|
|
error
|
|
);
|
|
|
|
results.push({
|
|
userId,
|
|
announced: false,
|
|
error
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
|
|
async function createPokerProfileContext(
|
|
client,
|
|
game
|
|
) {
|
|
if (
|
|
!client
|
|
||
|
|
!game?.guildId
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
let channel =
|
|
null;
|
|
|
|
if (
|
|
game.channelId
|
|
) {
|
|
try {
|
|
channel =
|
|
await client.channels.fetch(
|
|
game.channelId
|
|
);
|
|
}
|
|
|
|
catch {}
|
|
}
|
|
|
|
return {
|
|
guildId:
|
|
String(game.guildId),
|
|
channel,
|
|
replied:
|
|
false,
|
|
deferred:
|
|
false
|
|
};
|
|
}
|
|
|
|
|
|
module.exports = {
|
|
ensurePokerProfileDocument,
|
|
getPokerHandId,
|
|
getPokerActionId,
|
|
getPlayerOutcome,
|
|
|
|
recordPokerActionProfile,
|
|
recordPokerHandProfiles,
|
|
announcePokerHandProgress,
|
|
createPokerProfileContext,
|
|
|
|
claimPokerBadge,
|
|
evaluatePokerBadges
|
|
};
|