gotchi-battler-game-logic 2.0.8 → 4.0.0

package/scripts/balancing/createTrainingGotchis.js

@@ -0,0 +1,267 @@
+const fs = require('fs')
+
+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 powerLevels = ['Godlike', 'Mythical', 'Legendary', 'Rare', 'Uncommon', 'Common', 'Garbage']
+const traitCombos = [
+    '++++', '+++-', '++-+', '++--', '+-++', '+-+-', '+--+', '+---', 
+    '-+++', '-++-', '-+-+', '-+--', '--++', '--+-', '---+', '----'
+]
+const classes = ['Ninja','Enlightened','Cleaver','Tank','Cursed','Healer', 'Mage', 'Troll']
+
+
+// Create training gotchi objects like below for all combinations of powerLevels, traitCombos and classes
+// {
+//     "id": 1,
+//     "snapshotBlock": 0,
+//     "onchainId": 1000001,
+//     "name": "Godlike ++++ Ninja",
+//     "brs": 783,
+//     "nrg": 110,
+//     "agg": 98,
+//     "spk": 101,
+//     "brn": 107,
+//     "eyc": 94,
+//     "eys": 94,
+//     "kinship": 0,
+//     "xp": 0,
+//     "speed": 161,
+//     "health": 587,
+//     "crit": 25,
+//     "armor": 0,
+//     "evade": 16,
+//     "resist": 0,
+//     "magic": 486,
+//     "physical": 196,
+//     "accuracy": 95,
+//     "attack": "magic",
+//     "actionDelay": 0.617,
+//     "specialId": 1,
+//     "svgFront": "https://storage.googleapis.com/gotchi-battler-qa_gotchis/training/ninja_godlike_front.png",
+//     "svgBack": "https://storage.googleapis.com/gotchi-battler-qa_gotchis/training/ninja_godlike_back.png",
+//     "svgLeft": "https://storage.googleapis.com/gotchi-battler-qa_gotchis/training/ninja_godlike_left.png",
+//     "svgRight": "https://storage.googleapis.com/gotchi-battler-qa_gotchis/training/ninja_godlike_right.png",
+//     "createdAt": "2023-09-09 12:10:01",
+//     "updatedAt": "2024-06-05 16:34:00",
+//     "special": {
+//         "id": 1,
+//         "class": "Ninja",
+//         "name": "Spectral strike",
+//         "cooldown": 0,
+//         "leaderPassive": "Sharpen blades"
+//     }
+// }
+
+const main = (version) => {
+    const trainingGotchisTraits = require(`./v${version}/training_gotchis_traits.json`)
+    const { mapGotchi } = require(`./v${version}/mapGotchi.js`)
+
+    const trainingGotchis = []
+
+    let id = 1
+    traitCombos.forEach((t) => {
+        powerLevels.forEach((p) => {
+            for (let index = 0; index < t.length; index ++) {
+                const c = t[index]
+
+                const gotchi = {
+                    id,
+                    snapshotBlock: 0,
+		            onchainId: 1000000 + id,
+                }
+
+                // Based on the position of the trait in the traitCombos array, we can determine the class of the gotchi
+                // e.g. if the first trait is positive then add ninja, if it's negative then add enlightened
+                const className = classes[index * 2 + (c === '+' ? 0 : 1)]
+
+                // e.g Godlike ++++ Mage
+                gotchi.name = `${p} ${t} ${className}`
+
+                /**
+                 * This is for versions <= 1.7.2
+                 */
+                // const trainingGotchiTraits = trainingGotchisTraits[p.toLowerCase()][className.toLowerCase()]
+
+                // if (!trainingGotchiTraits) {
+                //     throw new Error(`No traits found for ${p} ${className}`)
+                // }
+
+                // gotchi.brs = trainingGotchiTraits.brs
+                // gotchi.nrg = trainingGotchiTraits.nrg[t[0] === '-' ? 0 : 1]
+                // gotchi.agg = trainingGotchiTraits.agg[t[1] === '-' ? 0 : 1]
+                // gotchi.spk = trainingGotchiTraits.spk[t[2] === '-' ? 0 : 1]
+                // gotchi.brn = trainingGotchiTraits.brn[t[3] === '-' ? 0 : 1]
+                // gotchi.eys = trainingGotchiTraits.eys[1] // These are always in index 1
+                // gotchi.eyc = trainingGotchiTraits.eyc[1] // These are always in index 1
+
+                /**
+                 * This is for versions >= 1.7.3
+                 */
+                const trainingGotchiTraits = trainingGotchisTraits[p.toLowerCase()]
+
+                if (!trainingGotchiTraits) {
+                    throw new Error(`No traits found for ${p}`)
+                }
+
+                gotchi.brs = trainingGotchiTraits.brs
+                gotchi.nrg = trainingGotchiTraits.traits[t[0] === '-' ? 0 : 1]
+                gotchi.agg = trainingGotchiTraits.traits[t[1] === '-' ? 0 : 1]
+                gotchi.spk = trainingGotchiTraits.traits[t[2] === '-' ? 0 : 1]
+                gotchi.brn = trainingGotchiTraits.traits[t[3] === '-' ? 0 : 1]
+                gotchi.eys = trainingGotchiTraits.eyes
+                gotchi.eyc = trainingGotchiTraits.eyes
+                
+                gotchi.kinship = 0
+                gotchi.xp = 0
+
+                // Map the in game stats to the gotchi
+                mapGotchi(gotchi)
+                gotchi.attack = t[3] === '-' ? 'physical' : 'magic'
+                gotchi.actionDelay = Math.round(((100 / gotchi.speed) + Number.EPSILON) * 1000) / 1000
+
+                gotchi.specialId = classes.indexOf(className) + 1
+                gotchi.svgFront = `https://storage.googleapis.com/gotchi-battler-qa_gotchis/training/${className.toLowerCase()}_${p.toLowerCase()}_front.png`
+                gotchi.svgBack = `https://storage.googleapis.com/gotchi-battler-qa_gotchis/training/${className.toLowerCase()}_${p.toLowerCase()}_back.png`
+                gotchi.svgLeft = `https://storage.googleapis.com/gotchi-battler-qa_gotchis/training/${className.toLowerCase()}_${p.toLowerCase()}_left.png`
+                gotchi.svgRight = `https://storage.googleapis.com/gotchi-battler-qa_gotchis/training/${className.toLowerCase()}_${p.toLowerCase()}_right.png`
+                gotchi.createdAt = '2023-09-09 12:10:01'
+                gotchi.updatedAt = '2024-06-05 16:34:00'
+                gotchi.special = specials.find(s => s.id === gotchi.specialId)
+
+                trainingGotchis.push(gotchi)
+
+                id++
+            }
+        })
+    })
+
+    const avgGotchis = createAvgGotchs(trainingGotchis)
+
+    trainingGotchis.push(...avgGotchis)
+
+    fs.writeFileSync('./training_gotchis.json', JSON.stringify(trainingGotchis, null, 2))
+}
+
+const createAvgGotchs = (trainingGotchis) => {
+    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)
+
+                    if (['speed', 'health', 'armor', 'resist', 'magic', 'physical', 'accuracy'].includes(stat)) {
+                        avgGotchi[stat] = Math.round(total / gotchis.length)
+                    } else {
+                        // Round to 2 decimal places
+                        avgGotchi[stat] = Math.round((total / gotchis.length) * 100) / 100
+                    }
+                })
+
+                // 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)
+            })
+        })
+    })
+
+    return avgGotchis
+}
+
+// node scripts/balancing/createTrainingGotchis.js
+main('1.7.3')

