A real-time sports trivia platform that allows organizers to host interactive betting games during sporting events. Players can join rooms, place strategic bets on live events, and compete on a dynamic leaderboard.

QuickPicks Trivia enables organizers (bars, venues, or individuals) to create interactive trivia rooms for sports games. As events unfold during the game, players receive "Quick Pick" opportunities - time-limited betting events where they can wager points based on predicted outcomes. The scoring system rewards correct predictions with points proportional to the event's probability, creating strategic gameplay where players must balance risk and reward.

• Real-time Multiplayer: WebSocket-powered live gameplay with instant updates
• Strategic Wagering: Point-based betting system with risk/reward calculations
• Dynamic Leaderboards: Live score tracking and rankings
• Room-based Games: Multiple concurrent games with unique room codes
• Mobile-friendly: Responsive React Native Web interface
• Host Controls: Dedicated dashboard for game organizers

arena/
├── backend/                 # FastAPI WebSocket server
│   ├── main.py             # Main application entry point
│   ├── models.py           # Pydantic data models
│   ├── game_data.py        # Hardcoded game events and data
│   └── requirements.txt    # Python dependencies
├── frontend/               # React Native Web client
│   ├── src/
│   │   ├── screens/        # Application screens
│   │   ├── components/     # Reusable components
│   │   ├── services/       # API communication
│   │   └── router/         # Navigation routing
│   └── package.json        # Node.js dependencies
└── event_detection/        # Future: Live event detection

• FastAPI: High-performance Python web framework
• WebSocket: Real-time bidirectional communication
• Pydantic: Data validation and serialization
• Uvicorn: ASGI web server
• In-memory Storage: Dictionary-based game state management

• React Native for Web: Cross-platform UI framework
• React Native Paper: Material Design component library
• TypeScript: Type-safe JavaScript development
• React Router: Client-side navigation
• WebSocket Client: Real-time server communication

• Theme: Purple and dark grey color scheme (PrizePicks-inspired)
• Responsive Design: Mobile-first approach
• Component Library: React Native Paper for consistent UI

1. Organizer creates a room with:
   • Room name (venue/location)
   • Game name (e.g., "Lions vs Ravens @ 7pm")
   • Host name identification

1. Players join using room ID or browse available rooms
2. Enter display name (no authentication required)
3. Wait in lobby until host starts the game
4. Receive real-time event notifications
5. Place bets within time windows
6. View live leaderboard updates
7. See final rankings at game end

Each Quick Pick event includes:

• Question/Scenario: What players are betting on
• Answer Choices: 2-4 possible outcomes
• Odds: Probability-based scoring multipliers
• Timer: Limited response window
• Resolution: Automated outcome determination

• Players start with base points
• Wager amount calculated based on total events
• Correct answers earn points based on probability
• Incorrect answers lose wagered points
• Lower probability events offer higher rewards

• Python 3.8 or higher
• Node.js 16 or higher
• npm or yarn package manager

1. Navigate to the backend directory:

   cd arena/backend

2. Install Python dependencies:

   pip install -r requirements.txt

3. Start the FastAPI server:

   python main.py

The backend will run on http://localhost:8000

1. Navigate to the frontend directory:

   cd arena/frontend

2. Install Node.js dependencies:

   npm install

3. Start the development server:

   npm run start

The frontend will run on http://localhost:3000

For external access during development:

1. Install ngrok globally:

   npm install -g ngrok

2. Expose the backend (in a new terminal):

   ngrok http 8000

3. Expose the frontend (in another terminal):

   ngrok http 3000

4. Use the provided ngrok URLs to access the application remotely

• GET / - Health check
• GET /games - List available games
• POST /create-game - Create new room
• GET /room/{room_id} - Get room information
• POST /admin/start-demo/{room_id} - Admin game control

• WS /ws/{room_id} - Real-time game communication

• JOIN_ROOM - Player joins room
• START_GAME - Host initiates game
• NEW_EVENT - New question broadcast
• SUBMIT_ANSWER - Player submits bet
• ANSWERS_CLOSED - Betting window closed
• EVENT_RESOLVED - Results and scoring
• ROOM_UPDATE - General room state changes
• GAME_ENDED - Final results

• Room: Game container with players and events
• Player: Individual participant with score and bets
• Event: Individual betting opportunity
• GameState: Complete room state management
• WebSocketMessage: Real-time communication format

1. WAITING - Room created, accepting players
2. IN_PROGRESS - Game active, events occurring
3. COMPLETED - All events finished, final scores

• Hardcoded Events: Pre-defined question set for demo
• No Authentication: Name-based player identification
• In-Memory Storage: No persistent database
• Single Game Type: "Lions vs Ravens" demo only
• Manual Event Triggers: No live sports data integration

• game_data.py - Centralized event and game definitions
• Easy modification of questions, timers, and scoring
• Probability-based point calculations
• Extensible for future game types

1. Create a room as host
2. Join as multiple players (different browsers/devices)
3. Start game from host dashboard
4. Place bets during event windows
5. Observe real-time scoring and leaderboards
6. Verify final results

• Manual game start endpoint
• Room state inspection
• Event timing controls
• Debug logging throughout

• Real-time event detection from sports APIs
• Automated question generation
• Dynamic probability calculations
• Multiple concurrent games

• User authentication and profiles
• Persistent game history
• Advanced analytics dashboard
• Custom event creation tools
• Mobile native applications

• Database integration (PostgreSQL/MongoDB)
• Redis for session management
• Horizontal scaling architecture
• Cloud deployment configurations

This project was built for HackGT 12. For development:

1. Fork the repository
2. Create feature branches for new functionality
3. Test thoroughly with multiple concurrent users
4. Submit pull requests with clear descriptions

Real-time communication is essential for synchronized gameplay. The WebSocket architecture ensures all players see events and results simultaneously.

Enables rapid development with mobile-ready components while maintaining web compatibility.

Simplifies development and reduces infrastructure requirements for hackathon timeline.

Creates strategic depth where players must evaluate risk vs reward for each betting opportunity.

This project is developed for educational and hackathon purposes.