API trivia dla twórców gier

Po co to istnieje

Co zbudujesz

Stack - najpierw Expo, warianty silników niżej

• React Native + Expo SDK 54+ - npx create-expo-app, jedno repo na iOS / Android / web. Główny przewodnik.
• QuizBase REST API - jeden endpoint (GET /api/v1/questions/random), jeden nagłówek (X-API-Key), odpowiedź JSON z text, correctAnswer, incorrectAnswers.
• expo-audio (SDK 53+ - zastępuje przestarzałe expo-av) - gotowe efekty dźwiękowe przez hook useAudioPlayer. Dwie linie na dźwięk. Opcjonalne, ale dodaje szlifu w pięć minut.
• Bez backendu - publishable keys są bezpieczne dla CORS i dla bundla klienckiego. Proxy serwerowe jest opcjonalne, przydaje się tylko, gdy chcesz ukryć wzorce użycia albo dołożyć warstwę cache.
• Tryb offline - dołącz dump BY-SA z /data (pliki JSON; publikujemy go, by spełnić wymóg share-alike źródeł) do assets/ w grach mobilnych, gdzie sieć w runtime bywa zawodna.

Zbuduj mechanikę quizu krok po kroku

Siedem kroków, dwadzieścia minut. Pierwsze sześć daje grywalny ekran quizu na telefonie; siódmy dodaje opcjonalny multilang. Każdy krok to jeden akapit kontekstu plus kod do skopiowania. Jeśli twój stack to Unity / Godot / Roblox, przeskocz do sekcji wariantów stacku po kroku 2 - wywołanie REST jest identyczne, zmienia się tylko warstwa renderowania.

1. Krok 1
   Utwórz projekt Expo

   Postaw świeżą aplikację Expo. Szablon `default` daje React Native, TypeScript, routing oparty na plikach (Expo Router) i preinstalowane Expo SDK. Uruchomisz to na prawdziwym telefonie przez aplikację Expo Go, na symulatorze iOS, emulatorze Androida albo w przeglądarce - wszystko jedną komendą.

   bash

   npx create-expo-app@latest quiz-game --template default
   cd quiz-game
   pnpm install

2. Krok 2
   Zdobądź darmowy klucz API QuizBase

   Zarejestruj się na quizbase.runriva.com/pricing - wybierz darmowy plan (bez karty, 500 zapytań/dzień, każdy endpoint odblokowany). Wybierz **publishable key** (prefiks `qb_pk_…`, etykieta scope w dashboardzie `publishable`) - publishable keys są zaprojektowane do użycia po stronie klienta, w tym w klientach gier. Skopiuj go raz (pokazujemy go jawnie tylko raz), a potem dodaj do nowego pliku `.env.local`. Expo udostępnia każdą zmienną env z prefiksem `EXPO_PUBLIC_` w bundlu klienckim podczas builda.

   bash

   EXPO_PUBLIC_QUIZBASE_KEY=qb_pk_your_key_here

3. Krok 3
   Pobierz pytanie i wyrenderuj je

   Otwórz `app/index.tsx` i zastąp jego zawartość. Pojedynczy `useEffect` odpala się raz przy montażu, pobiera jedno losowe pytanie z QuizBase i renderuje je jako nagłówek `<Text>`. Kształt odpowiedzi to `{ data: [{ id, text, correctAnswer, incorrectAnswers }] }` - `correctAnswer` i `incorrectAnswers` wracają jako osobne pola, więc sam decydujesz, czy je przetasować (powinieneś, bo inaczej poprawna odpowiedź zawsze będzie ostatnia i gra rozwiązuje się sama).

   tsx

   import { useEffect, useState } from 'react';
   import { Text, View } from 'react-native';
   
   interface Question {
     id: string;
     text: string;
     correctAnswer: string;
     incorrectAnswers: string[];
   }
   
   export default function HomeScreen() {
     const [q, setQ] = useState<Question | null>(null);
   
     useEffect(() => {
       fetch(
         'https://quizbase.runriva.com/api/v1/questions/random' +
           '?lang=en&limit=1',
         {
           headers: {
             'X-API-Key': process.env.EXPO_PUBLIC_QUIZBASE_KEY!
           }
         }
       )
         .then((r) => r.json())
         .then((d) => setQ(d.data[0]));
     }, []);
   
     if (!q) return <Text>Loading…</Text>;
     return (
       <View style={{ flex: 1, padding: 24, paddingTop: 80 }}>
         <Text style={{ fontSize: 22, fontWeight: '600' }}>{q.text}</Text>
       </View>
     );
   }

