gotchi-battler-game-logic 1.0.0 → 2.0.0

package/scripts/balancing/fixTrainingGotchis.js

@@ -0,0 +1,260 @@
+const fs = require('fs')
+const trainingGotchis = require('./v1.7/training_gotchis.json')
+
+const specials = [
+    {
+        "id": 1,
+        "class": "Ninja",
+        "name": "Spectral strike",
+        "cooldown": 0,
+        "leaderPassive": "Sharpen blades"
+    },
+    {
+        "id": 2,
+        "class": "Enlightened",
+        "name": "Meditate",
+        "cooldown": 0,
+        "leaderPassive": "Cloud of Zen"
+    },
+    {
+        "id": 3,
+        "class": "Cleaver",
+        "name": "Cleave",
+        "cooldown": 2,
+        "leaderPassive": "Frenzy"
+    },
+    {
+        "id": 4,
+        "class": "Tank",
+        "name": "Taunt",
+        "cooldown": 0,
+        "leaderPassive": "Fortify"
+    },
+    {
+        "id": 5,
+        "class": "Cursed",
+        "name": "Curse",
+        "cooldown": 0,
+        "leaderPassive": "Spread the fear"
+    },
+    {
+        "id": 6,
+        "class": "Healer",
+        "name": "Blessing",
+        "cooldown": 0,
+        "leaderPassive": "Cleansing Aura"
+    },
+    {
+        "id": 7,
+        "class": "Mage",
+        "name": "Thunder",
+        "cooldown": 2,
+        "leaderPassive": "Channel the coven"
+    },
+    {
+        "id": 8,
+        "class": "Troll",
+        "name": "Devestating Smash",
+        "cooldown": 2,
+        "leaderPassive": "Clan momentum"
+    }
+]
+
+const classes = ['Ninja','Enlightened','Cleaver','Tank','Cursed','Healer', 'Mage', 'Troll']
+const powerLevels = ['Godlike', 'Mythical', 'Legendary', 'Rare', 'Uncommon', 'Common', 'Garbage']
+
+// This is copied/hacked from the mapGotchi function in the backend
+const fixTraits = (gotchi) => {
+    const traitMaps = {
+        speed: {
+            baseFormula: 100,
+            multiplier: 1,
+            traitKey: 0,
+            isNegative: false
+        },
+        health: {
+            baseFormula: 'brs*0.75',
+            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.25',
+            multiplier: 5,
+            traitKey: 3,
+            isNegative: false
+        },
+        physical: {
+            baseFormula: 'brs*0.25',
+            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
+    }
+}
+
+const addAvgGotchs = () => {
+    const statsToOverwrite = ["speed", "health", "crit", "armor", "evade", "resist", "accuracy"]
+
+    const avgGotchis = [];
+
+    // Add magic gotchis
+    ['magic', 'physical'].forEach((brainValue) => {
+        powerLevels.forEach((powerLevel) => {
+            classes.forEach((className) => {
+                // Find all gotchis with the same class and power level
+                // Names are in the format "Godlike ++++ Ninja"
+                const gotchis = trainingGotchis.filter(gotchi => gotchi.name.includes(powerLevel) && gotchi.name.includes(className))
+
+                // Copy over one of the gotchis
+                const avgGotchi = JSON.parse(JSON.stringify(gotchis[0]))
+
+                // Add an id
+                avgGotchi.id = trainingGotchis.length + avgGotchis.length + 1
+
+                // Overwrite the name
+                avgGotchi.name = `${powerLevel} avg-${brainValue} ${className}`
+
+                // Overwrite the stats
+                statsToOverwrite.forEach((stat) => {
+                    const total = gotchis.reduce((acc, gotchi) => acc + gotchi[stat], 0)
+                    avgGotchi[stat] = Math.round(total / gotchis.length)
+                })
+
+                // Get the highest/lowest magic value
+                const magicValues = gotchis.map(gotchi => gotchi.magic)
+                const highestMagic = Math.max(...magicValues)
+                const lowestMagic = Math.min(...magicValues)
+
+                // Get the highest/lowest physical value
+                const physicalValues = gotchis.map(gotchi => gotchi.physical)
+                const highestPhysical = Math.max(...physicalValues)
+                const lowestPhysical = Math.min(...physicalValues)
+
+                // If this is a magic gotchi then set the magic value to the highest
+                if (brainValue === 'magic') {
+                    avgGotchi.magic = highestMagic
+                    avgGotchi.physical = lowestPhysical
+                    avgGotchi.attack = 'magic'
+                } else {
+                    avgGotchi.magic = lowestMagic
+                    avgGotchi.physical = highestPhysical
+                    avgGotchi.attack = 'physical'
+                }
+
+                avgGotchis.push(avgGotchi)
+            })
+        })
+    })
+
+    trainingGotchis.push(...avgGotchis)
+}
+
+// Sort the gotchis by id
+trainingGotchis.sort((a, b) => a.id - b.id)
+
+trainingGotchis.forEach(gotchi => {
+    // Add special to gotchi
+    const special = specials.find(special => special.id === gotchi.specialId)
+
+    if (!special) throw new Error(`Special not found for gotchi: "${gotchi.name}"`)
+
+    gotchi.special = special
+
+    // Fix names
+    // If name ends with a + or - then add the class name at the end
+    if (gotchi.name.endsWith('+') || gotchi.name.endsWith('-')) {
+        gotchi.name = `${gotchi.name} ${classes[gotchi.specialId - 1]}`
+    }
+
+    // Remove extra fields
+    delete gotchi.tier
+    delete gotchi.class
+    delete gotchi.stats_brs
+
+    // Make sure the gotchi has the correct traits
+    fixTraits(gotchi)
+})
+
+// Add the average gotchis
+addAvgGotchs()
+
+// Write the updated trainingGotchis to a new file
+fs.writeFileSync('./training_gotchis1.json', JSON.stringify(trainingGotchis, null, '\t'))
+
+// node scripts/balancing/fixTrainingGotchis.js

package/scripts/balancing/processSims.js

@@ -0,0 +1,230 @@
+require('dotenv').config()
+const fs = require('fs')
+const path = require('path')
+const { Storage } = require('@google-cloud/storage')
+const storage = new Storage()
+
+if (!process.env.CLOUD_RUN_JOB) {
+    // Use key file locally
+    process.env.GOOGLE_APPLICATION_CREDENTIALS = path.join(__dirname, '../../keyfile.json')
+}
+
+const downloadAndCombineResults = async (executionId, numOfTasks) => {
+    const results = []
+
+    // Download all the files in batches of 100
+    for (let i = 0; i < numOfTasks; i += 100) {
+        const batch = []
+
+        for (let j = 0; j < 100; j++) {
+            if (i + j < numOfTasks) {
+                batch.push(storage.bucket(process.env.SIMS_BUCKET).file(`${executionId}_${i + j}.json`).download())
+            }
+        }
+
+        const batchResults = await Promise.all(batch)
+        results.push(...batchResults)
+
+        console.log(`Downloaded ${i + batchResults.length} files`)
+    }
+
+    const combinedResults = []
+
+    for (const result of results) {
+        combinedResults.push(JSON.parse(result.toString()))
+    }
+
+    return combinedResults
+}
+
+const classes = ['Ninja','Enlightened','Cleaver','Tank','Cursed','Healer', 'Mage', 'Troll']
+
+const calculateKpis = (data) => {
+    // Extract wins values
+    const wins = data.map(item => item.wins);
+
+    // Calculate the mean of wins
+    const winsMean = wins.reduce((sum, value) => sum + value, 0) / wins.length;
+
+    // Calculate the wins per slot
+    const winsPerSlot = winsMean / 5
+
+    // Calculate the standard deviation of wins
+    const winsVariance = wins.reduce((sum, value) => sum + Math.pow(value - winsMean, 2), 0) / (wins.length - 1);
+    const winsStdev = Math.sqrt(winsVariance)
+
+    // Calculate Interquartile Range (IQR)
+    wins.sort((a, b) => a - b)
+    const q1 = wins[Math.floor(wins.length / 4)]
+    const q3 = wins[Math.floor(wins.length * 3 / 4)]
+    const iqr = q3 - q1
+
+    // Analyse top and bottom quartiles
+    const topQuartile = data.filter(item => item.wins >= q3)
+    const bottomQuartile = data.filter(item => item.wins <= q1)
+    const topQuartileWins = topQuartile.map(item => item.wins)
+    const bottomQuartileWins = bottomQuartile.map(item => item.wins)
+    const topQuartileWinsMean = topQuartileWins.reduce((sum, value) => sum + value, 0) / topQuartileWins.length
+    const bottomQuartileWinsMean = bottomQuartileWins.reduce((sum, value) => sum + value, 0) / bottomQuartileWins.length
+
+    // Non leader global KPIs
+     
+
+    const results = {
+        winsMean: winsMean.toFixed(2),
+        winsPerSlot: winsPerSlot.toFixed(2),
+        winsStdev: winsStdev.toFixed(2),
+        iqr: iqr.toFixed(2),
+        topQuartileWinsMean: topQuartileWinsMean.toFixed(2),
+        bottomQuartileWinsMean: bottomQuartileWinsMean.toFixed(2),
+        classes: {}
+    }
+
+    
+    classes.forEach((className, i) => {
+        /**
+         * Get leader KPIs
+         * Leaders are in slot 1
+         */
+
+        // Names are in format "G|avg|1_B" 
+        // G is power level, avg is trait combo, 1 is class number, B is formation position
+        const leaderWins = data.filter(item => item.slot1.includes(`${i + 1}`)).map(item => item.wins)
+
+        const leaderWinsMean = leaderWins.reduce((sum, value) => sum + value, 0) / leaderWins.length;
+        const leaderWinsVariance = leaderWins.reduce((sum, value) => sum + Math.pow(value - leaderWinsMean, 2), 0) / (leaderWins.length - 1);
+        const leaderWinsStdev = Math.sqrt(leaderWinsVariance)
+
+        // Calculate Interquartile Range (IQR)
+        leaderWins.sort((a, b) => a - b)
+        const leaderQ1 = leaderWins[Math.floor(leaderWins.length / 4)]
+        const leaderQ3 = leaderWins[Math.floor(leaderWins.length * 3 / 4)]
+        const leaderIqr = leaderQ3 - leaderQ1
+
+        // Analyse top and bottom quartiles
+        const leaderTopQuartile = data.filter(item => item.slot1.includes(`${i + 1}`) && item.wins >= leaderQ3)
+        const leaderBottomQuartile = data.filter(item => item.slot1.includes(`${i + 1}`) && item.wins <= leaderQ1)
+        const leaderTopQuartileWins = leaderTopQuartile.map(item => item.wins)
+        const leaderBottomQuartileWins = leaderBottomQuartile.map(item => item.wins)
+        const leaderTopQuartileWinsMean = leaderTopQuartileWins.reduce((sum, value) => sum + value, 0) / leaderTopQuartileWins.length
+        const leaderBottomQuartileWinsMean = leaderBottomQuartileWins.reduce((sum, value) => sum + value, 0) / leaderBottomQuartileWins.length
+
+        /**
+         * Get non-leader KPIs
+         * Non leaders are in slots 2, 3, 4, 5 
+         */
+
+        // Get the teams where the class is in the non-leader slots
+        const nonLeaderTeams = data.filter(item => item.slot2.includes(`${i + 1}`) || item.slot3.includes(`${i + 1}`) || item.slot4.includes(`${i + 1}`) || item.slot5.includes(`${i + 1}`))
+
+        const totalNonLeaderWins = nonLeaderTeams.reduce((sum, item) => {
+            const team = [item.slot2, item.slot3, item.slot4, item.slot5]
+            const occurrences = team.filter(slot => slot.includes(`${i + 1}`)).length
+            return sum + item.wins / 5 * occurrences
+        }, 0)
+
+        // Get total non-leader occurrences
+        const totalOccurrences = nonLeaderTeams.reduce((sum, item) => {
+            const team = [item.slot2, item.slot3, item.slot4, item.slot5]
+            return sum + team.filter(slot => slot.includes(`${i + 1}`)).length
+        }, 0)
+
+        // Calulate win per non-leader occurance
+        const winsPerOccurance = totalNonLeaderWins / totalOccurrences
+
+
+        results.classes[className] = {
+            leader: {
+                winsMean: leaderWinsMean.toFixed(2),
+                winsMeanVsGlobal: (leaderWinsMean - winsMean).toFixed(2),
+                winsMeanVsGlobalPercentage: ((leaderWinsMean - winsMean) / winsMean * 100).toFixed(2),
+                winsStdev: leaderWinsStdev.toFixed(2),
+                winsStdevVsGlobal: (leaderWinsStdev - winsStdev).toFixed(2),
+                winsStdevVsGlobalPercentage: ((leaderWinsStdev - winsStdev) / winsStdev * 100).toFixed(2),
+                iqr: leaderIqr.toFixed(2),
+                iqrVsGlobal: (leaderIqr - iqr).toFixed(2),
+                iqrVsGlobalPercentage: ((leaderIqr - iqr) / iqr * 100).toFixed(2),
+                topQuartileWinsMean: leaderTopQuartileWinsMean.toFixed(2),
+                topQuartileWinsMeanVsGlobal: (leaderTopQuartileWinsMean - topQuartileWinsMean).toFixed(2),
+                topQuartileWinsMeanVsGlobalPercentage: ((leaderTopQuartileWinsMean - topQuartileWinsMean) / topQuartileWinsMean * 100).toFixed(2),
+                bottomQuartileWinsMean: leaderBottomQuartileWinsMean.toFixed(2),
+                bottomQuartileWinsMeanVsGlobal: (leaderBottomQuartileWinsMean - bottomQuartileWinsMean).toFixed(2),
+                bottomQuartileWinsMeanVsGlobalPercentage: ((leaderBottomQuartileWinsMean - bottomQuartileWinsMean) / bottomQuartileWinsMean * 100).toFixed(2)
+            },
+            nonLeader: {
+                winsPerOccurance: winsPerOccurance.toFixed(2),
+                winsPerOccuranceVsGlobal: (winsPerOccurance - winsPerSlot).toFixed(2),
+                winsPerOccuranceVsGlobalPercentage: ((winsPerOccurance - winsPerSlot) / winsPerSlot * 100).toFixed(2)
+            }
+        }
+    })
+
+    return results
+}
+
+const main = async (executionId, numOfTasks, gameLogicVersion) => {
+    const gameLogicConstants = require(`../../game-logic/${gameLogicVersion}/constants.js`)
+
+    const data = await downloadAndCombineResults(executionId, numOfTasks)
+
+    const availablePowerLevels = {
+        'G': 'Godlike',
+        'M': 'Mythical',
+        'L': 'Legendary',
+        'R': 'Rare',
+        'U': 'Uncommon',
+        'C': 'Common'
+    }
+
+    // Find power levels from data
+    // slot1 is in the format "G|avg|1_B" where the first character is the power level
+    // Find the unique first characters in slot1
+    const powerLevels = Array.from(new Set(data.map(item => item.slot1[0])))
+
+    // Calculate KPIs for each power level
+    const results = {
+        metadata: {
+            gameLogicVersion: gameLogicVersion,
+            gameLogicConstants: gameLogicConstants,
+            powerLevels: powerLevels.map(powerLevel => availablePowerLevels[powerLevel])
+        },
+        results: {}
+    }
+    powerLevels.forEach((powerLevel) => {
+        const powerLevelData = data.filter(item => item.slot1[0] === powerLevel)
+        results.results[availablePowerLevels[powerLevel]] = calculateKpis(powerLevelData)
+    })
+
+    if(process.env.CLOUD_RUN_JOB) {
+        const bucket = storage.bucket('gotchi-battler-sims-v1-7-1')
+        
+        // Get number of files in the bucket
+        const [files] = await bucket.getFiles()
+        const numOfFiles = files.length
+
+        // Write the results to a file
+        await bucket.file(`${numOfFiles + 1}.json`).save(JSON.stringify(results, null, 2))
+    } else {
+        // Write to /scripts/balancing/output/<executionId>.json
+        fs.writeFileSync(path.join(__dirname, '/output/', `${executionId}.json`), JSON.stringify(results, null, 2))
+    }
+}
+
+module.exports = main
+
+// node scripts/balancing/processSims.js avg-sims-99hzc 7920 v1.7
+if (require.main === module) {
+    const executionId = process.env.EXECUTION_ID || process.argv[2]
+    const numOfTasks = parseInt(process.env.NUM_OF_TASKS) || parseInt(process.argv[3])
+    const gameLogicVersion = process.env.GAME_LOGIC_VERSION || process.argv[4]
+
+    main(executionId, numOfTasks, gameLogicVersion)
+        .then(() => {
+            console.log('Done')
+            process.exit(0)
+        })
+        .catch((error) => {
+            console.error(error)
+            process.exit(1)
+        })
+}