gotchi-battler-game-logic 1.0.0 → 2.0.0

package/scripts/balancing/sims.js

@@ -0,0 +1,278 @@
+require('dotenv').config()
+const path = require('path')
+const crypto = require('crypto')
+const { Storage } = require('@google-cloud/storage')
+const storage = new Storage()
+const classes = ['Ninja','Enlightened','Cleaver','Tank','Cursed','Healer', 'Mage', 'Troll']
+
+/**
+ * Create teams from all the possible trait combinations from the class combination
+ * @param {Array} classCombo The class combinations
+ * @param {Array} classTraitCombos The trait combinations for each class
+ * @param {Array} powerLevels The power levels
+ * @param {Array} trainingGotchis The training gotchis
+ * @param {Boolean} useTraitSets If false then exhaustive search is done, if true then only the trait sets are used
+ * @returns {Object} A team object
+ */
+const createTeamIndexes = (classCombos, classTraitCombos, powerLevels, trainingGotchis, useTraitSets) => {
+
+    const teams = []
+
+    if (!useTraitSets) {
+        classCombos.forEach(classCombo => {
+            powerLevels.forEach(powerLevel => {
+                // Loop over each class in the classCombo
+                for(let i = 0; i < classCombo.length; i++) {
+                    classTraitCombos[classCombo[i] - 1].forEach(traitSet1 => {
+                        for (let j = i + 1; j < classCombo.length; j++) {
+                            classTraitCombos[classCombo[j] - 1].forEach(traitSet2 => {
+                                for (let k = j + 1; k < classCombo.length; k++) {
+                                    classTraitCombos[classCombo[k] - 1].forEach(traitSet3 => {
+                                        for (let l = k + 1; l < classCombo.length; l++) {
+                                            classTraitCombos[classCombo[l] - 1].forEach(traitSet4 => {
+                                                for (let m = l + 1; m < classCombo.length; m++) {
+                                                    classTraitCombos[classCombo[m] - 1].forEach(traitSet5 => {
+                                                        const team = [];
+
+                                                        [traitSet1, traitSet2, traitSet3, traitSet4, traitSet5].forEach((traitSet, index) => {
+                                                            const gotchiName = `${powerLevel} ${traitSet} ${classes[classCombo[index] - 1]}`
+                                                            const gotchi = trainingGotchis.find(gotchi => {
+                                                                return gotchi.name === gotchiName
+                                                            })
+
+                                                            if (!gotchi) throw new Error(`Gotchi not found: "${gotchiName}"`)
+
+                                                            team.push(gotchi.id)
+                                                        })
+
+                                                        teams.push(team)
+                                                    })
+                                                }
+                                            })
+                                        }
+                                    })
+                                }
+                            })
+                        }
+                    })
+                }
+            })
+        })
+    } else {
+        classCombos.forEach(classCombo => {
+            powerLevels.forEach(powerLevel => {
+                // Loop over how many trait sets there are in the classTraitCombos array
+                classTraitCombos[0].forEach((x, i) => {
+                    const team = []
+                    classCombo.forEach(classIndex => {
+                        const gotchiName = `${powerLevel} ${classTraitCombos[classIndex - 1][i]} ${classes[classIndex - 1]}`
+                        const gotchi = trainingGotchis.find(gotchi => {
+                            return gotchi.name === gotchiName
+                        })
+    
+                        if (!gotchi) throw new Error(`Gotchi not found: "${gotchiName}"`)
+                        
+                        team.push(gotchi.id)
+                    })
+                    teams.push(team)
+                })
+            })
+        })
+    }
+
+    
+
+    return teams
+}
+
+/**
+ * Creates an in game team object from a team index
+ * @param {Array} teamIndex An array of gotchi ids
+ * @returns {Object} An in game team object
+ */
+const createTeamFromTeamIndex = (teamIndex, trainingGotchis, setTeamPositions) => {
+    const team = {
+        formation: {
+            front: [null, null, null, null, null],
+            back: [null, null, null, null, null],
+        },
+        leader: null,
+        name: null,
+        owner: null
+    }
+
+    // Put all in the back row for now
+    team.formation.back = teamIndex.map(gotchiId => {
+        const gotchi = trainingGotchis.find(gotchi => gotchi.id === gotchiId)
+
+        if (!gotchi) throw new Error(`Gotchi not found with id: "${gotchiId}"`)
+
+        return gotchi
+    })
+
+    team.leader = team.formation.back[0].id
+    team.name = `${team.formation.back[0].name[0]} ${teamIndex}` // e.g. "M 1,2,3,4,5"
+    team.owner = '0x0000000000000000000000000000000000000000'
+
+    // Set the team positions for each gotchi being in the front or back row
+    setTeamPositions(team)
+
+    return team
+}
+
+const getGotchisSimNameFromTeam = (team) => {
+    const names = [];
+
+    [0,1,2,3,4].forEach(i => {
+        const gotchi = team.formation.back[i] || team.formation.front[i]
+        const position  = !!team.formation.back[i] ? 'B' : 'F'
+
+        const nameParts = gotchi.name.split(' ')
+        // Return e.g. "R|++++|1_B"
+        names.push(`${nameParts[0][0]}|${nameParts[1]}|${classes.indexOf(nameParts[2]) + 1}_${position}`)
+    })  
+    return names
+}
+
+const runSims = async (simsVersion, gameLogicVersion, simsPerMatchup) => {
+    const trainingGotchis = require(`./${simsVersion}/training_gotchis.json`)
+    const classCombos = require(`./${simsVersion}/class_combos.js`)
+    const classTraitCombos = require(`./${simsVersion}/trait_combos.json`)
+    const setTeamPositions = require(`./${simsVersion}/setTeamPositions`)
+    const gameLogic = require("../../game-logic")[gameLogicVersion].gameLoop
+
+    const attackingPowerLevels = ['Godlike']
+    const defendingPowerLevels = ['Godlike', 'Mythical', 'Legendary']
+    
+    const attackingTeamIndexes = createTeamIndexes(classCombos, classTraitCombos, attackingPowerLevels, trainingGotchis, true)
+
+    // console.log(`Running sims for ${attackingTeamIndexes.length} attacking teams`)
+
+    const defendingTeamIndexes = createTeamIndexes(classCombos, classTraitCombos, defendingPowerLevels, trainingGotchis, true)
+
+    // console.log(`Against ${defendingTeamIndexes.length} defending teams`)
+
+    // Which attacking team are we running the sims on?
+    // If running on Cloud Run, use the task index
+    // If running locally, use the command line argument or default to 0
+    const attackingTeamIndex = process.env.CLOUD_RUN_TASK_INDEX ? parseInt(process.env.CLOUD_RUN_TASK_INDEX) : parseInt(process.argv[2]) || 0
+
+    // Get the attacking team
+    const attackingTeam = createTeamFromTeamIndex(attackingTeamIndexes[attackingTeamIndex], trainingGotchis, setTeamPositions)
+    const gotchiSimNames = getGotchisSimNameFromTeam(attackingTeam)
+    // Run the sims for each defending team
+    const results = {
+        id: attackingTeamIndex,
+        slot1: gotchiSimNames[0],
+        slot2: gotchiSimNames[1],
+        slot3: gotchiSimNames[2],
+        slot4: gotchiSimNames[3],
+        slot5: gotchiSimNames[4],
+        wins: 0,
+        draws: 0,
+        losses: 0
+    }
+
+    defendingPowerLevels.forEach(powerLevel => {
+        results[`wins${powerLevel}`] = 0
+        results[`draws${powerLevel}`] = 0
+        results[`losses${powerLevel}`] = 0
+    })
+
+    console.time(`Sims for ${attackingTeam.name}`)
+
+    defendingTeamIndexes.forEach((defendingTeamIndex, i) => {
+        const defendingTeam = createTeamFromTeamIndex(defendingTeamIndex, trainingGotchis, setTeamPositions)
+        
+        let matchupWins = 0
+        let matchupDraws = 0
+        let matchupLosses = 0
+
+        // Run the sims
+        Array(simsPerMatchup).fill(null).forEach(() => {
+            // Quit early if result is already determined
+            if (matchupWins >= simsPerMatchup / 2 || 
+                matchupLosses >= simsPerMatchup / 2 || 
+                matchupDraws >= simsPerMatchup / 2) return
+
+            const logs = gameLogic(attackingTeam, defendingTeam, crypto.randomBytes(32).toString('hex'))
+
+            if (logs.result.winner === 1) matchupWins++
+            if (logs.result.winner === 0) matchupDraws++
+            if (logs.result.winner === 2) matchupLosses++
+        })
+
+        // Get first letter of oppeonent team name to determine power level
+        const powerLevel = defendingPowerLevels.find(name => name[0] === defendingTeam.name[0]) 
+
+        if (matchupWins >= simsPerMatchup / 2) {
+            results.wins++
+            results[`wins${powerLevel}`]++
+        }
+
+        if (matchupDraws >= simsPerMatchup / 2) {
+            results.draws++
+            results[`draws${powerLevel}`]++
+        }
+
+        if (matchupLosses >= simsPerMatchup / 2) {
+            results.losses++
+            results[`losses${powerLevel}`]++
+        }
+    })
+
+    console.timeEnd(`Sims for ${attackingTeam.name}`)
+
+    // Check total wins, draws, losses to make sure they add up to number of defending teams
+    const totalMatchups = results.wins + results.draws + results.losses
+    if (totalMatchups !== defendingTeamIndexes.length) {
+        throw new Error(`Total matchups (${totalMatchups}) does not match number of defending teams (${defendingTeamIndexes.length})`)
+    }
+
+    if (process.env.CLOUD_RUN_JOB && process.env.SIMS_BUCKET) {
+        // Save as JSON to GCS
+        try {
+            await storage.bucket(process.env.SIMS_BUCKET).file(`${process.env.CLOUD_RUN_EXECUTION}_${attackingTeamIndex}.json`).save(JSON.stringify(results))
+        } catch (err) {
+            throw err
+        }
+        
+    } else {
+       console.log('Results', results)
+
+        // Test saving to GCS
+        if (false) {
+            process.env.GOOGLE_APPLICATION_CREDENTIALS = path.join(__dirname, '../../keyfile.json')
+            try {
+                await storage.bucket(process.env.SIMS_BUCKET).file(`avg-sims-znw68_${attackingTeamIndex}.json`).save(JSON.stringify(results))
+            } catch (err) {
+                throw err
+            }
+        }
+    }
+}
+
+module.exports = runSims
+
+// If running from the command line, run the sims
+// 1st argument is the attacking team index
+// 2nd argument is the sims version
+// 3rd argument is the game logic version
+// 4th argument is the number of sims per matchup
+// node scripts/balancing/sims.js 0 v1.7.1 v1.7 3 true
+if (require.main === module) {
+    const simsVersion = process.env.SIMS_VERSION || process.argv[3] || 'v1.7'
+    const gameLogicVersion = process.env.GAME_LOGIC_VERSION || process.argv[4] || 'v1.7'
+    const simsPerMatchup = parseInt(process.env.SIMS_PER_MATCHUP) || parseInt(process.argv[5]) || 3
+    const useAvg = process.env.USE_AVG || process.argv[6] === 'true' || false
+
+    runSims(simsVersion, gameLogicVersion, simsPerMatchup, useAvg)
+        .then(() => {
+            console.log('Done')
+            process.exit(0)
+        })
+        .catch((err) => {
+            console.error(err)
+            process.exit(1)
+        })
+}