4. Krok 4
   Wyrenderuj cztery opcje odpowiedzi jako przyciski Pressable

   Wymieszaj `correctAnswer` z trzema `incorrectAnswers`, przetasuj raz na pytanie (`useMemo` kluczowany na `question.id`, żeby kolejność nie zmieniała się między re-renderami) i wyrenderuj jako komponenty `Pressable`. Pressable to prymityw React Native dla obszarów dotykowych - z marszu obsługuje cele dotyku, efekt ripple na Androidzie i reakcję wizualną na iOS.

   tsx

   import { useEffect, useMemo, useState } from 'react';
   import { Pressable, Text, View } from 'react-native';
   
   // …
   
   const choices = useMemo(() => {
     if (!q) return [];
     return [q.correctAnswer, ...q.incorrectAnswers]
       .map((value) => ({ value, sort: Math.random() }))
       .sort((a, b) => a.sort - b.sort)
       .map(({ value }) => value);
   }, [q?.id]);
   
   return (
     <View style={{ flex: 1, padding: 24, paddingTop: 80 }}>
       <Text style={{ fontSize: 22, fontWeight: '600' }}>{q.text}</Text>
       {choices.map((c) => (
         <Pressable
           key={c}
           style={{
             marginTop: 12,
             padding: 16,
             backgroundColor: '#eee',
             borderRadius: 8
           }}
         >
           <Text style={{ fontSize: 16 }}>{c}</Text>
         </Pressable>
       ))}
     </View>
   );

5. Krok 5
   Obsłuż tapnięcia odpowiedzi z natychmiastowym feedbackiem

   Śledź, którą opcję tapnął użytkownik. Porównaj ją z `q.correctAnswer`. Pokoloruj tapnięty przycisk na zielono, gdy poprawnie, na czerwono, gdy błędnie. Po jednym tapnięciu zablokuj wszystkie przyciski - gracz nie powinien móc zmienić odpowiedzi po jej zatwierdzeniu (bez tego gra trivia przestaje wydawać się uczciwa). To najmniejsza porcja stanu, która zamienia ekran w grę.

   tsx

   const [selected, setSelected] = useState<string | null>(null);
   
   {choices.map((c) => {
     const isThis = selected === c;
     const isCorrect = c === q.correctAnswer;
     return (
       <Pressable
         key={c}
         disabled={selected !== null}
         onPress={() => setSelected(c)}
         style={{
           marginTop: 12,
           padding: 16,
           backgroundColor: isThis
             ? isCorrect ? '#c8f7c5' : '#f7c5c5'
             : '#eee',
           borderRadius: 8
         }}
       >
         <Text style={{ fontSize: 16 }}>{c}</Text>
       </Pressable>
     );
   })}
   {selected && (
     <Text style={{ marginTop: 16, fontSize: 16 }}>
       {selected === q.correctAnswer
         ? '✓ Correct!'
         : `✗ Wrong — the answer was ${q.correctAnswer}.`}
     </Text>
   )}

6. Krok 6
   Dodaj efekty dźwiękowe z expo-audio

   Z dźwiękiem gry trivia są trzy razy przyjemniejsze. `expo-audio` (SDK 53+ - zastąpił przestarzałe `expo-av`) jest w domyślnym szablonie Expo. Doinstaluj raz, jeśli go brakuje: `npx expo install expo-audio`. Dwa pliki MP3 wolne od opłat (dzwonek poprawnej, brzęczyk błędnej) leżą w `assets/sounds/` - z Freesound, ZapSplat albo z własnej sesji w GarageBand. Hook `useAudioPlayer` zwraca obiekt playera; po każdej odpowiedzi wywołaj `player.play()`.

   tsx

   import { useAudioPlayer } from 'expo-audio';
   
   // Top of component — useAudioPlayer is a hook, must be at top level
   const correctPlayer = useAudioPlayer(require('../assets/sounds/correct.mp3'));
   const wrongPlayer = useAudioPlayer(require('../assets/sounds/wrong.mp3'));
   
   useEffect(() => {
     if (!selected) return;
     const player = selected === q.correctAnswer ? correctPlayer : wrongPlayer;
     player.seekTo(0);
     player.play();
   }, [selected]);

7. Krok 7
   Dodaj przełącznik języków (opcjonalnie)

   Gracze uwielbiają widzieć w grze trivia swój ojczysty język. Dodanie obsługi języków to jedna dodatkowa zmienna stanu plus `?lang=` przy fetchu. QuizBase obsługuje obecnie `en` (angielski) i `pl` (polski), a więcej języków dochodzi na życzenie - aktualna lista jest zawsze pod `GET /api/v1/languages`. Liczba pytań różni się między językami (angielski ma najszersze pokrycie), więc połączenie `?lang=` z wąskim filtrem `?category=` może zwrócić mniej wyników, niż się spodziewasz - jeśli budujesz wybór języka, sprawdź to wcześniej przez `GET /api/v1/languages`.

   tsx

   const [lang, setLang] = useState<'en' | 'pl'>('en');
   
   // in fetch URL:
   `https://quizbase.runriva.com/api/v1/questions/random?lang=${lang}&limit=1`
   
   // in JSX, above question:
   <View style={{ flexDirection: 'row', gap: 8 }}>
     {(['en', 'pl'] as const).map((l) => (
       <Pressable
         key={l}
         onPress={() => { setLang(l); setSelected(null); }}
         style={{ padding: 8 }}
       >
         <Text style={{ fontWeight: lang === l ? 'bold' : 'normal' }}>
           {l.toUpperCase()}
         </Text>
       </Pressable>
     ))}
   </View>