package/scripts/balancing/extractOnchainTraits.js

@@ -0,0 +1,61 @@
+const fs = require('fs')
+const trainingGotchis = require('./v1.7/training_gotchis.json')
+
+const onchainTraitNames = [
+    'nrg',
+    'agg',
+    'spk',
+    'brn',
+    'eys',
+    'eyc'
+]
+
+const main = () => {
+    const onchainTraits = {}
+    
+    // Loop through all training gotchis ids 1-448 and extract the onchain traits
+    for (let i = 1; i < 449; i++) {
+        const gotchi = trainingGotchis[i]
+
+        const powerLevel = gotchi.name.split(' ')[0].toLowerCase()
+        const gotchiClass = gotchi.name.split(' ')[2].toLowerCase()
+
+        if (!onchainTraits[powerLevel]) {
+            onchainTraits[powerLevel] = {}
+        }
+
+        if (!onchainTraits[powerLevel][gotchiClass]) {
+            onchainTraits[powerLevel][gotchiClass] = {}
+        }
+
+        if (!onchainTraits[powerLevel][gotchiClass].brs) {
+            onchainTraits[powerLevel][gotchiClass].brs = gotchi.brs
+        }
+
+        onchainTraitNames.forEach((trait) => {
+            if (!onchainTraits[powerLevel][gotchiClass][trait]) {
+                onchainTraits[powerLevel][gotchiClass][trait] = []
+            }
+
+            if (gotchi[trait] < 50) {
+                if (!onchainTraits[powerLevel][gotchiClass][trait][0]) {
+                    onchainTraits[powerLevel][gotchiClass][trait][0] = gotchi[trait]
+                }
+            } else {
+                if (!onchainTraits[powerLevel][gotchiClass][trait][1]) {
+                    onchainTraits[powerLevel][gotchiClass][trait][1] = gotchi[trait]
+                }
+            }
+        })
+    }
+
+    fs.writeFileSync('./training_gotchis_traits.json', JSON.stringify(onchainTraits, (key, value) => {
+        if (Array.isArray(value)) {
+            return JSON.stringify(value) // Convert array to a string
+        }
+        return value
+    }, 2).replace(/"\[(.*?)\]"/g, '[$1]'))
+}
+
+// node scripts/balancing/extractOnchainTraits.js
+main()