package/scripts/balancing/v1.7/class_combos.js

@@ -0,0 +1,44 @@
+const generateClassCombinations = () => {
+    // Generate combinations of the 8 classes for the 4 non-leader spots
+    const combinations = []
+
+    for (let i = 1; i <= 8; i++) {
+        for (let j = 1; j <= 8; j++) {
+            for (let k = 1; k <= 8; k++) {
+                for (let l = 1; l <= 8; l++) {
+                    combinations.push([i, j, k, l].sort())
+                }
+            }
+        }
+    }
+
+    // Remove duplicate combinations, so [1,1,1,1] is allowed but [1,1,1,2] and [1,1,2,1] are duplicates
+    // Keep as numbers for now, convert to strings to remove duplicates, then convert back to numbers
+    const uniqueCombinations = [...new Set(combinations.map((combination) => combination.join('')))].map((combination) => combination.split('').map((number) => parseInt(number)))
+
+    return uniqueCombinations
+}
+
+const getCombinationsForALeader = (leaderClass) => {
+    const combinations = generateClassCombinations()
+
+    const combinationsForALeader = combinations.map((combination) => {
+        return [leaderClass, ...combination]
+    })
+
+    return combinationsForALeader
+}
+
+const getAllClassCombos = () => {
+    const allClassCombos = []
+
+    for (let i = 1; i <= 8; i++) {
+        allClassCombos.push(...getCombinationsForALeader(i))
+    }
+
+    return allClassCombos
+}
+
+const allClassCombos = getAllClassCombos()
+
+module.exports = allClassCombos