Kompletna aplikacja - jeden plik, gotowy do skopiowania

Pełny ekran quizu Expo z wyborem języka, licznikiem punktów, efektami dźwiękowymi i przyciskiem Next. Wrzuć go do `app/index.tsx`, dodaj `EXPO_PUBLIC_QUIZBASE_KEY` do `.env.local`, wrzuć dwa MP3 do `assets/sounds/` i uruchom `pnpm start`.

import { useAudioPlayer } from 'expo-audio';
import { useEffect, useMemo, useState } from 'react';
import { Pressable, Text, View } from 'react-native';

interface Question {
  id: string;
  text: string;
  correctAnswer: string;
  incorrectAnswers: string[];
}

const API = 'https://quizbase.runriva.com/api/v1/questions/random';
const KEY = process.env.EXPO_PUBLIC_QUIZBASE_KEY!;

async function fetchQuestion(lang: string): Promise<Question> {
  const r = await fetch(`${API}?lang=${lang}&limit=1`, {
    headers: { 'X-API-Key': KEY }
  });
  const d = await r.json();
  return d.data[0];
}

export default function HomeScreen() {
  const [q, setQ] = useState<Question | null>(null);
  const [selected, setSelected] = useState<string | null>(null);
  const [lang, setLang] = useState<'en' | 'pl'>('en');
  const [score, setScore] = useState({ right: 0, wrong: 0 });

  // expo-audio: hooks at top level, replay via seekTo(0) + play()
  const correctPlayer = useAudioPlayer(require('../assets/sounds/correct.mp3'));
  const wrongPlayer = useAudioPlayer(require('../assets/sounds/wrong.mp3'));

  useEffect(() => { void fetchQuestion(lang).then(setQ); }, [lang]);

  useEffect(() => {
    if (!selected || !q) return;
    const correct = selected === q.correctAnswer;
    setScore((s) => correct ? { ...s, right: s.right + 1 } : { ...s, wrong: s.wrong + 1 });
    const player = correct ? correctPlayer : wrongPlayer;
    player.seekTo(0);
    player.play();
  }, [selected]);

  const choices = useMemo(() => {
    if (!q) return [];
    return [q.correctAnswer, ...q.incorrectAnswers]
      .map((value) => ({ value, sort: Math.random() }))
      .sort((a, b) => a.sort - b.sort)
      .map(({ value }) => value);
  }, [q?.id]);

  if (!q) return <Text style={{ padding: 24 }}>Loading…</Text>;

  return (
    <View style={{ flex: 1, padding: 24, paddingTop: 80 }}>
      <View style={{ flexDirection: 'row', gap: 12, marginBottom: 16 }}>
        {(['en', 'pl'] as const).map((l) => (
          <Pressable key={l} onPress={() => { setLang(l); setSelected(null); }}>
            <Text style={{ fontWeight: lang === l ? 'bold' : 'normal' }}>{l.toUpperCase()}</Text>
          </Pressable>
        ))}
        <Text style={{ marginLeft: 'auto' }}>
          {score.right}/{score.right + score.wrong}
        </Text>
      </View>
      <Text style={{ fontSize: 22, fontWeight: '600' }}>{q.text}</Text>
      {choices.map((c) => {
        const isThis = selected === c;
        const isCorrect = c === q.correctAnswer;
        return (
          <Pressable
            key={c}
            disabled={selected !== null}
            onPress={() => setSelected(c)}
            style={{
              marginTop: 12, padding: 16,
              backgroundColor: isThis
                ? isCorrect ? '#c8f7c5' : '#f7c5c5'
                : '#eee',
              borderRadius: 8
            }}
          >
            <Text style={{ fontSize: 16 }}>{c}</Text>
          </Pressable>
        );
      })}
      {selected && (
        <Pressable
          onPress={() => { setSelected(null); void fetchQuestion(lang).then(setQ); }}
          style={{ marginTop: 16, padding: 16, backgroundColor: '#222', borderRadius: 8 }}
        >
          <Text style={{ color: '#fff', fontSize: 16, textAlign: 'center' }}>Next question</Text>
        </Pressable>
      )}
    </View>
  );
}

Pobierz darmowy klucz API na /pricing - bez karty kredytowej.

Niech napisze to AI - Cursor, Claude Code, Copilot

Jesteś twórcą gier z weekendowym prototypem do wydania. Jasne, że chcesz, żeby AI napisało warstwę danych. Oto trzy prompty, które wklejasz do Cursora, Claude Code albo GitHub Copilota - każdy daje działający ekran quizu w niecałe dwie minuty. Prompty zawierają dokładny kształt odpowiedzi API, więc AI nie zhalucynuje `question.choices` zamiast `question.incorrectAnswers`.

Build an Expo (React Native) trivia quiz game using the QuizBase API.