package/scripts/balancing/fixTrainingGotchis.js

@@ -4,60 +4,60 @@ const { mapGotchi } = require('../../utils/mapGotchi')
 
 const specials = [
     {
-        "id": 1,
-        "class": "Ninja",
-        "name": "Spectral strike",
-        "cooldown": 0,
-        "leaderPassive": "Sharpen blades"
+        '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': 2,
+        'class': 'Enlightened',
+        'name': 'Meditate',
+        'cooldown': 0,
+        'leaderPassive': 'Cloud of Zen'
     },
     {
-        "id": 3,
-        "class": "Cleaver",
-        "name": "Cleave",
-        "cooldown": 2,
-        "leaderPassive": "Frenzy"
+        'id': 3,
+        'class': 'Cleaver',
+        'name': 'Cleave',
+        'cooldown': 2,
+        'leaderPassive': 'Frenzy'
     },
     {
-        "id": 4,
-        "class": "Tank",
-        "name": "Taunt",
-        "cooldown": 0,
-        "leaderPassive": "Fortify"
+        'id': 4,
+        'class': 'Tank',
+        'name': 'Taunt',
+        'cooldown': 0,
+        'leaderPassive': 'Fortify'
     },
     {
-        "id": 5,
-        "class": "Cursed",
-        "name": "Curse",
-        "cooldown": 0,
-        "leaderPassive": "Spread the fear"
+        'id': 5,
+        'class': 'Cursed',
+        'name': 'Curse',
+        'cooldown': 0,
+        'leaderPassive': 'Spread the fear'
     },
     {
-        "id": 6,
-        "class": "Healer",
-        "name": "Blessing",
-        "cooldown": 0,
-        "leaderPassive": "Cleansing Aura"
+        'id': 6,
+        'class': 'Healer',
+        'name': 'Blessing',
+        'cooldown': 0,
+        'leaderPassive': 'Cleansing Aura'
     },
     {
-        "id": 7,
-        "class": "Mage",
-        "name": "Thunder",
-        "cooldown": 2,
-        "leaderPassive": "Channel the coven"
+        'id': 7,
+        'class': 'Mage',
+        'name': 'Thunder',
+        'cooldown': 2,
+        'leaderPassive': 'Channel the coven'
     },
     {
-        "id": 8,
-        "class": "Troll",
-        "name": "Devestating Smash",
-        "cooldown": 2,
-        "leaderPassive": "Clan momentum"
+        'id': 8,
+        'class': 'Troll',
+        'name': 'Devestating Smash',
+        'cooldown': 2,
+        'leaderPassive': 'Clan momentum'
     }
 ]
 
