☰

GeoGuessr Auto-Save to Google Sheets

Automatically saves all solo games to Google Sheets and tracks current games

// ==UserScript==
// @name         GeoGuessr Auto-Save to Google Sheets
// @namespace    http://tampermonkey.net/
// @version      1.1
// @description  Automatically saves all solo games to Google Sheets and tracks current games
// @author       Flykii
// @match        https://www.geoguessr.com/*
// @grant        GM_addStyle
// @grant        GM_xmlhttpRequest
// @grant        GM_setValue
// @grant        GM_getValue
// @connect      www.geoguessr.com
// @connect      script.google.com
// @connect      script.googleusercontent.com
// @connect      *
// @license      MIT
// ==/UserScript==

(function() {
    'use strict';

    const CONFIG = {
        GOOGLE_SCRIPT_URL: 'YOUR_URL_HERE',
        DELAY_MS: 500,
        INITIAL_SCAN_PAGES: 20,
        CHECK_INTERVAL: 30000
    };

    let isScanning = false;
    let currentGameToken = null;
    let lastProcessedTime = GM_getValue('lastProcessedTime', Date.now() - 24*60*60*1000);

    function init() {
        console.log('Solo Stats - GeoGuessr Auto-Save to Google Sheets');

        setTimeout(() => {
            scanRecentGames();
        }, 2000);

        startGameMonitoring();

        setInterval(() => {
            if (!isScanning) {
                scanRecentGames();
            }
        }, CONFIG.CHECK_INTERVAL);

        let currentUrl = window.location.href;
        setInterval(() => {
            if (window.location.href !== currentUrl) {
                currentUrl = window.location.href;
                handleUrlChange(currentUrl);
            }
        }, 1000);
        checkFirstTime();
    }
    function createHistoricalImportUI() {
        const importUI = document.createElement('div');
        importUI.id = 'historical-import-ui';
        importUI.innerHTML = `
            <div style="
                position: fixed;
                top: 50%;
                left: 50%;
                transform: translate(-50%, -50%);
                background: white;
                border: 2px solid #4caf50;
                border-radius: 10px;
                padding: 20px;
                box-shadow: 0 4px 20px rgba(0,0,0,0.3);
                z-index: 10001;
                font-family: Arial, sans-serif;
                max-width: 400px;
                text-align: center;
            ">
                <h3 style="margin-top: 0; color: #4caf50;">Import Historical Games into your Google Sheet</h3>
                <p style="margin: 15px 0;">Import your previous solo Geoguessr games?</p>
                <div style="margin: 15px 0;">
                    <label for="pageCount">Pages to scan:</label><br>
                    <input type="number" id="pageCount" value="10" min="1" max="100" style="
                        margin: 5px;
                        padding: 5px;
                        border: 1px solid #ddd;
                        border-radius: 4px;
                        width: 60px;
                    ">
                </div>
                <div style="margin: 15px 0;">
                    <button id="startImport" style="
                        background: #4caf50;
                        color: white;
                        border: none;
                        padding: 10px 20px;
                        border-radius: 5px;
                        cursor: pointer;
                        margin: 5px;
                    ">Start Import</button>
                    <button id="cancelImport" style="
                        background: #f44336;
                        color: white;
                        border: none;
                        padding: 10px 20px;
                        border-radius: 5px;
                        cursor: pointer;
                        margin: 5px;
                    ">Cancel</button>
                </div>
                <div id="importProgress" style="display: none; margin: 15px 0;">
                    <div style="background: #f0f0f0; border-radius: 10px; overflow: hidden;">
                        <div id="progressBar" style="
                            background: #4caf50;
                            height: 20px;
                            width: 0%;
                            transition: width 0.3s ease;
                        "></div>
                    </div>
                    <p id="progressText">Starting...</p>
                </div>
            </div>
        `;

        const overlay = document.createElement('div');
        overlay.style.cssText = `
            position: fixed;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            background: rgba(0,0,0,0.5);
            z-index: 10000;
        `;
        
        document.body.appendChild(overlay);
        overlay.appendChild(importUI);

        document.getElementById('startImport').onclick = () => startHistoricalImport();
        document.getElementById('cancelImport').onclick = () => {
            document.body.removeChild(overlay);
        };
    }

    async function startHistoricalImport() {
        const pageCount = parseInt(document.getElementById('pageCount').value) || 10;
        const progressDiv = document.getElementById('importProgress');
        const progressBar = document.getElementById('progressBar');
        const progressText = document.getElementById('progressText');
        
        document.getElementById('startImport').style.display = 'none';
        document.getElementById('cancelImport').style.display = 'none';
        progressDiv.style.display = 'block';

        let importedCount = 0;
        let totalChecked = 0;
        let currentPage = 0;
        let paginationToken = null;

        try {
            while (currentPage < pageCount) {
                progressText.textContent = `Scanning page ${currentPage + 1}/${pageCount}...`;
                progressBar.style.width = `${(currentPage / pageCount) * 100}%`;

                const feedData = await fetchFeedData(paginationToken);
                
                if (!feedData || !feedData.entries || feedData.entries.length === 0) {
                    break;
                }

                for (const entry of feedData.entries) {
                    const gameTokens = extractGameTokens(entry);
                    totalChecked += gameTokens.length;
                    
                    for (const token of gameTokens) {
                        const saved = await saveGameIfSolo(token);
                        if (saved) {
                            importedCount++;
                            progressText.textContent = `Found ${importedCount} games (${totalChecked} checked) - Page ${currentPage + 1}/${pageCount}`;
                        }
                        await delay(200);
                    }
                }

                if (!feedData.paginationToken) break;
                paginationToken = feedData.paginationToken;
                currentPage++;
                await delay(500);
            }

            progressBar.style.width = '100%';
            progressText.innerHTML = `
                Import completed<br>
                <strong>${importedCount}</strong> new games imported<br>
                <small>${totalChecked} games checked total</small>
            `;

            GM_setValue('lastProcessedTime', Date.now());

            setTimeout(() => {
                const overlay = document.querySelector('#historical-import-ui').parentElement.parentElement;
                document.body.removeChild(overlay);
            }, 3000);

        } catch (error) {
            progressText.innerHTML = `Error during import: ${error.message}`;
            console.error('Historical import error:', error);
            
            setTimeout(() => {
                progressDiv.innerHTML += '<br><button onclick="this.parentElement.parentElement.parentElement.parentElement.remove()" style="background: #f44336; color: white; border: none; padding: 5px 10px; border-radius: 3px; cursor: pointer; margin-top: 10px;">Close</button>';
            }, 1000);
        }
    }

    function checkFirstTime() {
        const firstTime = GM_getValue('firstTimeUser', true);
        if (firstTime) {
            setTimeout(() => {
                createHistoricalImportUI();
                GM_setValue('firstTimeUser', false);
            }, 3000);
        }
    }





    function startGameMonitoring() {
        const observer = new MutationObserver((mutations) => {
            mutations.forEach((mutation) => {
                if (mutation.addedNodes.length > 0) {
                    checkForGameElements();
                }
            });
        });

        observer.observe(document.body, {
            childList: true,
            subtree: true
        });
    }

    function handleUrlChange(url) {
        const gameMatch = url.match(/\/games\/([a-zA-Z0-9_-]+)/);
        if (gameMatch && gameMatch[1] !== currentGameToken) {
            currentGameToken = gameMatch[1];
            console.log('Solo Stats - New game :', currentGameToken);

            setTimeout(() => {
                saveCurrentGame(currentGameToken);
            }, 5000);
        }
    }

    function checkForGameElements() {
        const gameEndElements = document.querySelectorAll('[data-qa="game-finished"], .result-view, .results__summary');
        if (gameEndElements.length > 0 && currentGameToken) {
            setTimeout(() => {
                saveCurrentGame(currentGameToken);
            }, 2000);
        }
    }

    async function scanRecentGames() {
        if (isScanning) return;

        isScanning = true;
        console.log('Solo Stats - Scanning recent games...');

        try {
            let paginationToken = null;
            let page = 0;
            let newGamesFound = 0;

            while (page < CONFIG.INITIAL_SCAN_PAGES) {
                const feedData = await fetchFeedData(paginationToken);

                if (!feedData || !feedData.entries || feedData.entries.length === 0) {
                    break;
                }

                for (const entry of feedData.entries) {
                    const entryTime = new Date(entry.created || entry.time).getTime();
                    if (entryTime <= lastProcessedTime) {
                        page = CONFIG.INITIAL_SCAN_PAGES;
                        break;
                    }

                    const gameTokens = extractGameTokens(entry);
                    for (const token of gameTokens) {
                        const saved = await saveGameIfSolo(token);
                        if (saved) {
                            newGamesFound++;
                        }
                        await delay(CONFIG.DELAY_MS);
                    }
                }

                if (!feedData.paginationToken) break;
                paginationToken = feedData.paginationToken;
                page++;
                await delay(CONFIG.DELAY_MS);
            }

            if (newGamesFound > 0) {
                GM_setValue('lastProcessedTime', Date.now());
                console.log(`Solo Stats - ${newGamesFound} new games saved`);
            } else {
                console.log('Solo Stats - 0 New games found');
            }

        } catch (error) {
            console.error('❌ Erreur lors du scan:', error);
        } finally {
            isScanning = false;
        }
    }

    function extractGameTokens(entry) {
        const tokens = [];

        try {
            if (entry.payload && entry.payload.token) {
                tokens.push(entry.payload.token);
            }
            else if (entry.payload && typeof entry.payload === 'string') {
                if (entry.payload.startsWith('[')) {
                    const payloadArray = JSON.parse(entry.payload);
                    for (const item of payloadArray) {
                        if (item.payload && item.payload.gameToken) {
                            tokens.push(item.payload.gameToken);
                        }
                    }
                } else {
                    const payloadData = JSON.parse(entry.payload);
                    if (payloadData.gameToken) {
                        tokens.push(payloadData.gameToken);
                    }
                }
            }
            else if (entry.payload && entry.payload.gameToken) {
                tokens.push(entry.payload.gameToken);
            }

            const fullEntryStr = JSON.stringify(entry);
            const gameMatches = fullEntryStr.match(/"gameToken":"([a-zA-Z0-9_-]+)"/g);
            if (gameMatches) {
                gameMatches.forEach(match => {
                    const token = match.match(/"gameToken":"([a-zA-Z0-9_-]+)"/)[1];
                    if (!tokens.includes(token)) {
                        tokens.push(token);
                    }
                });
            }

            const gameUrlMatch = fullEntryStr.match(/https:\/\/geoguessr\.com\/games\/([a-zA-Z0-9_-]+)/);
            if (gameUrlMatch && !tokens.includes(gameUrlMatch[1])) {
                tokens.push(gameUrlMatch[1]);
            }

        } catch (error) {
            console.warn('extraction tokens error:', error);
        }

        return tokens;
    }

    async function saveCurrentGame(token) {
        return await saveGameIfSolo(token);
    }

    async function saveGameIfSolo(token) {
        try {
            const gameData = await fetchGameData(token);
            if (!gameData) return false;

            if (gameData.type === 'duels' || gameData.type === 'team-duels' || gameData.type === 'battle_royale' ||
                (gameData.players && gameData.players.length > 1)) {
                return false;
            }

            const savedGames = GM_getValue('savedGames', '{}');
            const savedGamesObj = JSON.parse(savedGames);
            if (savedGamesObj[token]) {
                return false;
            }

            const gameInfo = formatGameData(gameData);
            const success = await sendToGoogleSheets(gameInfo);

            if (success) {
                savedGamesObj[token] = true;
                GM_setValue('savedGames', JSON.stringify(savedGamesObj));

                console.log(`Solo Stats - Game saved: ${gameData.mapName} - ${gameInfo.score} points`);
                return true;
            }

        } catch (error) {
            console.error(`Solo Stats - Error savong game ${token}:`, error);
        }

        return false;
    }

    function formatGameData(gameData) {
        const score = gameData.player?.totalScore?.amount || 0;
        const distance = gameData.player?.totalDistanceInMeters || 0;
        const gameMode = getGameModeFromRestrictions(gameData);

        const rounds = gameData.rounds?.map((round, index) => {
            const guess = gameData.player?.guesses?.[index] || {};

            return {
                roundNumber: index + 1,
                score: guess.roundScoreInPoints || guess.roundScore?.amount || 0,
                distance: guess.distanceInMeters || guess.distance?.meters?.amount * 1000 || 0,
                country: round.streakLocationCode || 'unknown',
                lat: round.lat,
                lng: round.lng,
                guessLat: guess.lat,
                guessLng: guess.lng,
                time: guess.time || 0
            };
        }) || [];

        return {
            token: gameData.token,
            date: new Date().toISOString(),
            score: parseInt(score) || 0,
            distance: distance,
            mapName: gameData.mapName || 'Unknown',
            mapId: gameData.map,
            gameMode: gameMode,
            timeLimit: gameData.timeLimit || 0,
            rounds: rounds,
            restrictions: {
                forbidMoving: gameData.forbidMoving || false,
                forbidZooming: gameData.forbidZooming || false,
                forbidRotating: gameData.forbidRotating || false
            }
        };
    }

    function getGameModeFromRestrictions(gameData) {
        const { forbidMoving, forbidZooming, forbidRotating } = gameData;

        if (forbidMoving && forbidZooming && forbidRotating) {
            return 'NMPZ';
        } else if (forbidMoving && !forbidZooming && !forbidRotating) {
            return 'No Move';
        } else if (!forbidMoving && !forbidZooming && !forbidRotating) {
            return 'Moving';
        } else {
            const restrictions = [];
            if (forbidMoving) restrictions.push('NM');
            if (!forbidZooming) restrictions.push('Z');
            if (!forbidRotating) restrictions.push('R');
            return restrictions.length > 0 ? restrictions.join('') : 'Custom';
        }
    }

    async function sendToGoogleSheets(gameData) {
        const userId = await generateUserId();

        return new Promise((resolve) => {
            GM_xmlhttpRequest({
                method: 'POST',
                url: CONFIG.GOOGLE_SCRIPT_URL,
                headers: {
                    'Content-Type': 'application/json',
                },
                data: JSON.stringify({
                    action: 'saveGame',
                    gameData: gameData,
                    userId: userId
                }),
                onload: function(response) {
                    if (response.status >= 200 && response.status < 300) {
                        try {
                            const result = JSON.parse(response.responseText);
                            if (result.success) {
                                showSpreadsheetLink(result.spreadsheetUrl);
                                resolve(true);
                            } else {
                                console.error('Error Google Sheets :', result.error);
                                resolve(false);
                            }
                        } catch (error) {
                            console.error('Erreur parsing Google Sheets response :', error);
                            resolve(false);
                        }
                    } else {
                        console.error(`Error HTTP Google Sheets : ${response.status}`);
                        resolve(false);
                    }
                },
                onerror: function(error) {
                    console.error('Erreur request Google Sheets :', error);
                    resolve(false);
                }
            });
        });
    }

    async function generateUserId() {
        let userId = GM_getValue('userId');
        if (!userId) {
            const canvas = document.createElement('canvas');
            const ctx = canvas.getContext('2d');
            ctx.textBaseline = 'top';
            ctx.font = '14px Arial';
            ctx.fillText('GeoGuessr User ID', 2, 2);

            const fingerprint = canvas.toDataURL();
            const timestamp = Date.now();
            const random = Math.random().toString(36).substring(2, 15);

            userId = btoa(`${fingerprint.substring(0, 20)}-${timestamp}-${random}`).substring(0, 16);
            GM_setValue('userId', userId);
        }
        return userId;
    }

    function showSpreadsheetLink(url) {
        const shown = GM_getValue('spreadsheetLinkShown', false);
        if (!shown && url) {
            console.log('Solo Stats - GeoGuessr:', url);

            const notification = document.createElement('div');
            notification.innerHTML = `
                <div style="
                    position: fixed;
                    top: 20px;
                    right: 20px;
                    background: #4caf50;
                    color: white;
                    padding: 15px 20px;
                    border-radius: 8px;
                    z-index: 10000;
                    box-shadow: 0 4px 12px rgba(0,0,0,0.3);
                    font-family: Arial, sans-serif;
                    max-width: 300px;
                ">
                    <div style="font-weight: bold; margin-bottom: 8px;">📊 GeoGuessr Stats</div>
                    <div style="font-size: 13px; margin-bottom: 10px;">Solo Stats - Games auto saved</div>
                    <a href="${url}" target="_blank" style="
                        color: white;
                        text-decoration: underline;
                        font-size: 13px;
                    ">Your stats</a>
                    <button onclick="this.parentElement.parentElement.remove()" style="
                        float: right;
                        background: none;
                        border: none;
                        color: white;
                        cursor: pointer;
                        font-size: 16px;
                        margin-top: -5px;
                    ">×</button>
                </div>
            `;

            document.body.appendChild(notification);
            setTimeout(() => {
                if (notification.parentElement) {
                    notification.remove();
                }
            }, 10000);

            GM_setValue('spreadsheetLinkShown', true);
        }
    }

    async function fetchFeedData(paginationToken) {
        let url = '/api/v4/feed/private?count=50';
        if (paginationToken) {
            url += `&paginationToken=${encodeURIComponent(paginationToken)}`;
        }

        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                method: 'GET',
                url: url,
                headers: {
                    'Content-Type': 'application/json',
                },
                onload: function(response) {
                    if (response.status >= 200 && response.status < 300) {
                        try {
                            const data = JSON.parse(response.responseText);
                            resolve(data);
                        } catch (error) {
                            reject(new Error('Error parsing JSON: ' + error.message));
                        }
                    } else {
                        reject(new Error(`Error HTTP: ${response.status}`));
                    }
                },
                onerror: function(error) {
                    reject(new Error('Errr request: ' + error.message));
                }
            });
        });
    }

    async function fetchGameData(token) {
        return new Promise((resolve) => {
            GM_xmlhttpRequest({
                method: 'GET',
                url: `/api/v3/games/${token}`,
                headers: {
                    'Content-Type': 'application/json',
                },
                onload: function(response) {
                    if (response.status >= 200 && response.status < 300) {
                        try {
                            const data = JSON.parse(response.responseText);
                            resolve(data);
                        } catch (error) {
                            console.warn(`Errorr parsing game ${token}:`, error);
                            resolve(null);
                        }
                    } else {
                        console.warn(`cant look up for game ${token} : ${response.status}`);
                        resolve(null);
                    }
                },
                onerror: function() {
                    resolve(null);
                }
            });
        });
    }

    function delay(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', init);
    } else {
        init();
    }

})();