gotchi-battler-game-logic 1.0.0

package/scripts/data/tournaments.json

@@ -0,0 +1,67 @@
+[
+    {
+        "id": 1,
+        "name": "Test Tournament 1",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 2,
+        "name": "Test Tournament 2",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 4,
+        "name": "1000 DAI Bounty Tournament",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 5,
+        "name": "2000 DAI Bounty Tournament",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 7,
+        "name": "10k GHST Rarity Farming Tournament",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 8,
+        "name": "30k GHST Rarity Farming Tournament",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 9,
+        "name": "60k GHST Rarity Farming Tournament",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 10,
+        "name": "Test Tournament 3",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 11,
+        "name": "1000 DAI Bounty Tournament",
+        "gameLogicVersion": "v1.4"
+    },
+    {
+        "id": 12,
+        "name": "1000 DAI Bounty Tournament",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 13,
+        "name": "RF8 10K GHST Tournament",
+        "gameLogicVersion": "v1.5"
+    },
+    {
+        "id": 14,
+        "name": "RF8 40K GHST Tournament",
+        "gameLogicVersion": "v1.6"
+    },
+    {
+        "id": 15,
+        "name": "RF8 100K GHST Tournament",
+        "gameLogicVersion": "v1.6"
+    }
+]

package/scripts/runBattle.js

@@ -0,0 +1,16 @@
+const fs = require('fs')
+const path = require('path')
+const battle = require('..')
+
+// Edit these json files to test different battles
+// NOTE: Only the in-game stats (speed, health, crit etc..) are used in the game logic
+const team1 = require('./data/team1.json')
+const team2 = require('./data/team2.json')
+
+const results = battle(team1, team2, "82807311112923564712218359337695919195403960526804010606215202651499586140469")
+
+const timestamp = new Date().getTime()
+const resultsFilename = `results-${timestamp}.json`
+fs.writeFileSync(path.join(__dirname, 'output', resultsFilename), JSON.stringify(results, null, '\t'))
+
+console.log(`Results written to ${path.join(__dirname, 'output', resultsFilename)}`)

package/scripts/validateBattle.js

@@ -0,0 +1,64 @@
+const axios = require('axios')
+const { GameError, ValidationError } = require('../utils/errors')
+const { logToInGameTeams } = require('../utils/transforms')
+const { compareLogs } = require('../utils/validations')
+const gameVersions = require('../game-logic')
+
+const main = async (battleId, seed, gameLogicVersion) => {
+
+    if (!gameLogicVersion) gameLogicVersion = gameVersions.current
+    if (!gameVersions[gameLogicVersion]) throw new Error('Invalid game logic version')
+        
+    const gameLoop = gameVersions[gameLogicVersion].gameLoop
+
+    const res = await axios.get(`https://storage.googleapis.com/gotchi-battler-live_battles/v1/${battleId}.json`)
+
+    if (!res || !res.data || !res.data.layout) {
+        console.error('Battle not found')
+        return
+    }
+
+    // Transform the logs to in-game teams
+    const teams = logToInGameTeams(res.data)
+
+    try {
+        // Run the game loop
+        const logs = await gameLoop(teams[0], teams[1], seed)
+
+        // Validate the results
+        compareLogs(res.data, logs)
+
+        return logs
+    } catch (error) {
+        if (error instanceof GameError) {
+            console.error('Errored game logs: ', error.logs)
+        }
+
+        throw error
+    }
+}
+
+module.exports = main
+
+// node scripts/validateBattle.js 4d0f3c5c-08a0-42db-bd34-dee44300685a 82807311112923564712218359337695919195403960526804010606215202651499586140469
+if (require.main === module) {
+    const battleId = process.argv[2]
+    const seed = process.argv[3]
+    const gameLogicVersion = process.argv[4]
+
+    main(battleId, seed, gameLogicVersion)
+    .then(() => {
+        console.log('Results from game logic match the logs ✅')
+        console.log('Done')
+        process.exit(0)
+    })
+    .catch((error) => {
+        if (error instanceof ValidationError) {
+            console.error('Results from game logic do not match the logs ❌')
+        }
+            
+        console.error('Error: ', error.message)
+
+        process.exit(1)
+    })
+}

package/scripts/validateTournament.js

