#3487 Google Gemini 2.5 Pro: Sports Events, Play-by-Play Wagering

#3487 I want to create an app that let's two or more people watching a sports event bet on the outcome of the next play. Examples for baseball: pitch, batter, result of play; football: offensive play and defensive result; basketball: two- or three-point shot, result of shot, rebounder, following action.

Of course. I can help you build a real-time, multi-user "prop bet" application for sporting events. This app will allow you and your friends to create a game room, choose a sport, and place friendly wagers on the outcomes of individual plays.

Here is a complete React application that uses Firebase Firestore for real-time data synchronization. This will allow all players in a game room to see bets and score updates instantly.

import React, { useState, useEffect, useMemo } from 'react';

import { initializeApp } from 'firebase/app';

import { getAuth, signInAnonymously, onAuthStateChanged, signInWithCustomToken } from 'firebase/auth';

import { getFirestore, doc, setDoc, getDoc, onSnapshot, updateDoc, arrayUnion, collection, addDoc } from 'firebase/firestore';

import { ArrowLeft, Users, PlusCircle, Share2, Award, ChevronsRight, Crown } from 'lucide-react';

// --- Firebase Configuration ---

// This configuration is provided by the environment.

const firebaseConfig = typeof __firebase_config !== 'undefined' ? JSON.parse(__firebase_config) : {};

const appId = typeof __app_id !== 'undefined' ? __app_id : 'default-prop-bet-app';

// --- Initialize Firebase ---

const app = initializeApp(firebaseConfig);

const auth = getAuth(app);

const db = getFirestore(app);

// --- Sport Definitions ---

