Val Town Code SearchReturn to Val Town

1import { email } from "https://esm.town/v/std/email";
2
3export default async function(interval: Interval) {
4  const resp = await fetch("https://www.nintendo.com/au/nintendo-live-2024-sydney");
5  const html = await resp.text();

20
21const _logEl = document.getElementById("logs");
22function log(message) {
23  console.log(message);
24  _logEl.innerHTML += `<pre>${JSON.stringify(message, null, 2)}</pre>`;
28
29const _statusEl = document.getElementById("status");
30function status(message) {
31  _statusEl.hidden = false;
32  _statusEl.innerText = message;
34}
35
36async function postJson(url, body?) {
37  return await fetch(url, {
38    method: "POST",
42}
43
44async function handleRegister() {
45  const username = document.getElementById("name").value;
46
57}
58
59async function startAuth(options, conditional) {
60  await SimpleWebAuthnBrowser.startAuthentication(options, conditional)
61    .then(log)
74});
75
76async function handleLogin() {
77  const username = document.getElementById("name").value;
78
80}
81
82async function handleLogout() {
83  await postJson("/logout");
84  status("✅ Logged out!");

23
24// UTILS
25function generateJWT(userId: string) {
26  return new SignJWT({ userId }).setProtectedHeader({ alg: "HS256" }).sign(SECRET);
27}
28function verifyJWT(token: string) {
29  return jwtVerify(token, SECRET);
30}
31function generateRandomString() {
32  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
33}

9import { agentHandler } from "https://esm.town/v/saolsen/gameplay_agent";
10
11function rand_action(
12  state: Connect4State,
13  agent_data?: { counter: number },

7} from "https://esm.town/v/saolsen/gameplay_poker";
8
9function fold_action(
10  view: PokerView,
11  _agent_data?: JsonObject,

8} from "https://esm.town/v/saolsen/gameplay_poker";
9
10function agent(view: PokerView, _agent_data?: JsonObject): PokerAgentResponse {
11  const round = view.rounds[view.round];
12  const player = round.active_player;

11const SIMULATIONS = 10000;
12
13function rand_action(state: Connect4State): Connect4Action {
14  const player = state.active_player;
15  while (true) {
22}
23
24function score_action(
25  current_state: Connect4State,
26  action: Connect4Action,
63}
64
65function agent(state: Connect4State): Connect4AgentResponse {
66  // For each action we could take, simulate multiple random games from the resulting state.
67  // Keep track of the number of wins for each action.

83  /** The name of the agent. */
84  agentname: string;
85  /** The agent function. */
86  agent: Connect4Agent<T> | Connect4AsyncAgent<T>;
87}
99  /** The name of the agent. */
100  agentname: string;
101  /** The agent function. */
102  agent: PokerAgent<T> | PokerAsyncAgent<T>;
103}
121 * a variety of different http server libraries.
122 *
123 * To see how to write the agent functions,
124 * see the {@link Connect4Agent} and {@link PokerAgent}
125 *
134 * used with an http server that supports the fetch interface.
135 */
136export function agentHandler<
137  T extends Json = Json,
138>(
139  agents: AgentSpec<T>[],
140): (req: Request) => Promise<Response> {
141  return async function(request: Request): Promise<Response> {
142    if (request.method === "GET") {
143      return Response.json({

100
101/**
102 * Helper function to create a {@link Card} from a string.
103 *
104 * @param {string} s The string representation of the card.
106 * @returns {Card} The card.
107 */
108export function cardFromString(s: string): Card {
109  const rank_s = s.slice(0, -1);
110  const rank = RANK_NAMES.indexOf(rank_s);
121
122/**
123 * Helper function to create a string from a {@link Card}.
124 *
125 * @param {Card} c The card.
127 * @returns {string} The string representation of the card.
128 */
129export function cardToString(c: Card): string {
130  return RANK_NAMES[c.rank] + SUIT_NAMES[c.suit];
131}
137 * @returns {Card[]} A deck of cards.
138 */
139export function deck(): Card[] {
140  const cards: Card[] = [];
141  for (let rank: Rank = 0; rank <= Rank.Ace; rank++) {
156 * @param {Card[]} cards The deck of cards to shuffle.
157 */
158export function shuffle(cards: Card[]) {
159  let i = cards.length;
160  while (i !== 0) {
339
340/**
341 * Function to compute the {@link Hand} of a list of 5 cards.
342 *
343 * @param {Card[]} cards The list of 5 cards.
345 * @returns {Hand} The hand of the cards.
346 */
347export function hand(cards: Card[]): Hand {
348  if (cards.length !== 5) {
349    throw new Error(`Invalid number of cards: ${cards.length}`);
443
444/**
445 * Helper function to compute a value for a {@link Hand} that can be compared
446 * to other hands.
447 *
459 * @returns {number[]} The comparison value for the hand.
460 */
461export function handRank(hand: Hand): number[] {
462  const hand_rank: number[] = [hand.kind];
463  switch (hand.kind) {
509
510/**
511 * Comparator function for {@link Hand} values.
512 *
513 * @param {Hand} a A hand to compare.
518 * and 0 if they are equal.
519 */
520export function compareHands(a: Hand, b: Hand): number {
521  const a_rank = handRank(a);
522  const b_rank = handRank(b);
542 * @returns {Hand} The best hand (made from 5 of them) from the cards.
543 */
544export function bestHand(cards: Card[]): Hand {
545  console.assert(cards.length === 7);
546  const hand_cards = [];
788
789/**
790 * Function to create a new Poker game.
791 *
792 * @param {PokerArgs} args The arguments to create the game.
796 * or an error if the arguments are invalid.
797 */
798export function newGame(
799  args: PokerArgs,
800): [PokerState, Status] | GameError {
869 * @returns {null | GameError} null if the action is valid, or a GameError if it is invalid.
870 */
871export function checkAction(
872  state: PokerState | PokerView,
873  player: number,
947 * there are no more {@link RoundPlayerStatus.Playing} players.
948 */
949function playerAfter(
950  player: number | null,
951  player_status: RoundPlayerStatus[],
977 * or an error if the action is invalid.
978 */
979export function applyAction(
980  state: PokerState,
981  player: number,
1322 * @returns {PokerView | GameError} The player's game view.
1323 */
1324export function getView(
1325  state: PokerState,
1326  player: number,
1366
1367/**
1368 * Function type for a Poker Agent.
1369 *
1370 * * Takes the current game state and optional agent data.
1392
1393/**
1394 * Function type for an async Poker Agent.
1395 *
1396 * * Takes the current game state and optional agent data.

52   *  * The board is a 2D array of {@link Slot}.
53   *  * The first index is the column and the second index is the row.
54   *  See {@link get} and {@link set} for helper functions
55   *  to access the board by column and row.
56   */
80
81/**
82 * Function to create a new Connect4 game.
83 *
84 * @param {Connect4Args} args The arguments to create the game.
88 * or an error if the arguments are invalid.
89 */
90export function newGame(
91  args: Connect4Args,
92): [Connect4State, Status] | GameError {
115
116/**
117 * Helper function to get the slot at a column and row.
118 *
119 * @param {Connect4State} state The game state.
123 * @returns {Slot} The slot at the column and row.
124 */
125export function get(state: Connect4State, col: number, row: number): Slot {
126  return state.board[col][row];
127}
128
129/**
130 * Helper function to set the slot at a column and row.
131 *
132 * @param {Connect4State} state The game state.
135 * @param {Slot} slot The value to set it to.
136 */
137export function set(
138  state: Connect4State,
139  col: number,
144}
145
146function check_slots_eq(a: Slot, b: Slot, c: Slot, d: Slot): Slot {
147  if (a === b && b === c && c === d) {
148    return a;
162 * or an error if the game state is invalid.
163 */
164export function checkStatus(state: Connect4State): Status | GameError {
165  // Check Vertical Win
166  for (let col = 0; col < COLS; col++) {
256 * @returns {null | GameError} null if the action is valid, or a GameError if it is invalid.
257 */
258export function checkAction(
259  state: Connect4State,
260  player: number,
285 * or an error if the action is invalid.
286 */
287export function applyAction(
288  state: Connect4State,
289  player: number,
306/**
307 * Get the player specific view of the game state.
308 * This function is required to define a {@link Game},
309 * but Connect4 does not have a player specific view because
310 * all players can see the entire board.
316 * @returns {Connect4State | GameError} The game state.
317 */
318export function getView(
319  state: Connect4State,
320  _player: number,
343
344/**
345 * Function type for a Connect4 Agent.
346 *
347 * * Takes the current game state and optional agent data.
369
370/**
371 * Function type for an async Connect4 Agent.
372 *
373 * * Takes the current game state and optional agent data.