MotoGP फ़ैंटेसी लीग की स्कोरिंग

फ़ैंटेसी गेम रेस डेटा के सबसे अच्छे उपयोगों में से एक हैं: खिलाड़ी राइडर चुनते हैं और हर नतीजा लीग टेबल को बदल देता है। यह गाइड JavaScript में आपके नियंत्रण वाले नियमों से लीग की स्कोरिंग करती है।

नियम

हर फ़ैंटेसी टीम तीन राइडर चुनती है। हर राउंड के बाद हर राइडर को मिलते हैं:

घटना	फ़ैंटेसी पॉइंट
रेस में मिले चैंपियनशिप पॉइंट	प्रति पॉइंट 1
जीत	+10 बोनस
पोडियम (P1–P3)	+5 बोनस
रेस पूरी नहीं की	−5

नियमों को कोड नहीं, डेटा के रूप में रखें, ताकि आप उन्हें सीज़न के बीच ट्यून कर सकें।

// scoring.js
export const RULES = Object.freeze({
  perPoint: 1,
  win: 10,
  podium: 5,
  dnf: -5,
});

/** Fantasy points for one rider's race result. Pure: same input, same output. */
export function scoreResult(result, rules = RULES) {
  let score = result.points * rules.perPoint;
  if (result.status === "FINISHED") {
    if (result.position === 1) score += rules.win;
    if (result.position <= 3) score += rules.podium;
  } else if (result.status === "DNF") {
    score += rules.dnf;
  }
  return score;
}

एक राउंड की स्कोरिंग

GET /races/seasons/{year}/round/{round}/results हर राइडर के लिए एक पंक्ति लौटाता है, जिसमें position, points, status, rider_name और एक स्थिर rider_id होते हैं। पंक्तियों को राइडर के आधार पर इंडेक्स करें और हर टीम के चुने राइडर्स का जोड़ निकालें:

// round.js
import { scoreResult } from "./scoring.js";

const HOST = "motogp-api-championship-data-statistics.p.rapidapi.com";
const headers = { "X-RapidAPI-Key": process.env.RAPIDAPI_KEY, "X-RapidAPI-Host": HOST };

async function get(path) {
  const res = await fetch(`https://${HOST}${path}`, { headers });
  if (!res.ok) throw new Error(`${path}: ${res.status}`);
  return (await res.json()).data;
}

export async function scoreRound(year, round, teams) {
  const results = await get(`/races/seasons/${year}/round/${round}/results?category=MOTOGP`);
  const byRider = new Map(results.map((r) => [r.rider_name, r]));

  return teams
    .map((team) => ({
      name: team.name,
      points: team.riders.reduce((sum, rider) => {
        const result = byRider.get(rider);
        return sum + (result ? scoreResult(result) : 0); // didn't start: 0
      }, 0),
    }))
    .sort((a, b) => b.points - a.points);
}

const league = [
  { name: "Late Brakers", riders: ["Marco Bezzecchi", "Raúl Fernández", "Fabio Di Giannantonio"] },
  { name: "Apex Hunters", riders: ["Marc Márquez", "Jorge Martín", "Pedro Acosta"] },
];

console.table(await scoreRound(2026, 1, league));

पढ़ने की सुविधा के लिए यह उदाहरण चुने गए राइडर्स को नाम से मिलाता है। प्रोडक्शन में, जब खिलाड़ी अपनी टीम बनाए तब GET /riders/seasons/{year} से हर चुने राइडर का rider_id सहेजें और नतीजों को rider_id से इंडेक्स करें।

सीज़न टोटल

हर पूरे हो चुके राउंड की स्कोरिंग करें और नतीजे जोड़ दें। जो राउंड अभी हुआ नहीं, वह ख़ाली सूची लौटाता है और सबको 0 अंक मिलते हैं:

export async function seasonTable(year, teams, lastRound) {
  const totals = new Map(teams.map((t) => [t.name, 0]));
  for (let round = 1; round <= lastRound; round++) {
    for (const { name, points } of await scoreRound(year, round, teams)) {
      totals.set(name, totals.get(name) + points);
    }
  }
  return [...totals].map(([name, points]) => ({ name, points })).sort((a, b) => b.points - a.points);
}

नतीजे आने के बाद हर राउंड के स्कोर अपने डेटाबेस में सहेज लें। राउंड के अंतिम होने के बाद स्कोर कभी नहीं बदलते, इसलिए API को सिर्फ़ सबसे नए राउंड के लिए कॉल करना होगा।

पिक लिस्ट और प्राइसिंग

• कौन चुना जा सकता है: GET /riders/seasons/{year}?category=MOTOGP सीज़न की ग्रिड सूचीबद्ध करता है।
• राइडर की क़ीमतें: इन्हें मौजूदा चैंपियनशिप (GET /standings/seasons/{year}/riders) से निकालें, ताकि लीडर्स पिछड़ने वालों से महँगे हों।