Stack: Expo SDK 54+ + TypeScript + Expo Router (default template). Single screen in app/index.tsx.

API call:
  GET https://quizbase.runriva.com/api/v1/questions/random?lang=en&limit=1
  Header: X-API-Key: <process.env.EXPO_PUBLIC_QUIZBASE_KEY>

Response shape:
{
  "data": [{
    "id": "uuid",
    "text": "What is...?",
    "correctAnswer": "Answer",
    "incorrectAnswers": ["Wrong 1", "Wrong 2", "Wrong 3"]
  }]
}

Requirements:
1. Fetch one question on mount + on language change.
2. Render question and four answer choices as <Pressable> buttons (shuffle correct + incorrect with useMemo keyed on question.id).
3. Tap a choice → highlight it green (correct) or red (wrong), disable all buttons, show feedback.
4. Score tracker (right/total) in the top-right corner.
5. Language picker for en/pl (the languages QuizBase currently supports) — refetches on switch.
6. "Next question" button at the bottom after answering.
7. Sound effects on answer — use `expo-audio` (SDK 53+, replaces deprecated `expo-av`): import { useAudioPlayer } from 'expo-audio', call hook at top level for both correct.mp3 and wrong.mp3 in assets/sounds/, then player.seekTo(0) + player.play() in the answer effect.
8. Loading state ("Loading…") before first question arrives.

Use TypeScript types for the Question shape. Use React Native primitives only (View, Text, Pressable). One extra dep: `expo-audio` (npx expo install expo-audio).

Build an Expo (React Native) trivia quiz game using the QuizBase API.

Stack: Expo SDK 54+ + TypeScript + Expo Router (default template). Single screen in app/index.tsx.

API call:
  GET https://quizbase.runriva.com/api/v1/questions/random?lang=en&limit=1
  Header: X-API-Key: <process.env.EXPO_PUBLIC_QUIZBASE_KEY>

Response shape:
{
  "data": [{
    "id": "uuid",
    "text": "What is...?",
    "correctAnswer": "Answer",
    "incorrectAnswers": ["Wrong 1", "Wrong 2", "Wrong 3"]
  }]
}

Requirements:
1. Fetch one question on mount + on language change.
2. Render question and four answer choices as <Pressable> buttons (shuffle correct + incorrect with useMemo keyed on question.id).
3. Tap a choice → highlight it green (correct) or red (wrong), disable all buttons, show feedback.
4. Score tracker (right/total) in the top-right corner.
5. Language picker for en/pl (the languages QuizBase currently supports) — refetches on switch.
6. "Next question" button at the bottom after answering.
7. Sound effects on answer — use `expo-audio` (SDK 53+, replaces deprecated `expo-av`): import { useAudioPlayer } from 'expo-audio', call hook at top level for both correct.mp3 and wrong.mp3 in assets/sounds/, then player.seekTo(0) + player.play() in the answer effect.
8. Loading state ("Loading…") before first question arrives.

Use TypeScript types for the Question shape. Use React Native primitives only (View, Text, Pressable). One extra dep: `expo-audio` (npx expo install expo-audio).

// Expo trivia quiz screen powered by the QuizBase API
// API: GET https://quizbase.runriva.com/api/v1/questions/random?lang=en&limit=1
// Auth: X-API-Key header from process.env.EXPO_PUBLIC_QUIZBASE_KEY
// Response shape: { data: [{ id, text, correctAnswer, incorrectAnswers: string[] }] }
//
// Requirements:
// - Fetch question on mount with useEffect
// - Shuffle correct + incorrect into four <Pressable> buttons (useMemo keyed on question.id)
// - On tap: highlight green/red, disable all, show feedback text
// - "Next question" button refetches and resets
// - Score tracker (right/total)
// - Language picker for en/pl (the languages QuizBase currently supports)
// - Sound effects via expo-audio (useAudioPlayer hook, NOT deprecated expo-av)
import { useEffect, useMemo, useState } from 'react';
import { Pressable, Text, View } from 'react-native';

interface Question {
  id: string;
  text: string;
  correctAnswer: string;
  incorrectAnswers: string[];
}

export default function HomeScreen() {
  // Press Tab and let Copilot write the rest
}

MCP - tylko na czas projektowania (pomiń, jeśli wydajesz)

Dla twórców gier MCP to głównie narzędzie na czas projektowania - twój agent w Cursorze albo Claude Code dostaje narzędzia QuizBase jako natywne możliwości podczas budowania gry, ale gotowa gra i tak używa REST w runtime (szybciej, mniejszy bundle, prostsze debugowanie). Jeśli budujesz agenta opakowującego grę (bot trivia na Twitcha, Discord Activity, Custom GPT), zajrzyj na `/use-cases/ai-agent-builders` po pełny setup MCP.

