Catch a Monster Game Mechanics

Understand how Catch a Monster works — damage formulas, type advantages, grades, XP, and fusion

Educational Reference

These formulas are community-estimated references to help players understand game mechanics. Actual in-game values may differ. We do not endorse third-party scripts or exploits.

Game Mechanics & Formulas

Understanding how Catch a Monster works under the hood.

Damage Calculation

The base damage formula in Catch a Monster takes into account attack stats, type advantages, and grade modifiers.

-- Damage Calculation Formula
local function calculateDamage(attacker, defender)
    local baseDamage = attacker.attack
    local typeMultiplier = getTypeMultiplier(attacker.type, defender.type)
    local gradeBonus = getGradeBonus(attacker.grade)
    
    local finalDamage = baseDamage * typeMultiplier * gradeBonus
    
    -- Random variance (±10%)
    local variance = 0.9 + (math.random() * 0.2)
    finalDamage = finalDamage * variance
    
    return math.floor(finalDamage)
end

-- Type Multipliers
-- Super Effective: 1.5x
-- Not Very Effective: 0.5x
-- Normal: 1.0x

Type Advantage Matrix

Understanding type matchups is crucial for effective battling.

-- Type Advantage System
local typeChart = {
    Fire = {
        strongAgainst = {"Grass", "Ice"},
        weakAgainst = {"Water", "Rock"}
    },
    Water = {
        strongAgainst = {"Fire", "Rock"},
        weakAgainst = {"Grass", "Electric"}
    },
    Grass = {
        strongAgainst = {"Water", "Rock"},
        weakAgainst = {"Fire", "Ice", "Flying"}
    },
    Electric = {
        strongAgainst = {"Water", "Flying"},
        weakAgainst = {"Ground"}
    },
    Normal = {
        strongAgainst = {},
        weakAgainst = {}
    }
}

local function getTypeMultiplier(attackerType, defenderType)
    local chart = typeChart[attackerType]
    if table.find(chart.strongAgainst, defenderType) then
        return 1.5 -- Super effective
    elseif table.find(chart.weakAgainst, defenderType) then
        return 0.5 -- Not very effective
    end
    return 1.0 -- Normal damage
end

Grade Bonus System

Higher grade monsters have better base stats and multipliers.

-- Grade Stat Multipliers
local gradeMultipliers = {
    E = 1.0,    -- Base stats
    D = 1.15,   -- +15% stats
    C = 1.30,   -- +30% stats
    B = 1.50,   -- +50% stats
    A = 1.75,   -- +75% stats
    S = 2.00,   -- +100% stats (2x)
    SS = 2.50   -- +150% stats (2.5x)
}

local function getGradeBonus(grade)
    return gradeMultipliers[grade] or 1.0
end

-- Example: SS grade monster has 2.5x the base stats
-- A level 1 SS Wattoad would have stats equivalent to
-- a much higher level E grade Wattoad

XP & Leveling System

Experience points are gained through battles. The amount varies based on enemy level and type.

-- XP Calculation
local function calculateXP(defeatedMonster, playerMonster)
    local baseXP = defeatedMonster.baseXPValue
    local levelDiff = defeatedMonster.level - playerMonster.level
    
    -- Level difference bonus/penalty
    local levelMod = 1 + (levelDiff * 0.1)
    levelMod = math.clamp(levelMod, 0.5, 2.0)
    
    -- 2x XP gamepass check
    if player:HasGamepass("2xXP") then
        levelMod = levelMod * 2
    end
    
    return math.floor(baseXP * levelMod)
end

-- XP Required for Level Up
local function xpToNextLevel(currentLevel)
    -- Exponential growth formula
    return math.floor(100 * (currentLevel ^ 1.5))
end

-- Level 1 → 2: 100 XP
-- Level 10 → 11: ~316 XP
-- Level 50 → 51: ~3,535 XP

Fusion Mechanics

The fusion system combines 5 monsters of the same type and grade into a higher grade version.

-- Fusion System Logic
local FUSION_REQUIREMENT = 5

local gradeOrder = {"E", "D", "C", "B", "A", "S", "SS"}

local function canFuse(monsters)
    if #monsters ~= FUSION_REQUIREMENT then
        return false, "Need exactly 5 monsters"
    end
    
    local firstType = monsters[1].type
    local firstGrade = monsters[1].grade
    
    for _, monster in ipairs(monsters) do
        if monster.type ~= firstType then
            return false, "All monsters must be same type"
        end
        if monster.grade ~= firstGrade then
            return false, "All monsters must be same grade"
        end
    end
    
    -- Check if already max grade
    if firstGrade == "SS" then
        return false, "Cannot fuse SS grade monsters"
    end
    
    return true
end

local function fuseMonsters(monsters)
    local baseMonster = monsters[1]
    local currentGradeIndex = table.find(gradeOrder, baseMonster.grade)
    local newGrade = gradeOrder[currentGradeIndex + 1]
    
    -- Create new monster with upgraded grade
    local fusedMonster = {
        type = baseMonster.type,
        grade = newGrade,
        level = 1, -- Reset to level 1
        -- Stats recalculated based on new grade
    }
    
    return fusedMonster
end

Catch Rate Formula

Once defeated, monsters have a 100% catch rate. The grade of the caught monster is determined at spawn.

-- Grade Spawn Rates (estimated)
local gradeSpawnRates = {
    E = 0.40,   -- 40% chance
    D = 0.25,   -- 25% chance
    C = 0.18,   -- 18% chance
    B = 0.10,   -- 10% chance
    A = 0.05,   -- 5% chance
    S = 0.018,  -- 1.8% chance
    SS = 0.002  -- 0.2% chance
}

local function determineSpawnGrade()
    local roll = math.random()
    local cumulative = 0
    
    for grade, rate in pairs(gradeSpawnRates) do
        cumulative = cumulative + rate
        if roll <= cumulative then
            return grade
        end
    end
    
    return "E" -- Default
end

-- Note: Actual rates may vary
-- Some areas may have modified rates