@@ -0,0 +1,101 @@
+const fs = require('fs')
+const path = require('path')
+const axios = require('axios')
+const { getTournamentContract } = require('../utils/contracts')
+const { ValidationError } = require('../utils/errors')
+const tournaments = require('./data/tournaments.json')
+const validateBattle = require('./validateBattle')
+
+const main = async (tournamentId) => {
+
+    console.log(`Getting tournament config for id  ${tournamentId}...`)
+
+    const tournamentConfig = tournaments.find(t => `${t.id}` === `${tournamentId}`)
+
+    if (!tournamentConfig || !tournamentConfig.gameLogicVersion) {
+        console.error('Tournament config not found with id:', tournamentId)
+        return
+    }
+
+    console.log(`Found, using game logic version "${tournamentConfig.gameLogicVersion}" ✅`)
+    console.log(`Getting tournament data for id: ${tournamentId}...`)
+
+    const tournament = await axios.get(`https://gotchi-battler-backend-blmom6tkla-ew.a.run.app/api/v1/tournaments/${tournamentId}`)
+
+    if (!tournament || !tournament.data || !tournament.data.address) {
+        console.error('Tournament not found with id:', tournamentId)
+        return
+    }
+
+    const onchainAddress = tournament.data.address
+
+    const brackets = await axios.get(`https://gotchi-battler-backend-blmom6tkla-ew.a.run.app/api/v1/tournaments/${tournamentId}/brackets`)
+
+    if (!brackets || !brackets.data || !brackets.data.length) {
+        console.error('Brackets not found')
+        return
+    }
+
+    console.log(`Tournament data for id ${tournamentId} found ✅`)
+    console.log(`Validating "${tournament.data.name}"...`)
+    console.log('(This process can take up to 20 minutes for large tournaments)')
+    for (const bracket of brackets.data) {
+        console.log(`Validating "${bracket.name}"...`)
+        for (const round of bracket.rounds) {
+            for (const battle of round.battles) {
+                // If battle is a BYE then skip
+                if (!battle.team1Id || !battle.team2Id) {
+                    continue
+                }
+
+                // Get seed for the battle
+                const tournamentContract = getTournamentContract(onchainAddress)
+                const seed = await tournamentContract.roundSeeds(round.roundStage)
+
+                try {
+                    await validateBattle(battle.id, seed.toString(), tournamentConfig.gameLogicVersion)
+                } catch (error) {
+                    if (error instanceof ValidationError) {
+                        console.error(`Battle ${battle.id} failed validation ❌`)
+                        console.error(`Seed: "${seed.toString()}"`)
+
+                        // Write original logs to file
+                        const originalLogsFilename = `${battle.id}-originalLogs.json`
+                        fs.writeFileSync(path.join(__dirname, 'output', originalLogsFilename), JSON.stringify(error.originalLogs, null, '\t'))
+
+                        // Write new logs to file
+                        const newLogsFilename = `${battle.id}-newLogs.json`
+                        fs.writeFileSync(path.join(__dirname, 'output', newLogsFilename), JSON.stringify(error.newLogs, null, '\t'))
+
+                        console.error(`Original logs written to ${path.join(__dirname, 'output', originalLogsFilename)}`)
+                        console.error(`New logs written to ${path.join(__dirname, 'output', newLogsFilename)}`)
+                    }
+
+                    throw error
+                }
+                
+            }
+            console.log(`Round ${round.roundStage} validated ✅`)
+        }
+        console.log(`"${bracket.name}" validated ✅`)
+    }
+    console.log(`"${tournament.data.name}" validated ✅`)
+}
+
+module.exports = main
+
+// node scripts/validateTournament.js 15
+if (require.main === module) {
+    const tournamentId = process.argv[2]
+
+    main(tournamentId)
+    .then(() => {
+        console.log('Done')
+        process.exit(0)
+    })
+    .catch((error) => {
+        console.error(error)
+
+        process.exit(1)
+    })
+}

package/utils/contracts.js

@@ -0,0 +1,13 @@
+const { ethers } = require('ethers')
+const tournamentAbi = require('../constants/tournamentManagerAbi.json')
+
+const getTournamentContract = (address) => {
+    const provider = new ethers.providers.JsonRpcProvider('https://polygon-rpc.com')
+    const contract = new ethers.Contract(address, tournamentAbi, provider)
+
+    return contract
+}
+
+module.exports = {
+    getTournamentContract
+}