• Dla twórców gier MCP to głównie narzędzie na czas projektowania - twój agent w Cursorze albo Claude Code dostaje quizbase_random i quizbase_categories jako natywne możliwości podczas budowania gry. Gotowa gra i tak woła REST w runtime (szybciej, prościej, bez klienta MCP do wpakowania w build mobilny).
• Pełne szczegóły MCP (12 narzędzi, 3 zasobów, 4 promptów) znajdziesz na stronie AI Agent Builders. Ta sekcja daje setup na czas projektowania; przejdź na tamtą stronę, jeśli budujesz agenta, który używa trivia jako warstwy wiedzy.

{
  "mcpServers": {
    "quizbase": {
      "url": "https://quizbase.runriva.com/mcp",
      "headers": {
        "Authorization": "Bearer qb_pk_your_key_here"
      }
    }
  }
}

claude mcp add quizbase \
  --transport http \
  --url https://quizbase.runriva.com/mcp \
  --header "Authorization: Bearer qb_pk_your_key_here"

# verify
claude mcp list

Use REST at runtime in your shipping game.
Use MCP at design time in Cursor / Claude Code to scaffold features.
Use MCP at runtime only if you are building an AI agent that wraps the game (Twitch trivia bot, Discord activity bot, ChatGPT Custom GPT).

Zobacz to w akcji

Inne stacki - to samo API, inny silnik

Expo + React Native to najłatwiejsze wejście, ale nie jedyne. Wywołanie QuizBase jest identyczne we wszystkich silnikach - zmienia się tylko warstwa renderowania. Oto trzy kolejne warianty gotowe do skopiowania.

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

[System.Serializable]
public class Question {
    public string id;
    public string text;
    public string correctAnswer;
    public string[] incorrectAnswers;
}

[System.Serializable]
public class QuestionResponse { public Question[] data; }

public class TriviaFetcher : MonoBehaviour {
    public string apiKey = "qb_pk_your_key_here";

    public IEnumerator FetchQuestion(System.Action<Question> onLoaded) {
        string url = "https://quizbase.runriva.com/api/v1/questions/random?lang=en&limit=1";
        using (UnityWebRequest req = UnityWebRequest.Get(url)) {
            req.SetRequestHeader("X-API-Key", apiKey);
            yield return req.SendWebRequest();
            if (req.result == UnityWebRequest.Result.Success) {
                QuestionResponse resp = JsonUtility.FromJson<QuestionResponse>(req.downloadHandler.text);
                onLoaded(resp.data[0]);
            } else {
                Debug.LogError("QuizBase fetch failed: " + req.error);
            }
        }
    }
}

extends Node

const API := "https://quizbase.runriva.com/api/v1/questions/random?lang=en&limit=1"
const KEY := "qb_pk_your_key_here"

@onready var http: HTTPRequest = $HTTPRequest

func fetch_question() -> void:
    http.request_completed.connect(_on_response, CONNECT_ONE_SHOT)
    var headers := ["X-API-Key: " + KEY]
    var err := http.request(API, headers, HTTPClient.METHOD_GET)
    if err != OK:
        push_error("Request failed to start: " + str(err))

func _on_response(result: int, code: int, _h: PackedStringArray, body: PackedByteArray) -> void:
    if result != HTTPRequest.RESULT_SUCCESS or code != 200:
        push_error("Fetch failed: code=" + str(code))
        return
    var data: Dictionary = JSON.parse_string(body.get_string_from_utf8())
    var question = data["data"][0]
    print("Q: ", question["text"])
    print("Correct: ", question["correctAnswer"])
    print("Wrong: ", question["incorrectAnswers"])

local HttpService = game:GetService("HttpService")

local API = "https://quizbase.runriva.com/api/v1/questions/random?lang=en&limit=1"
local KEY = "qb_pk_your_key_here"

local function fetchQuestion()
    local success, response = pcall(function()
        return HttpService:RequestAsync({
            Url = API,
            Method = "GET",
            Headers = { ["X-API-Key"] = KEY }
        })
    end)
    if not success or response.StatusCode ~= 200 then
        warn("QuizBase fetch failed:", response and response.StatusCode)
        return nil
    end
    local data = HttpService:JSONDecode(response.Body)
    return data.data[1]
end

local q = fetchQuestion()
if q then
    print("Q:", q.text)
    print("Correct:", q.correctAnswer)
    print("Wrong:", table.concat(q.incorrectAnswers, " | "))
end

Pułapki - na których łatwo się potknąć

Sześć haczyków, które widzimy w realnych zgłoszeniach od twórców gier, z konkretną poprawką dla każdego. Jeśli na któryś trafisz, ta sekcja oszczędzi ci sesji debugowania.

• Sieć mobilna bywa zawodna - co się dzieje, gdy `fetch` padnie w trakcie gry?

  Trzy warstwy obrony. (1) **Pobierz batch z wyprzedzeniem** - wywołaj ?limit=20 raz przy starcie aplikacji, trzymaj w cache stanu i serwuj z cache między rundami. (2) **Łap błędy i ponawiaj z wykładniczym backoffem** we wrapperze fetcha. (3) **Dołącz offline dump BY-SA** z /data do assets/ dla prawdziwego trybu offline - gdy sieci nie ma, sięgnij po lokalny odczyt JSON. Strategia zależy od twojej grupy: użytkownik w metrze potrzebuje offline, a użytkownik szkolnego Wi-Fi potrzebuje ponawiania.