package/scripts/balancing/v1.7/setTeamPositions.js

@@ -0,0 +1,105 @@
+const trainingGotchis = require('./training_gotchis.json')
+
+const getFrontRowScore = (gotchiId, leaderId) => {
+    const gotchi = trainingGotchis.find(gotchi => gotchi.id === gotchiId)
+    const leader = trainingGotchis.find(gotchi => gotchi.id === leaderId)
+
+    if (gotchi.name.includes(' avg ')) {
+        
+        if (gotchi.specialId === 2) {
+            // Enlightened are the best up front
+            return 6
+        } else if (leader.specialId === 6 && gotchi.specialId === 6) {
+            // Healer with a healer leader are the second best up front
+            return 5
+        } else if (gotchi.specialId === 5) {
+            // Cursed are the third best up front
+            return 4
+        } else if (gotchi.specialId === 6) {
+            // Healers do ok
+            return 2
+        } else if (gotchi.specialId === 7) {
+            // Mages always go to the back
+            return 0
+        } else {
+            return 1
+        }
+    }
+
+    // High health gotchis do well up front
+    const isHighHealth = gotchi.nrg < 50
+
+    // High armor gotchis do well up front
+    const isLowAgg = gotchi.agg < 50
+
+    // High evasion gotchis do well up front
+    const isHighSpk = gotchi.spk >= 50
+
+    const isLowBrn = gotchi.brn < 50
+
+    // Create a score from 0 to 6 based on how much they favour the front
+
+    let score = 0
+
+    if (gotchi.specialId === 2) score +=2 // Enlightened
+    if (isHighHealth) score++
+    if (isLowBrn) score++
+    if (isLowAgg) score++
+    if (isHighSpk) score++
+
+    return score
+} 
+
+module.exports = (team) => {
+    // All gotchis are currently in the back row
+    // Get the score for each gotchi for how much they favour the front row
+    const teamFrontRowScores = team.formation.back.map((gotchi) => getFrontRowScore(gotchi.id, team.leader)); 
+    
+    [0,1,2,3,4].forEach((i) => {
+        const gotchi = team.formation.back[i]
+        const score = teamFrontRowScores[i]
+
+        // If score is >= 3 then move to front row
+        if (score >= 3) {
+            team.formation.front[i] = gotchi
+            team.formation.back[i] = null
+        }
+    })
+
+    // If you have 5 gotchis in the front then send the lowest 2 to the back
+    const frontGotchis = team.formation.front.filter(gotchi => gotchi)
+    if (frontGotchis.length === 5) {
+        // Sort the gotchis by score in ascending order (lowest score first)
+        const orderedGotchis = JSON.parse(JSON.stringify(frontGotchis)).sort((a, b) => getFrontRowScore(a.id, team.leader) - getFrontRowScore(b.id, team.leader));
+
+        // Loop through the front row and the first 2 gotchis that have a score of either orderedGotchis[0] or orderedGotchis[1] move to the back
+        let hasMoved = 0
+        team.formation.front.forEach((gotchi, i) => {
+            if (hasMoved < 2 && (gotchi.id === orderedGotchis[0].id || gotchi.id === orderedGotchis[1].id)) {
+                team.formation.back[i] = gotchi
+                team.formation.front[i] = null
+
+                hasMoved++
+            }
+        })
+    }
+
+    // If you have 5 gotchis in the back then send the highest 2 to the front
+    const backGotchis = team.formation.back.filter(gotchi => gotchi)
+    if (backGotchis.length === 5) {
+        // Sort the gotchis by score in descending order (highest score first)
+        const orderedGotchis = JSON.parse(JSON.stringify(backGotchis)).sort((a, b) => getFrontRowScore(b.id, team.leader) - getFrontRowScore(a.id, team.leader));
+
+        // Loop through the back row and the first 2 gotchis that have a score of either orderedGotchis[0] or orderedGotchis[1] move to the front
+        let hasMoved = 0
+        team.formation.back.forEach((gotchi, i) => {
+            if (hasMoved < 2 && (gotchi.id === orderedGotchis[0].id || gotchi.id === orderedGotchis[1].id)) {
+                team.formation.front[i] = gotchi
+                team.formation.back[i] = null
+
+                hasMoved++
+            }
+        })
+    }
+}
+