gotchi-battler-game-logic 2.0.6 → 2.0.8

package/scripts/simRealBattle.js

@@ -0,0 +1,121 @@
+const axios = require('axios')
+const axiosRetry = require('axios-retry').default
+axiosRetry(axios, { 
+    retries: 3, 
+    retryDelay: axiosRetry.exponentialDelay
+})
+
+const { webappTeamToInGameTeam } = require('../utils/transforms')
+const { mapTeam } = require('../utils/mapGotchi')
+const { battle } = require('..')
+
+const main = async (battleId) => {
+
+    const battleRes = await axios.get(`https://gotchi-battler-backend-blmom6tkla-ew.a.run.app/api/v1/battles/${battleId}`)
+
+    if (!battleRes || !battleRes.data || !battleRes.data.team1 || !battleRes.data.team2) {
+        console.error('Battle not found')
+        return
+    }
+
+    // Transform the logs to in-game teams
+    const team1 = webappTeamToInGameTeam(battleRes.data.team1Snapshot || battleRes.data.team1)
+    const team2 = webappTeamToInGameTeam(battleRes.data.team2Snapshot || battleRes.data.team2)
+
+    console.log('Team 1', team1.formation.front.filter(g => g).map(g => {
+        return {
+            name: g.name,
+            health: g.health,
+            magic: g.magic,
+            physical: g.physical
+        }
+    }).concat(team1.formation.back.filter(g => g).map(g => {
+        return {
+            name: g.name,
+            health: g.health,
+            magic: g.magic,
+            physical: g.physical
+        }
+    })))
+    console.log('Team 2', team2.formation.front.filter(g => g).map(g => {
+        return {
+            name: g.name,
+            health: g.health,
+            magic: g.magic,
+            physical: g.physical
+        }
+    }).concat(team2.formation.back.filter(g => g).map(g => {
+        return {
+            name: g.name,
+            health: g.health,
+            magic: g.magic,
+            physical: g.physical
+        }
+    })))
+
+    mapTeam(team1)
+    mapTeam(team2)
+
+    console.log('Team 1', team1.formation.front.filter(g => g).map(g => {
+        return {
+            name: g.name,
+            health: g.health,
+            magic: g.magic,
+            physical: g.physical
+        }
+    }).concat(team1.formation.back.filter(g => g).map(g => {
+        return {
+            name: g.name,
+            health: g.health,
+            magic: g.magic,
+            physical: g.physical
+        }
+    })))
+    console.log('Team 2', team2.formation.front.filter(g => g).map(g => {
+        return {
+            name: g.name,
+            health: g.health,
+            magic: g.magic,
+            physical: g.physical
+        }
+    }).concat(team2.formation.back.filter(g => g).map(g => {
+        return {
+            name: g.name,
+            health: g.health,
+            magic: g.magic,
+            physical: g.physical
+        }
+    })))
+
+    // Run 1000 sims to get the average stats
+    let team1Wins = 0
+    let team2Wins = 0
+    for (let i = 0; i < 1000; i++) {
+        const logs = await battle(team1, team2, `${Math.random()}`, false)
+        if (logs.result.winner === 1) {
+            team1Wins++
+        } else {
+            team2Wins++
+        }
+    }
+
+    console.log(`Team 1 wins: ${team1Wins}`)
+    console.log(`Team 2 wins: ${team2Wins}`)
+}
+
+module.exports = main
+
+// node scripts/simRealBattle.js 19566507-bafe-4a97-a5ee-0926ac9efcd8
+if (require.main === module) {
+    const battleId = process.argv[2]
+
+    main(battleId)
+    .then(() => {
+        console.log('Done')
+        process.exit(0)
+    })
+    .catch((error) => {
+        console.error('Error: ', error)
+        process.exit(1)
+    })
+}

package/scripts/validateBattle.js