@@ -65,7 +65,7 @@ const classes = ['Ninja','Enlightened','Cleaver','Tank','Cursed','Healer', 'Mage
 const powerLevels = ['Godlike', 'Mythical', 'Legendary', 'Rare', 'Uncommon', 'Common', 'Garbage']
 
 const addAvgGotchs = () => {
-    const statsToOverwrite = ["speed", "health", "crit", "armor", "evade", "resist", "accuracy"]
+    const statsToOverwrite = ['speed', 'health', 'crit', 'armor', 'evade', 'resist', 'accuracy']
 
     const avgGotchis = [];
 

package/scripts/balancing/processSims.js

@@ -41,16 +41,16 @@ const classes = ['Ninja','Enlightened','Cleaver','Tank','Cursed','Healer', 'Mage
 
 const calculateKpis = (data) => {
     // Extract wins values
-    const wins = data.map(item => item.wins);
+    const wins = data.map(item => item.wins)
 
     // Calculate the mean of wins
-    const winsMean = wins.reduce((sum, value) => sum + value, 0) / wins.length;
+    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 winsVariance = wins.reduce((sum, value) => sum + Math.pow(value - winsMean, 2), 0) / (wins.length - 1)
     const winsStdev = Math.sqrt(winsVariance)
 
     // Calculate Interquartile Range (IQR)
@@ -91,8 +91,8 @@ const calculateKpis = (data) => {
         // 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 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)
@@ -196,7 +196,7 @@ const main = async (executionId, numOfTasks, gameLogicVersion) => {
     })
 
     if(process.env.CLOUD_RUN_JOB) {
-        const bucket = storage.bucket('gotchi-battler-sims-v1-7-2')
+        const bucket = storage.bucket('gotchi-battler-sims-v1-7-3')
         
         // Get number of files in the bucket
         const [files] = await bucket.getFiles()

package/scripts/balancing/sims.js

@@ -125,7 +125,7 @@ const getGotchisSimNameFromTeam = (team) => {
 
     [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 position  = team.formation.back[i] ? 'B' : 'F'
 
         const nameParts = gotchi.name.split(' ')
         // Return e.g. "R|++++|1_B"
@@ -139,7 +139,7 @@ const runSims = async (simsVersion, gameLogicVersion, simsPerMatchup) => {
     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 gameLogic = require('../../game-logic')[gameLogicVersion].gameLoop
 
     const attackingPowerLevels = ['Godlike']
     const defendingPowerLevels = ['Godlike', 'Mythical', 'Legendary']
@@ -181,7 +181,7 @@ const runSims = async (simsVersion, gameLogicVersion, simsPerMatchup) => {
 
     console.time(`Sims for ${attackingTeam.name}`)
 
-    defendingTeamIndexes.forEach((defendingTeamIndex, i) => {
+    defendingTeamIndexes.forEach((defendingTeamIndex) => {
         const defendingTeam = createTeamFromTeamIndex(defendingTeamIndex, trainingGotchis, setTeamPositions)
         
         let matchupWins = 0
@@ -231,23 +231,16 @@ const runSims = async (simsVersion, gameLogicVersion, simsPerMatchup) => {
 
     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
-        }
+        await storage.bucket(process.env.SIMS_BUCKET).file(`${process.env.CLOUD_RUN_EXECUTION}_${attackingTeamIndex}.json`).save(JSON.stringify(results))
         
     } else {
-       console.log('Results', results)
+        console.log('Results', results)
 
         // Test saving to GCS
-        if (false) {
+        const test = false
+        if (test) {
             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
-            }
+            await storage.bucket(process.env.SIMS_BUCKET).file(`avg-sims-znw68_${attackingTeamIndex}.json`).save(JSON.stringify(results))
         }
     }
 }
@@ -259,9 +252,9 @@ module.exports = runSims
 // 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.2 v1.7 3 true
+// node scripts/balancing/sims.js 0 v1.7.3 v1.7 3 true
 if (require.main === module) {
-    const simsVersion = process.env.SIMS_VERSION || process.argv[3] || 'v1.7.2'
+    const simsVersion = process.env.SIMS_VERSION || process.argv[3] || 'v1.7.3'
     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

package/scripts/balancing/v1.7/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.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
+    }
+}
+
+module.exports = {
+    mapGotchi,
+    mapTeam
+}