yes.getPlayer(): Promise<Player>

Get the current player as other players see them on leaderboards: a name and an avatar. There are no player ids. If the app is still signing the player in, the call waits for it. Both fields are null when nobody is signed in.

const player = await yes.getPlayer();
nameLabel.textContent = player.name ?? 'Player';

yes.submitScore(score: number, options?: SubmitScoreOptions): Promise<SubmitScoreResult>

Submit a score to the leaderboard. It never blocks your game, so you can call it and move on. If you want the result, await it: it resolves once the server has checked the score. Offline, the score is saved on the device and syncs later.

// Fire and forget
yes.submitScore(gameState.score);

// Or wait for the server's answer
const result = await yes.submitScore(gameState.score);
if (result.validated && result.isNewBest) {
  showBanner(`New best! Rank #${result.rank}`);
}

yes.getLeaderboard(): Promise<LeaderboardSnapshot | null>

Get the game's leaderboards so you can draw your own board. You get two boards: weekly (resets every week) and allTime. Each has the top 10 (top), the player's own row (self, or null if they haven't scored) and the players just above and below them (neighbours). Calling it again is cheap, and calling it right after submitScore() gives you the board with the new score. Resolves null when there's no leaderboard to show, e.g. the player is signed out — skip your leaderboard UI then.

const board = await yes.getLeaderboard();
if (board) {
  const me = board.weekly.self;
  showRank(me ? `#${me.rank} this week` : 'Play to get on the board');
  for (const row of board.weekly.top) {
    drawRow(row.rank, row.name, row.score, row.isSelf);
  }
}

yes.isRewardedAdReady(): Promise<RewardState>

Read what your offer needs to draw itself: whether a rewarded ad is ready, and how many Tickets the player holds.

const { ready, ticketBalance } = await yes.isRewardedAdReady();

watchAdButton.disabled = !ready;
ticketLabel.textContent = `You have ${ticketBalance} Tickets`;

yes.onRewardStateChange(callback: (state: RewardState) => void): () => void

Fires when ad readiness or the Ticket balance changes, so you redraw your offer instead of polling. Returns an unsubscribe function.

drawOffer(await yes.isRewardedAdReady());
const off = yes.onRewardStateChange(state => drawOffer(state));

// ...when the offer closes
off();

yes.reportRewardOffered(placement: string): void

Call it every time an offer appears on screen, whether or not the player takes it. No need to await. Without it the platform can't tell a placement nobody takes from one nobody sees.

showReviveOffer();
yes.reportRewardOffered('revive');

yes.watchRewardedAd(placement: string): Promise<RewardedAdResult>

Play a rewarded ad straight away, with no platform screen. Your game is paused while it plays. Grant the reward only when rewarded is true. Watching an ad never gives the player Tickets.

const result = await yes.watchRewardedAd('revive');
if (result.rewarded) {
  revivePlayer();
}

yes.spendTicket(amount: number, placement: string): Promise<TicketSpendResult>

Spend Tickets at the price you set. Each call is one spend; calling again charges again. If the player doesn't hold enough, the Yes Store opens with your game paused behind it, and the call resolves once it closes: spent if they bought enough, otherwise INSUFFICIENT_BALANCE.

const result = await yes.spendTicket(3, 'booster');
if (result.spent) {
  grantBooster();
}

yes.showInterstitialAd(placement?: string): Promise<InterstitialAdResult>

Tell the platform this is a good moment for an ad. If no ad fits or none is loaded, it resolves 'skipped' straight away. If an ad plays, your game is paused behind it and the call resolves when the ad closes. Either way, carry on the same. Only call it at a real break, never mid-action.

async function onLevelComplete() {
  showResults();
  await yes.showInterstitialAd('level_end');
  showNextLevelButton(); // the same whether or not an ad played
}

yes.isInterstitialAdReady(): Promise<AdReadyStatus>

Whether an interstitial is loaded right now. Just a hint: you don't need to call it before showInterstitialAd(), which may still skip.

const { ready } = await yes.isInterstitialAdReady();

yes.haptic(style?: HapticStyle): void

Trigger haptic feedback on the player's device. No need to await. Does nothing on devices without haptics.

yes.haptic();          // default medium tap
yes.haptic('success'); // positive feedback
yes.haptic('error');   // negative feedback

yes.getLanguage(): string

Returns the app's current language code. Synchronous, and already correct on your first line of game code — no need to wait for onReady().

const lang = yes.getLanguage();
const base = lang.split('-')[0]; // 'pt-BR' -> 'pt'

setUILanguage(SUPPORTED[base] ? base : 'en');

yes.onLanguageChange(callback: (language: string) => void): () => void

Fires when the player switches language while your game is running. Only on an actual change — read the initial value with getLanguage(). Returns an unsubscribe function.

// Localize now, and again whenever the player switches.
applyTranslations();
yes.onLanguageChange(() => applyTranslations());