const SPORTS = {

baseball: {

bets: [

{ id: 'pitch_type', label: 'Pitch Type', options: ['Fastball', 'Curveball', 'Slider', 'Changeup', 'Other'] },

{ id: 'pitch_result', label: 'Pitch Result', options: ['Ball', 'Called Strike', 'Swinging Strike', 'Foul Ball', 'In Play'] },

outcomes: [

{ id: 'play_result', label: 'Result of At-Bat', options: ['Walk', 'Strikeout', 'Single', 'Double', 'Triple', 'Home Run', 'Sacrifice', 'Out'] }

]

football: {

bets: [

{ id: 'play_type', label: 'Offensive Play', options: ['Run', 'Pass'] },

{ id: 'run_direction', label: 'Run Direction (if run)', options: ['Left', 'Middle', 'Right', 'N/A'] },

{ id: 'pass_length', label: 'Pass Length (if pass)', options: ['Short (<10yd)', 'Medium (10-20yd)', 'Long (20+yd)', 'N/A'] },

outcomes: [

{ id: 'result', label: 'Play Result', options: ['Gain', 'Loss', 'No Gain', 'Incomplete', 'Interception', 'Fumble', 'Touchdown'] },

{ id: 'yards', label: 'Yards Gained/Lost', options: ['-5 or less', '-4 to -1', '0', '1-4', '5-9', '10-19', '20+'] }

]

basketball: {

bets: [

{ id: 'shot_type', label: 'Shot Type', options: ['2-Point Shot', '3-Point Shot', 'Free Throw'] },

{ id: 'player_action', label: 'Player Action', options: ['Dribble Drive', 'Catch and Shoot', 'Post-up', 'Off-ball screen'] },

outcomes: [

{ id: 'shot_result', label: 'Shot Result', options: ['Made', 'Missed'] },

{ id: 'follow_up', label: 'Follow-up Action', options: ['Offensive Rebound', 'Defensive Rebound', 'Foul', 'Turnover'] }

]

}

};

// --- Helper Components ---

const Spinner = () => (

);

const Modal = ({ isOpen, onClose, title, children }) => {

if (!isOpen) return null;

return (

<h3 className="text-xl font-bold">{title}</h3>

</div>

<div className="p-6">{children}</div>

</div>

);

};

// --- Main App Component ---

export default function App() {

const [user, setUser] = useState(null);

const [isAuthReady, setIsAuthReady] = useState(false);

const [room, setRoom] = useState(null);

const [roomId, setRoomId] = useState('');

const [error, setError] = useState('');

const [isLoading, setIsLoading] = useState(false);

const [copied, setCopied] = useState(false);

const [playerName, setPlayerName] = useState('');

const [isNameModalOpen, setIsNameModalOpen] = useState(false);

// --- Authentication Effect ---

useEffect(() => {

const initAuth = async () => {

try {

const token = typeof __initial_auth_token !== 'undefined' ? __initial_auth_token : null;

if (token) {

await signInWithCustomToken(auth, token);

} else {

await signInAnonymously(auth);

}

} catch (err) {

console.error("Authentication Error:", err);

setError("Could not authenticate. Please refresh.");

}

};

const unsubscribe = onAuthStateChanged(auth, (currentUser) => {

setUser(currentUser);

setIsAuthReady(true);

if (currentUser && !currentUser.displayName) {

setIsNameModalOpen(true);

}

});

initAuth();

return () => unsubscribe();

}, []);

// --- Room Subscription Effect ---

useEffect(() => {

if (!roomId || !db) return;

const roomRef = doc(db, `artifacts/${appId}/public/data/propBetRooms`, roomId);

const unsubscribe = onSnapshot(roomRef, (docSnap) => {

if (docSnap.exists()) {

setRoom({ id: docSnap.id, ...docSnap.data() });

} else {

setError("Room not found. It might have been deleted.");

setRoom(null);

setRoomId('');

}

setIsLoading(false);

}, (err) => {

console.error("Snapshot Error:", err);

setError("Error listening to room updates.");

setIsLoading(false);

});

return () => unsubscribe();

}, [roomId, db]);

// --- Memoized Values ---

const currentPlayer = useMemo(() => {

if (!user || !room?.players) return null;

return room.players[user.uid];

}, [user, room]);

const isHost = useMemo(() => {

return currentPlayer?.isHost === true;

}, [currentPlayer]);

// --- Core Functions ---

const handleCreateRoom = async (sport) => {

if (!user || !playerName) {

setIsNameModalOpen(true);

return;

}

setIsLoading(true);

setError('');

try {

const collectionRef = collection(db, `artifacts/${appId}/public/data/propBetRooms`);

const newRoomDoc = await addDoc(collectionRef, {

sport: sport,

hostId: user.uid,

createdAt: new Date(),

players: {

[user.uid]: { name: playerName, score: 0, isHost: true }

currentPlay: null,

playHistory: []

});

setRoomId(newRoomDoc.id);

} catch (err) {

console.error("Error creating room:", err);

setError("Failed to create room. Please try again.");

setIsLoading(false);

}

};

const handleJoinRoom = async (joinRoomId) => {

if (!user || !playerName) {

setIsNameModalOpen(true);

return;

}

if (!joinRoomId) {

setError("Please enter a Room ID.");

return;

}

setIsLoading(true);

setError('');

try {

const roomRef = doc(db, `artifacts/${appId}/public/data/propBetRooms`, joinRoomId);

const roomSnap = await getDoc(roomRef);

if (!roomSnap.exists()) {

setError("Room not found. Check the ID and try again.");

setIsLoading(false);

return;

}

const newPlayer = { name: playerName, score: 0, isHost: false };

await updateDoc(roomRef, {

[`players.${user.uid}`]: newPlayer

});

setRoomId(joinRoomId);

} catch (err) {

console.error("Error joining room:", err);

setError("Failed to join room. Please try again.");

setIsLoading(false);

}

};

const handleSetPlayerName = () => {

if (playerName.trim()) {

setIsNameModalOpen(false);

}

};

const handleLeaveRoom = () => {

setRoom(null);

setRoomId('');

setError('');

};

const handleCopyRoomId = () => {

const el = document.createElement('textarea');

el.value = roomId;

document.body.appendChild(el);

el.select();

document.execCommand('copy');

document.body.removeChild(el);

setCopied(true);

setTimeout(() => setCopied(false), 2000);

};

// --- Render Logic ---

if (!isAuthReady) {

return (

<p className="mt-4 text-lg">Authenticating...</p>

</div>

);

}

if (isNameModalOpen) {

return (

<p className="text-gray-300">Please enter a name to use in the game.</p>

<input

type="text"

value={playerName}

onChange={(e) => setPlayerName(e.target.value)}

placeholder="e.g., Coach Dave"

className="p-3 bg-gray-700 rounded-lg border border-gray-600 focus:outline-none focus:ring-2 focus:ring-indigo-500"

<button

onClick={handleSetPlayerName}

disabled={!playerName.trim()}

className="w-full bg-indigo-600 hover:bg-indigo-700 text-white font-bold py-3 px-4 rounded-lg transition-colors disabled:bg-gray-500 disabled:cursor-not-allowed"

Save Name

</button>

</div>

</Modal>

</div>

);

}

if (!room) {

return <Lobby onCreate={handleCreateRoom} onJoin={handleJoinRoom} error={error} isLoading={isLoading} />;

}

return <GameRoom room={room} user={user} onLeave={handleLeaveRoom} onCopy={handleCopyRoomId} copied={copied} isHost={isHost} />;

}

const Lobby = ({ onCreate, onJoin, error, isLoading }) => {

const [joinId, setJoinId] = useState('');

const [selectedSport, setSelectedSport] = useState('baseball');

return (

<p className="text-gray-400 mb-8">Challenge your friends on every play.</p>

{error && <p className="bg-red-500/20 text-red-300 p-3 rounded-lg mb-6">{error}</p>}

{/* Create Room Section */}

<h2 className="text-2xl font-bold mb-4 flex items-center justify-center"><PlusCircle className="mr-2 text-indigo-400"/> Create a New Game</h2>

<label htmlFor="sport-select" className="block text-sm font-medium text-gray-300 mb-2">Choose a Sport:</label>

<select

id="sport-select"

value={selectedSport}

onChange={(e) => setSelectedSport(e.target.value)}

className="w-full p-3 bg-gray-700 rounded-lg border border-gray-600 focus:outline-none focus:ring-2 focus:ring-indigo-500"

{Object.keys(SPORTS).map(key => (

<option key={key} value={key}>{SPORTS[key].name}</option>

))}

</select>

</div>

<button

onClick={() => onCreate(selectedSport)}

disabled={isLoading}

className="w-full bg-indigo-600 hover:bg-indigo-700 text-white font-bold py-3 px-4 rounded-lg transition-colors flex items-center justify-center disabled:bg-gray-500"

{isLoading ? <Spinner/> : 'Create Game'}

</button>

</div>

</div>

{/* Join Room Section */}

<div>

<input

type="text"

value={joinId}

onChange={(e) => setJoinId(e.target.value)}

placeholder="Enter Room ID"

className="flex-grow p-3 bg-gray-700 rounded-lg border border-gray-600 focus:outline-none focus:ring-2 focus:ring-purple-500"

<button

onClick={() => onJoin(joinId)}

disabled={isLoading}

className="bg-purple-600 hover:bg-purple-700 text-white font-bold py-3 px-4 rounded-lg transition-colors flex items-center justify-center disabled:bg-gray-500"

{isLoading ? <Spinner/> : 'Join'}

</button>

</div>

);

};

const GameRoom = ({ room, user, onLeave, onCopy, copied, isHost }) => {

const sportConfig = SPORTS[room.sport];

const roomRef = doc(db, `artifacts/${appId}/public/data/propBetRooms`, room.id);

const [myBet, setMyBet] = useState({});

const [outcome, setOutcome] = useState({});

const [isResolving, setIsResolving] = useState(false);

const currentPlay = room.currentPlay;

const playersArray = Object.entries(room.players || {}).map(([id, data]) => ({ id, ...data }));

useEffect(() => {

// Reset local bet state when a new play starts

if (currentPlay) {

const existingBet = currentPlay.bets?.[user.uid];

setMyBet(existingBet || {});

} else {

setMyBet({});

setOutcome({});

}

}, [currentPlay, user.uid]);

const handleStartPlay = async () => {

await updateDoc(roomRef, {

currentPlay: {

status: 'betting',

bets: {},

startedAt: new Date()

}

});

};

const handleBetChange = (betId, value) => {

setMyBet(prev => ({ ...prev, [betId]: value }));

};

const handlePlaceBet = async () => {

if (Object.keys(myBet).length === 0) return;

await updateDoc(roomRef, {

[`currentPlay.bets.${user.uid}`]: myBet

});

};

const handleResolvePlay = async () => {

if (Object.keys(outcome).length === 0) return;

setIsResolving(true);

const newScores = { ...room.players };

let pointsAwarded = {};

Object.entries(currentPlay.bets).forEach(([playerId, playerBet]) => {

let scoreForPlay = 0;

// Compare bet with outcome. This is a simple 1 point per correct prediction.

Object.entries(playerBet).forEach(([betKey, betValue]) => {

if (outcome[betKey] && outcome[betKey] === betValue) {

scoreForPlay += 1;

}

});

if (scoreForPlay > 0) {

newScores[playerId].score += scoreForPlay;

pointsAwarded[playerId] = scoreForPlay;

}

});

const resolvedPlay = {

...currentPlay,

outcome,

resolvedAt: new Date(),

pointsAwarded

};

await updateDoc(roomRef, {

players: newScores,

currentPlay: null,

playHistory: arrayUnion(resolvedPlay)

});

setIsResolving(false);

};

const renderBettingArea = () => {

if (!currentPlay) {

return isHost ? (

<h3 className="text-xl font-semibold mb-4">Ready for the next play?</h3>

Start New Play

</button>

</div>

) : (

<h3 className="text-xl font-semibold text-gray-300">Waiting for the host to start the next play...</h3>

</div>

);

}

const hasBet = currentPlay.bets && currentPlay.bets[user.uid];

return (

<h3 className="text-2xl font-bold mb-4 text-indigo-300">Place Your Bet!</h3>

{sportConfig.bets.map(bet => (

<label className="block text-sm font-medium text-gray-300 mb-2">{bet.label}</label>

<select

value={myBet[bet.id] || ''}

onChange={(e) => handleBetChange(bet.id, e.target.value)}

disabled={!!hasBet}

className="w-full p-3 bg-gray-700 rounded-lg border border-gray-600 focus:outline-none focus:ring-2 focus:ring-indigo-500 disabled:bg-gray-600 disabled:text-gray-400"

<option value="" disabled>Select...</option>

{bet.options.map(opt => <option key={opt} value={opt}>{opt}</option>)}

</select>

</div>

))}

</div>

{hasBet ? (

<p className="text-center text-green-400 font-semibold p-3 bg-green-500/10 rounded-lg">Your bet is locked in! Waiting for others...</p>

) : (

Lock In Bet

</button>

)}

</div>

);

};

const renderResolveArea = () => {

if (!currentPlay || !isHost) return null;

const allBetsIn = Object.keys(room.players).length === Object.keys(currentPlay.bets || {}).length;

if (!allBetsIn) {

return (

Waiting for all players to bet before resolving...

</div>

);

}

return (

<h3 className="text-2xl font-bold mb-4 text-purple-300">Resolve The Play</h3>

<p className="text-gray-400 mb-4">As the host, select the actual outcome of the play to award points.</p>

{[...sportConfig.bets, ...sportConfig.outcomes].map(o => (

<label className="block text-sm font-medium text-gray-300 mb-2">{o.label}</label>

<select

value={outcome[o.id] || ''}

onChange={(e) => setOutcome(prev => ({...prev, [o.id]: e.target.value}))}

className="w-full p-3 bg-gray-700 rounded-lg border border-gray-600 focus:outline-none focus:ring-2 focus:ring-purple-500"

<option value="" disabled>Select outcome...</option>

{o.options.map(opt => <option key={opt} value={opt}>{opt}</option>)}

</select>

</div>

))}

</div>

{isResolving ? <Spinner/> : 'Finalize & Award Points'}

</button>

</div>

);

};

return (

{/* Header */}

<div>

<ArrowLeft size={18} className="mr-2"/> Back to Lobby

</button>

<h1 className="text-3xl md:text-4xl font-bold mt-2 text-white">{sportConfig.name} Prop Bets</h1>

</div>

{copied ? <span className="text-xs text-green-400">Copied!</span> : <Share2 size={18} />}

</button>

</div>

</header>

{/* Main Content */}

{renderBettingArea()}

{renderResolveArea()}

</main>

{/* Sidebar */}

{/* Scoreboard */}

<h3 className="text-xl font-bold mb-4 flex items-center"><Award className="mr-2 text-yellow-400"/> Scoreboard</h3>

{playersArray.map(p => (

{p.isHost && <Crown size={16} className="ml-2 text-yellow-500" />}

</div>

<span className="font-bold text-2xl text-white">{p.score}</span>

</li>

))}

</ul>

</div>

{/* Current Bets */}

{currentPlay && (

<h3 className="text-xl font-bold mb-4 flex items-center"><ChevronsRight className="mr-2 text-green-400"/> Current Bets</h3>

{playersArray.map(p => {

const playerBet = currentPlay.bets?.[p.id];

return (

{playerBet ?

<span className="text-xs px-2 py-1 bg-green-500/20 text-green-300 rounded-full">Bet Placed</span> :

<span className="text-xs px-2 py-1 bg-yellow-500/20 text-yellow-300 rounded-full">Waiting...</span>

}

</li>

);

})}

</ul>

</div>

)}

</aside>

</div>

);

};

This application provides a robust starting point for your idea. Here's a breakdown of how it works and how you can use it:

How to Use the App

Enter Your Name: When you first load the app, you'll be prompted to enter a display name. This is the name your friends will see in the game room.
Create or Join a Game:
- To Create: Select a sport (Baseball, Football, or Basketball) from the dropdown and click "Create Game."
- To Join: Get the "Room ID" from a friend who has created a game, paste it into the input field, and click "Join."
Share the Room ID: Once in the game room, the unique Room ID is displayed at the top right. Copy and share this with your friends so they can join you.
Playing the Game:
- Host Starts: The person who created the room (the "Host," marked with a crown icon) will see a "Start New Play" button.
- Place Bets: Once the host starts a play, everyone in the room can select their predictions from the dropdown menus and click "Lock In Bet." You can't change your bet once it's placed. The "Current Bets" list shows who has and hasn't bet yet.
- Host Resolves: After the real-life play is over, the host will see a "Resolve The Play" section. They will select the actual outcomes from the dropdowns and click "Finalize & Award Points."
- Scoring: The app automatically compares everyone's bets to the outcome entered by the host. You get one point for each correct prediction. Scores are updated instantly on the scoreboard.
- Repeat: The host can then start the next play, and the cycle continues!

Next Steps and Potential Improvements

Custom Point Values: You could modify the logic to assign different point values to harder-to-predict outcomes.
Play History: The app saves a history of each play. You could add a new section to the UI to display this log, showing who bet on what and what the outcome was for each round.
More Sports & Bet Types: The SPORTS object at the top of the code is designed to be easily expandable. You can add new sports or more detailed betting options for the existing ones.
Live Chat: Add a simple chat box component to allow players to communicate within the app.
Host Controls: You could add more controls for the host, like the ability to kick a player or transfer host duties.

Describe how the players can create their own game, with tailored options unique to that game

Of course. While the current app lets you choose from pre-defined sports like baseball and football, I can describe how it could be extended to allow players to create their own completely custom games. This would empower users to tailor the betting options for any event, from a local soccer match to a reality TV show finale.

Here’s a conceptual overview of how this feature would work, broken down into two main parts: the creation process and the gameplay experience.

Part 1: The Custom Game Creation Process

To create a custom game, the "Host" would no longer be limited to the pre-set sports. Instead, they would have a "Create a Custom Game" option in the Lobby. This would open a new creation screen with the following steps:

Name Your Game: The first step is simple: give your game a unique name. This could be anything from "Sunday Night Football" to "Season Finale - The Great Bake Off."
Define the "Bets": This is the core of the customization. The host would define the questions that players will bet on for each "play" or round. For each bet, they would specify:
- The Bet Prompt: This is the question itself (e.g., "What will the next play be?").
- The Options: These are the multiple-choice answers players can select (e.g., "Run", "Pass", "Turnover").
- The host could add multiple, independent bet prompts for each round. For example, for a single football play, you could bet on both the play type (Run/Pass) and the outcome (Gain/Loss).
Define the "Outcomes": The host also needs to define the categories for resolving the play. This often mirrors the bet prompts but is used by the host to enter the actual result. For example:
- Outcome Category: "Result of the Play"
- Outcome Options: "Touchdown," "First Down," "Incomplete," "Fumble."
- This ensures that when the host resolves a round, they are selecting from a pre-defined list, which makes scoring automatic and fair.
Launch the Game: Once the host has defined the name, bets, and outcomes, they would click "Create Game." This would generate a new game room, just like the standard version, but running on their custom ruleset. The app would save this unique configuration to the game room's data.

Part 2: Playing a Custom Game

For the players, including the host, the gameplay experience would be very similar to the standard version, but with their own tailored options:

Placing Bets: When the host starts a new play, players will see the custom bet prompts and options that were defined during the creation process. They make their selections and lock in their bets as usual.
Resolving Plays: After the real-life action happens, the host will see the custom outcome categories they created. They select the actual results, and the app automatically calculates and distributes points to the players who guessed correctly.
The Scoreboard: The scoreboard and player list function exactly the same, creating a seamless experience whether the game is a standard sport or a fully custom creation.

This feature would transform the application from a sports-centric betting game into a flexible platform for creating friendly, play-by-play prediction games for virtually any live event.

Describe how this app could be played with AR glasses + generative-AI for NLP. All inputs would be voice and hand gestures.

Of course. Integrating the app with AR glasses and a generative AI for Natural Language Processing (NLP) would fundamentally transform the experience, making it completely hands-free and seamlessly blended with the act of watching the game.

Here’s a breakdown of how that futuristic version would work, with all inputs handled by voice and hand gestures.

The Scene: A New Way to Watch

Imagine you and your friends are in a living room watching a football game on TV. You're all wearing sleek, lightweight AR glasses. There's no need to look down at a phone; the game interface is part of your world.

1. The Augmented Reality Interface

The app's UI would appear as a shared, semi-transparent holographic panel floating in the room, perhaps anchored above or to the side of the television. It's designed to be minimalist, providing key information without obstructing the view of the actual game.

Shared Space: Everyone sees the same game board, scoreboard, and betting options in the same physical location. When a friend points to an option, you see their virtual "pointer" move in real-time.
Personal View: You also have a small, private heads-up display (HUD) in the corner of your vision for personal notifications, like "Your bet is locked in."

2. Starting and Joining a Game (Voice & Gesture)

The entire process is initiated through natural conversation.

Host: Looking at the group, you'd say, "Hey Bet Buddy, let's start a football game."
- AI Action: The generative AI parses this command. It recognizes the wake phrase ("Hey Bet Buddy"), the intent (start_game), and the parameter (game_type: 'football').
- AR Action: The main game interface materializes in the room. A prompt appears: "New Football Game Created. Inviting nearby players."
Joining Players:
- Your friends receive a small notification in their HUD: "Dave has invited you to a game. Join?"
- To accept, a friend simply says "I'm in" or gives a thumbs-up gesture.
- The AI confirms their entry, and their name and avatar pop up on the main scoreboard.

3. Placing a Bet: The Core Loop

This is where the system feels truly intuitive.

Host Initiates: After a play ends, the host says, "Okay, open bets for the next play."
Betting Opens: The main AR panel displays the betting options as large, floating interactive buttons (e.g., [Run], [Pass]).
Players Bet (Voice): You simply state your prediction in natural language.
- You might say: "I think it's going to be a pass."
- Your friend might say: "Put me down for a run."
- AI Action: The NLP model instantly interprets the intent (place_bet) and the chosen option from your speech. It doesn't need a rigid command structure.
Players Bet (Gesture): Alternatively, you could look at the floating [Pass] button, which would highlight it, and then make a simple "air tap" or "pinch" gesture with your hand to select it.
Confirmation: Once you've made a selection, the option glows in your designated player color. You say "Lock it in" or give another thumbs-up. Your bet is now submitted, and the UI shows you a "Bet Locked" status.

4. Resolving a Play and Scoring

After the play happens on TV, the host resolves it.

Host Resolves (Voice): The host doesn't need to select from menus. They just describe what happened: "That was a pass for a 10-yard gain."
AI Action: The generative AI is the star here. It parses the host's statement, extracts the key entities (play_type: 'Pass', result: 'Gain'), and maps them to the predefined outcome categories. It then automatically calculates the scores.
AR Action & Celebration: The system provides instant feedback.
- The correct answers on the main panel glow brightly.
- A shower of virtual confetti or a "+1" animation might fly from the panel to the avatars of the players who guessed correctly.
- The main scoreboard updates in real-time with a satisfying animation and sound effect.

The Role of Generative AI (NLP)

The AI is the "brain" that makes this hands-free experience possible.

Natural Language Understanding (NLU): It moves beyond simple commands to understand conversational phrases, context, and intent.
Disambiguation: If you say something vague like, "I bet on the offense," the AI would generate a follow-up question in the AR display: "Do you mean a Run or a Pass?"
Entity Extraction: This is key for the host. The AI is trained to listen for and pull out the specific game outcomes from a descriptive sentence, eliminating the need for manual data entry.

This AR and AI-powered version of the app removes the physical barrier of a phone, allowing players to stay fully immersed in the sporting event and the social experience of watching it with friends.

From <https://gemini.google.com/app/> Google Gemini 2.5 Pro

Search This Blog

Learning from ChatGPT