package/utils/errors.js

@@ -0,0 +1,30 @@
+class GameError extends Error {
+	constructor(msg, logs) {
+        super(msg)
+        this.name = 'GameError'
+
+		if(logs) {
+			this.logs = logs
+		}
+	}
+}
+
+class ValidationError extends Error {
+	constructor(msg, originalLogs, newLogs) {
+        super(msg)
+        this.name = 'ValidationError'
+
+		if(originalLogs) {
+			this.originalLogs = originalLogs
+		}
+
+		if(newLogs) {
+			this.newLogs = newLogs
+		}
+	}
+}
+
+module.exports = {
+    GameError,
+    ValidationError
+}

package/utils/transforms.js

@@ -0,0 +1,48 @@
+const logToInGameTeams = (originalLog) => {
+    // Deep copy the log to avoid modifying the original log
+    const log = JSON.parse(JSON.stringify(originalLog))
+
+    const teams = [];
+
+    [0, 1].forEach((teamIndex) => {
+        teams.push({
+            formation: {
+                front: log.layout.teams[teamIndex].rows[0].slots.map((slot) => {
+                    if (slot.isActive) {
+                        const gotchi = log.gotchis.find((gotchi) => gotchi.id === slot.id)
+
+                        if (!gotchi) {
+                            throw new Error(`Gotchi not found: ${slot.id}`)
+                        }
+
+                        return gotchi
+                    } else {
+                        return null
+                    }
+                }),
+                back: log.layout.teams[teamIndex].rows[1].slots.map((slot) => {
+                    if (slot.isActive) {
+                        const gotchi = log.gotchis.find((gotchi) => gotchi.id === slot.id)
+
+                        if (!gotchi) {
+                            throw new Error(`Gotchi not found: ${slot.id}`)
+                        }
+
+                        return gotchi
+                    } else {
+                        return null
+                    }
+                })
+            },
+            leader: log.layout.teams[teamIndex].leaderId,
+            name: log.layout.teams[teamIndex].name,
+            owner: log.layout.teams[teamIndex].owner
+        })
+    });
+    
+    return teams
+}
+
+module.exports = {
+    logToInGameTeams
+}   

package/utils/validations.js

@@ -0,0 +1,40 @@
+const { ValidationError } = require('./errors')
+
+const compareLogs = (originalLogs, newLogs) => {
+    // Check winner, loser and numOfTurns properties
+    if (originalLogs.result.winner !== newLogs.result.winner) {
+        throw new ValidationError(`Winner mismatch: ${originalLogs.result.winner} !== ${newLogs.result.winner}`, originalLogs, newLogs)
+    }
+
+    if (originalLogs.result.loser !== newLogs.result.loser) {
+        throw new ValidationError(`Loser mismatch: ${originalLogs.result.loser} !== ${newLogs.result.loser}`, originalLogs, newLogs)
+    }
+
+    if (originalLogs.result.numOfTurns !== newLogs.result.numOfTurns) {
+        throw new ValidationError(`numOfTurns mismatch: ${originalLogs.result.numOfTurns} !== ${newLogs.result.numOfTurns}`, originalLogs, newLogs)
+    }
+
+    // Validate winningTeam array
+    originalLogs.result.winningTeam.forEach((gotchi) => {
+        // Check id, name and health properties
+        const gotchi2 = newLogs.result.winningTeam.find((gotchi2) => gotchi2.id === gotchi.id)
+
+        if (!gotchi2) {
+            throw new ValidationError(`Gotchi not found in winningTeam: ${gotchi.id}`, originalLogs, newLogs)
+        }
+
+        if (gotchi.name !== gotchi2.name) {
+            throw new ValidationError(`Gotchi name mismatch: ${gotchi.name} !== ${gotchi2.name}`, originalLogs, newLogs)
+        }
+
+        if (gotchi.health !== gotchi2.health) {
+            throw new ValidationError(`Gotchi health mismatch: ${gotchi.health} !== ${gotchi2.health}`, originalLogs, newLogs)
+        }
+    })
+
+    return true
+}
+
+module.exports = {
+    compareLogs
+}