• Liczba pytań różni się między językami - `?lang=ja&category=animals` zwraca 5 pytań, nie 50.

  Angielski ma najgłębsze pokrycie; mniejsze języki mają mniej pytań na kategorię. Dwie poprawki: (1) sprawdź wcześniej przez GET /api/v1/languages, które zwraca liczby per język - i pokaż graczowi tylko języki mające ≥50 pytań dla wybranej kategorii. (2) poszerz filtr - zrezygnuj z ?category= w małym języku albo użyj ?topics_any=, żeby połączyć kilka powiązanych topików.

• Niektóre pytania są za trudne dla dzieci - moi 8-latkowie ciągle przegrywają.

  Filtruj po ?difficulty=easy ORAZ po kategorii (?category=animals, ?category=sports, ?category=geography są przyjazne dzieciom; ?category=politics już nie). Pobierz listę kategorii przez GET /api/v1/categories i ułóż białą listę dla trybu dziecięcego. Dataset udostępnia też filtrowanie ?topics_any= - wyselekcjonowane topiki w rodzaju safe-for-kids mogą dojść w przyszłości.

• Anti-cheat: przechowywanie odpowiedzi po stronie klienta jest trywialne do obejścia.

  Dla gry casual to zwykle w porządku - gracze, którzy oszukują w solowej trivia, oszukują samych siebie. Przy konkurencyjnej grze wieloosobowej z leaderboardami albo nagrodami owiń wywołanie QuizBase w mały proxy serwerowy (darmowy plan Cloudflare Workers, Vercel Functions, Supabase Edge Functions), który zwraca pytanie bez poprawnej odpowiedzi; poprawną odpowiedź odsyła dopiero, gdy gracz prześle swój strzał. Kosztuje ~50 linii backendu, a likwiduje całą powierzchnię ataku.

• Pakowanie zasobów: chcę dump BY-SA w bundlu mobilnym, ale jest za duży.

  Pełny dump BY-SA to mniej więcej 200 MB w dziewięciu plikach JSON (wszystkie języki, wszystkie metadane). Do bundli mobilnych prawie nigdy nie potrzebujesz aż tyle - wybierz języki i kategorie, które twoja gra obejmuje. Dump jest przygotowany pod selektywny import: byasa//.jsonl to JSONL (jedno pytanie na linię), więc możesz przefiltrować go grep-em i spakować tylko to, czego potrzebujesz. Typowy wycinek mobilny: 5-10 MB.

• Trafiony rate limit (HTTP 429) podczas playtestu z wieloma urządzeniami.

  Darmowy plan to 500 zapytań/dzień na konto QuizBase (nie na urządzenie - twój klucz jest współdzielony między buildami). Przy playteście na pięciu urządzeniach po 50 pytań na urządzenie masz 250 zapytań w piętnaście minut, więc w porządku. Na publiczną betę przejdź na plan Indie (10 000/dzień) albo dołóż warstwę cache: pobierz 20 pytań na sesję i trzymaj w cache stanu. Odpowiedź 429 zawiera nagłówek Retry-After - twój wrapper fetcha powinien go uszanować.

Najczęściej zadawane pytania

Czy mogę spakować pytania offline, żeby gra działała bez internetu?

Tak. Pobierz dump BY-SA z quizbase.runriva.com/data - pliki JSON, jeden na język na kategorię; publikujemy go, by spełnić wymóg share-alike źródeł CC-BY-SA, i odświeżamy co jakiś czas. Spakuj wycinek (języki i kategorie, które twoja gra obejmuje) do folderu assets aplikacji mobilnej i czytaj z dysku w runtime. Licencja dumpa to CC BY-SA 4.0, więc dodaj ekran atrybucji (z linkiem zwrotnym do quizbase.runriva.com i wymienieniem źródeł takich jak OpenTDB, OpenTriviaQA, MKQA), a będziesz zgodny komercyjnie.

Czy mogę użyć tego w komercyjnej grze?

Tak. Hostowane API jest licencjonowane komercyjnie zgodnie z twoim planem subskrypcji (darmowy plan pokrywa do 500 zapytań/dzień, płatne plany skalują wyżej). Bazowy dataset (dump BY-SA) jest na licencji Creative Commons Attribution-ShareAlike 4.0 - wolny do dowolnego użytku, w tym komercyjnego, z atrybucją. Każda odpowiedź API zawiera też obiekt `attribution` per rekord, więc jeśli chcesz, możesz pokazać źródło przy każdym pytaniu.

Jak utrzymać niskie zużycie danych mobilnych?

Trzy wzorce: (1) **Batch prefetch** - `?limit=20` raz na sesję gry, cache w stanie, bez fetcha na każde pytanie. (2) **Kompresja w transmisji** - `Accept-Encoding: gzip` (większość klientów HTTP robi to domyślnie). (3) **Spakuj dump BY-SA z wyprzedzeniem** - dla aplikacji offline-first dump w `assets/` całkowicie pomija sieć. Typowy batch 20 pytań to ~8 KB po gzipie.