@@ -1,70 +1,74 @@
-const axios = require('axios')
-const axiosRetry = require('axios-retry').default
-axiosRetry(axios, { 
-    retries: 3, 
-    retryDelay: axiosRetry.exponentialDelay
-})
-
-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)
-    })
-}
+const axios = require('axios')
+const axiosRetry = require('axios-retry').default
+axiosRetry(axios, { 
+    retries: 3, 
+    retryDelay: axiosRetry.exponentialDelay
+})
+const fs = require('fs')
+const path = require('path')
+
+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, true)
+
+        fs.writeFileSync(path.join(__dirname, 'output', `${battleId}_${Date.now()}.json`), JSON.stringify(logs, null, '\t'))
+
+        // 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 19566507-bafe-4a97-a5ee-0926ac9efcd8 86621513544048786694066938490119673052266855523096067323796322823978866460212
+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

@@ -1,101 +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)
-    })
-}
+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

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

package/utils/errors.js

@@ -1,30 +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
+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/mapGotchi.js

@@ -0,0 +1,119 @@
+const mapTeam = (team) => {
+    for(const gotchi of team.formation.front) {
+        if (gotchi) mapGotchi(gotchi)
+    }
+
+    for(const gotchi of team.formation.back) {
+        if (gotchi) mapGotchi(gotchi)
+    }
+}
+
+// This is copied/hacked from the mapGotchi function in the backend
+const mapGotchi = (gotchi) => {
+    const traitMaps = {
+        speed: {
+            baseFormula: 100,
+            multiplier: 1,
+            traitKey: 0,
+            isNegative: false
+        },
+        health: {
+            baseFormula: 'brs*0.85',
+            multiplier: 12,
+            traitKey: 0,
+            isNegative: true
+        },
+        crit: {
+            baseFormula: 0,
+            multiplier: 0.5,
+            traitKey: 1,
+            isNegative: false
+        },
+        armor: {
+            baseFormula: 0,
+            multiplier: 2,
+            traitKey: 1,
+            isNegative: true
+        },
+        evade: {
+            baseFormula: 0,
+            multiplier: 0.3,
+            traitKey: 2,
+            isNegative: false
+        },
+        resist: {
+            baseFormula: 0,
+            multiplier: 1,
+            traitKey: 2,
+            isNegative: true
+        },
+        magic: {
+            baseFormula: 'brs*0.35',
+            multiplier: 5,
+            traitKey: 3,
+            isNegative: false
+        },
+        physical: {
+            baseFormula: 'brs*0.35',
+            multiplier: 5,
+            traitKey: 3,
+            isNegative: true
+        },
+        accuracy: {
+            baseFormula: 50,
+            multiplier: 0.5,
+            traitKey: 45,
+            isNegative: false
+        }
+    }
+
+    const traitValue = (trait) => {
+        return trait < 50 ? 50 - trait : trait - 50 + 1
+    }
+
+    const onchainVals = [
+        gotchi.nrg,
+        gotchi.agg,
+        gotchi.spk,
+        gotchi.brn,
+        gotchi.eyc,
+        gotchi.eys
+    ]
+    // Convert trait value to in-game value
+    const traitValues = onchainVals.map(x => { return traitValue(x) })
+
+    // Map traits
+    for(const trait in traitMaps) { 
+        const traitMap = traitMaps[trait]
+        const onchainVal = onchainVals[traitMap.traitKey]
+
+        let base = traitMap.baseFormula
+
+        // If baseFormula is a string and contains a * then it is a formula
+        if (typeof traitMap.baseFormula === 'string' && traitMap.baseFormula.includes('*')) {
+            const formula = traitMap.baseFormula.split('*')
+
+            if (!gotchi[formula[0]]) throw new Error('Trait not found: ', formula[0])
+
+            base = Math.round(Number(gotchi[formula[0]]) * Number(formula[1]))
+        }
+
+        let newTrait
+        if (trait !== 'accuracy') {
+            if (traitMap.isNegative) {
+                newTrait = onchainVal < 50 ? Math.round(base + (traitValues[traitMap.traitKey] * traitMap.multiplier)) : base
+            } else {
+                newTrait = onchainVal < 50 ? base : Math.round(base + (traitValues[traitMap.traitKey] * traitMap.multiplier))
+            }
+        } else {
+            newTrait = base + ((traitValues[4] + traitValues[5]) * traitMap.multiplier)
+        }
+
+        if (newTrait !== gotchi[trait]) gotchi[trait] = newTrait
+    }
+}
+
+module.exports = {
+    mapGotchi,
+    mapTeam
+}