Jak zsynchronizować stan quizu wieloosobowego między urządzeniami w czasie rzeczywistym?

Użyj małej usługi realtime do synchronizacji stanu - Pusher, Ably, Liveblocks albo Supabase Realtime - wszystkie mają darmowe plany. Wzorzec: jedno urządzenie pobiera pytanie z QuizBase i rozgłasza je do pozostałych przez twój kanał realtime, wszystkie urządzenia renderują to samo pytanie, każde wysyła swoją odpowiedź kanałem, a host liczy punkty. Część po stronie QuizBase to jeden fetch na rundę; cała złożoność produktu siedzi w warstwie realtime.

Roblox Studio - czy muszę coś specjalnie włączyć?

Tak - przejdź do Home → Game Settings → Security → włącz 'Allow HTTP Requests'. Bez tego `HttpService:RequestAsync` zwraca błąd w opublikowanych experience'ach. Testowanie w Studio działa bez tego, ale produkcja już nie. To domyślne zabezpieczenie Roblox, nie kaprys QuizBase.

Jakie wersje Unity / Godot / Roblox są wspierane?

Próbki kodu testujemy na **Unity 6 LTS (wydanie 2024)**, **Godot 4.3**, **Roblox Studio 2026** i **Expo SDK 54+**. Starsze wersje też działają, ale dokładna składnia (konstruktory `UnityWebRequest`, sygnały węzła `HTTPRequest`, nazwy metod `HttpService`) może się różnić - sprawdź oficjalne docsy dla swojej wersji silnika. Kontrakt REST API jest identyczny we wszystkich silnikach: jeden URL, jeden nagłówek, odpowiedź JSON.

Czy dataset pytań jest bezpieczny dla dzieci?

Częściowo. Dataset obejmuje ogólną trivia, w tym politykę, rozrywkę dla dorosłych i historyczną przemoc (wojna, konflikt). Do gry dla dzieci filtruj do bezpiecznych kategorii: `?category=animals`, `?category=sports`, `?category=geography`, `?category=science-and-nature`. Połącz to z `?difficulty=easy`. Rozważamy wprowadzenie w przyszłości wyselekcjonowanego sluga topika `safe-for-kids`. Jeśli natkniesz się na nieodpowiednią treść, każde pytanie ma endpoint `/report` - zgłoś je, a my zajmiemy się tym w przeglądzie treści.

Czy mogę dostać wstępnie wyselekcjonowane paczki topików (historia, nauka, sport)?

Tak, przez filtrowanie `?topics_any=`. Kurujemy ~100 topików na język (top po liczbie pytań) - slugi takie jak `roman-history`, `cellular-biology`, `nba-basketball`. Przeglądaj je przez `GET /api/v1/topics?lang=en`. Możesz też filtrować surowe tagi przez `?tags=python,django` dla bardzo specyficznych nisz.

Jak zgłosić błędną odpowiedź lub złe tłumaczenie z wnętrza mojej gry?

Użyj `POST /api/v1/report` z id pytania, kategorią (`wrong-answer`, `bad-translation`, `offensive`, `outdated`, `other`) i opisem w wolnym tekście. Podepnij przycisk "Report this question" w ustawieniach albo na ekranie po grze. Zgłoszenia trafiają do naszej kolejki moderacji i zasilają przegląd treści. Nie wymagamy żadnych danych osobowych.

Gdzie szukać pomocy, jeśli coś się zepsuje?

Docsy na quizbase.runriva.com/docs zawierają quickstart, pełną referencję API, przewodniki po SDK i troubleshooting per silnik. Przy błędach API lub platformy użyj przycisku "Report a problem" w dashboardzie - automatycznie dołącza twój request id i kontekst klucza. Strona statusu jest pod /status, jeśli podejrzewasz awarię. Średni czas odpowiedzi to poniżej 48 godzin w dni robocze.

Dziesięć gier do wydania - wybierz jedną, zbuduj w ten weekend

Masz mechanikę trivia. Oto dziesięć kierunków na grę, które wychodzą poza 'tapnij, by odpowiedzieć' - każdy na tyle mały, by sprototypować go w weekend, i na tyle inny, że wynik jest osobnym produktem.

1. 1. Tryb daily challenge (te same pięć pytań dla wszystkich)

   Użyj daty jako deterministycznego seeda losowego fetcha. Ta sama data, te same pięć pytań na całym świecie - idealne pod hasła w stylu 'rywalizuj ze znajomymi', leaderboardy i wątki na Reddicie. Zmiana w jednej linii: wyprowadź seed z `new Date().toISOString().slice(0, 10)`.

2. 2. Wycieczka klasowa w Roblox Artykuł →

   Experience w Roblox Studio, w którym gracze dołączają do 'klasy', moderator wybiera topik, a pytania pojawiają się na ścianie. `HttpService` woła QuizBase, `TextLabel` renderuje pytanie, `TextButton` to opcje. Szkoły to uwielbiają - a monetyzacja w Roblox jest dobrze ogarnięta.

3. 3. Mobilna gra słowna w Unity z rundami na czas

   30 sekund na pytanie, licz streak, trzy błędy z rzędu resetują grę. Unity 6 LTS świetnie radzi sobie z UI Toolkit. `UnityWebRequest.Get` do wywołania API. To mechanika, która naprawdę uzależnia w aplikacjach trivia - presja czasu plus ryzyko utraty serii to haczyk.

4. 4. Wieloosobowa aktywność na Discordzie (w stylu Kahoot) Artykuł →

   Discord Activities API pozwala osadzić grę web w kanale głosowym. QuizBase REST + WebSockety (darmowy plan Pusher / Ably) do synchronizacji + mała tabela wyników. Kanały Discorda z aktywną publiką graczy to pochłaniają - presja społeczna przy odsłonięciu odpowiedzi to cała frajda.

5. 5. Cotygodniowy bot trivia na r/gamedev (Reddit) Artykuł →

   Bot Reddita, który publikuje cotygodniowy wątek trivia na r/gamedev (lub dowolnym subreddicie). Wtorkowy post = pytanie, czwartkowy post = odsłona + leaderboard. Reddit API + QuizBase API + cron na VPS-ie za 5 USD. Darmowy marketing dla twojej większej gry.

6. 6. Wieloosobowe PvP w czasie rzeczywistym (przeglądarka) Artykuł →

   Dwóch graczy, to samo pytanie pokazane obu, rundę wygrywa ten, kto pierwszy tapnie poprawną odpowiedź. PixiJS lub Phaser do renderowania, WebSockety do synchronizacji (darmowy plan Pusher / Ably / Liveblocks). Cała złożoność tkwi w warstwie realtime - treść trivia jest już gotowa.

7. 7. Generator PDF na rodzinny wieczór gier

   Narzędzie web generujące drukowalny PDF z 30 pytaniami trivia na rodzinny wieczór gier. Użytkownik wybiera kategorię i trudność, serwer pobiera pytania, generuje PDF przez `pdfkit` (Node) albo `puppeteer`. Pobieraj 3 USD za paczkę, wydaj w weekend.

8. 8. Doświadczenie trivia w VR (Meta Quest)

   Aplikacja VR w Unity, w której pytania unoszą się w przestrzeni 3D, a gracze chwytają odpowiedź śledzeniem dłoni. Unity XR Toolkit + QuizBase REST. Sklep Quest ma mniejszą pulę gier edukacyjnych niż mobile - łatwiej się wybić.

9. 9. Interaktywna nakładka na stream Twitcha Artykuł →

   Streamer wyświetla pytanie na ekranie przez OBS browser source, widzowie odpowiadają na czacie, a bot liczy punkty i ogłasza zwycięzcę. Twitch chat API + Node + QuizBase. Trafia w metrykę zaangażowania, na której streamerom naprawdę zależy (skok wiadomości na minutę przy każdej rundzie).

10. 10. Edukacyjna aplikacja mobilna z leaderboardami (ta oczywista, zrobiona dobrze)

    Klasyczna edukacyjna gra quizowa, ale z QuizBase pomijasz fazę 'zbierz bank pytań' i wydajesz w dwa tygodnie zamiast w dwa kwartały. iOS + Android przez Expo, leaderboard na darmowym planie Supabase, monetyzacja przez subskrypcję in-app odblokowującą zaawansowane kategorie.

Co zbudować dalej

Masz działający ekran quizu. Oto dokąd iść dalej - każdy link to konkretny następny krok, nie mgliste "przejrzyj nasze docsy".

• Pełna referencja REST API - każdy filtr, każdy parametr →

  Slugi kategorii, kody języków, enumy trudności, filtrowanie po tagach, filtrowanie po topikach, paginacja. Wszystko, po czym twoja gra mogłaby chcieć filtrować.

• Dump BY-SA (do offline bundli mobilnych) →

  Publikacja share-alike, którą wydajemy, by spełnić wymóg źródeł CC-BY-SA. Pliki JSON na język na kategorię - spakuj wycinek do assetów mobilnych pod tryb offline.

• TypeScript SDK z pełnoprawnymi typami →

  `@quizbase/client` - autouzupełnianie na każdym polu, każdej odpowiedzi, każdym kodzie błędu. Działa w Expo i backendach gier na Node.

• AI Agent Builders - MCP dla gier opakowanych w agenta →

  Budujesz bota trivia na Twitcha, Discord Activity albo Custom GPT na ChatGPT wokół swojej gry? Ta strona to tutorial MCP-first.

• Cennik i limity →

  Darmowy plan (500 zapytań/dzień). Plan Indie (9 USD/mc, 10 000/dzień), gdy gra wychodzi. Plan Pro (29 USD/mc, 100 000/dzień), gdy staje się viralem.