The Ultimate Magician Damage Comparison

All below calculations assume the following:
- Base level of 150 (unless stated otherwise)
- Basic attack of 400
- Mastery of 60%
- Include elemental staves (if the player has them) and Elemental Amplification (KMS values)

 Cleric/Priest/Bishop

#	IGN	Level	Damage at 150	INT	MATK
1	Warahyuu	150	25956 ~ 32764	768	1110
2	Ancietpriest	150	22331 ~ 28495	814	1005
3	leonpr1d3	150	16001 ~ 20963	725	809

 I/L Mages

#	IGN	Level	Damage at 150	INT	MATK
1	Goals	150	34739 ~ 43624	768	1159
2	gstatue1	150	27733 ~ 35415	793	1002
3	flarfek	150	21193 ~ 27656	705	843

 F/P Mages

#	IGN	Level	Damage at 150	INT	MATK
1	Harrisonized	150	24130 ~ 31153	761	916

 Without level adjustments, elemental staves, and Amp...

#	IGN	Level	Damage	INT	MATK
1	Goals	166	31085 ~ 38684	848	1239
2	Warahyuu	163	28534 ~ 35741	833	1175
3	gstatue1	157	23460 ~ 29820	828	1037
4	Ancietpriest	151	22511 ~ 28706	819	1010
5	Harrisonized	140	17656 ~ 22968	711	866
6	flarfek	130	13920 ~ 18477	605	743
7	leonpr1d3	66	5234 ~ 7558	295	379

Introduction:
Welcome to the ultimate magician damage scaling thread! This thread is largely different from all other threads because it calculates your REAL magician’s damage. This is because the magic damage formula is known and extremely accurate.

It can often be difficult to tell, “Whose mage is better?” Every mage has different elemental weapons, skills, and base attacks available, and thus there is no clear cut way to say “My mage is strong.” This topic will remedy this problem.

How the calculation is performed:
By receiving statistics from you about your level, INT, and MATK, I can calculate your damage. To calculate the damage, I assume a basic attack of 400 and 60% mastery. At no point during the calculations do I check for the damage cap, so this is not an issue. Also, I assume that the person is at level 150 who allocates all points to INT (also accounting for job advancements), as is common among most “best damage” threads. Lastly, the Damage Amplification used for this topic assumes the new Amplification multipliers from KMS in which, at level 30, is a 40% boost instead of 35%.

Credit to everyone in Russt’s thread for figuring out the damage formula.

MAX MAGIC DAMAGE = ((Magic²/1000 + Magic)/30 + INT/200) * Spell Attack * Amp * Elemental Staff
MIN MAGIC DAMAGE = ((Magic²/1000 + Magic * Mastery * 0.9)/30 + INT/200) * Spell Attack * Amp * Elemental Staff

My theory on what bonuses should count is very simple – if the bonus shows in the upper right corner of your screen while used, the bonus will not be counted for this calculation. This rules out Meditation, pots, Maple Hero, etc. while also allowing elemental staves and amplification. If you happen to use Maple Warrior to equip your wand/staff, include the LUK from MW to equip the wand/staf but not the INT as to not affect the damage calculation.

The source that I use is open and freely usable by anyone in the public. If you see any corrections that need to be made in the source, please let me know.

 Source Code

 Mage.py

Code:

class Mage:
    def __init__(self):
        self.IGN = ''
        self.Class = -1
        self.Level = -1
        self.INT = -1
        self.MATK = -1
        self.MaxDamage = 0
        self.MinDamage = 0
        
        self.EleWand = 0

        self.BasicAttack = 400
        self.Mastery = 0.6

        self.AmpLevel  = 0
        self.AmpLevels = [100, 107, 109, 111, 113, 114, 115, 116, 117, 118,
                          119, 121, 121, 123, 123, 125, 125, 127, 127, 129, 129,
                          131, 131, 133, 133, 135, 135, 137, 137, 137, 140]
        self.AmpMultiplier = 1.00

        #Level from which all calculations will be made
        self.BaseLevel = 150

    def AssignAmpLevel(self, AmpLevel):
        if self.IsCleric():
            raise Exception("AssignAmpLevel: Cleric/Priest/Bishop class does not have Amp -> %s" % (self.IGN))        
        if self.IsSecondJob() and AmpLevel > 0:
            raise Exception("AssignAmpLevel: Must be third job to allocate points to Amp -> %s" % (self.IGN))        
        if AmpLevel > ((self.Level - 70) * 3) + 1:
            raise Exception("AssignAmpLevel: Level of Amp impossible with level -> %s" % (self.IGN))
        self.AmpLevel = AmpLevel
        self.AmpMultiplier = self.AmpLevels[AmpLevel] / 100

    def __CalculateAdditionalINT(self):
        if self.Level == -1:
            raise Exception("CalculateAdditionalINT: Level must have a parameter -> %s" % (self.IGN))
        if self.INT == -1:
            raise Exception("CalcualteAdditionalINT: INT must have a parameter -> %s" % (self.IGN))
        if self.MATK == -1:
            raise Exception("CalculateAdditionalINT: MATK must have a parameter -> %s" % (self.IGN))
        if self.Class == -1:
            raise Exception("CalculateAdditionalINT: Class must have a parameter -> %s" % (self.IGN))

        #Level difference assumes all points put into INT
        INTToAdd = (self.BaseLevel - self.Level) * 5

        #Job Advancement
        ExtraINT = (2 - (self.Class % 10)) * 5
        INTToAdd += ExtraINT

        self.INT += INTToAdd
        
        #INT adds to MATK too
        self.MATK += INTToAdd
        if self.MATK > 1999:
            self.MATK = 1999
        self.Level = 150
        
    def CalculateDamage(self, Type='Adjust'):
        if Type == 'Adjust':
            if self.Level is not 150:
                self.__CalculateAdditionalINT()

        if Type == 'NoAdjust':
            self.AmpMultiplier = 1.00

        if self.IsCleric() and self.EleWand == 1:
            raise Exception("CalculateDamage: Cleric class does not have elemental weapons -> %s" % (self.IGN))
        if self.Level < 70 and self.EleWand == 1:
            raise Exception("CalculateDamage: Elemental wands are for level 70 and up -> %s" % (self.IGN))
        
        self.MaxDamage = (((self.MATK ** 2) / 1000 + self.MATK) / 30 + self.INT/200) * self.BasicAttack * self.AmpMultiplier
        self.MinDamage = (((self.MATK ** 2) / 1000 + self.MATK * self.Mastery * 0.9)/30 + self.INT/200) * self.BasicAttack * self.AmpMultiplier

        if(self.EleWand == 1) and Type == 'Adjust':
            self.MaxDamage *= 1.25
            self.MinDamage *= 1.25
        self.MaxDamage = int(self.MaxDamage)
        self.MinDamage = int(self.MinDamage)
        
    def IsCleric(self):
        if (230 <= self.Class <= 232):
            return True
        return False

    def IsIL(self):
        if (220 <= self.Class <= 222):
            return True
        return False

    def IsFP(self):
        if (210 <= self.Class <= 212):
            return True
        return False

    def IsSecondJob(self):
        if self.Class % 10 == 0:
            return True
        return False

    def IsThirdJob(self):
        if self.Class % 10 == 1:
            return True
        return False

    def IsFourthJob(self):
        if self.Class % 10 == 2:
            return True
        return False

 PlayerReader.py

Code:

import configparser
import os

import Mage

Bishops = []
ILArchMage = []
FPArchMage = []
Levels = []

def Main():
    config = configparser.SafeConfigParser()
    config.readfp(open('Players.txt'))
    sections = config.sections()
    for Name in sections:
        items = config.items(Name)
        MyMage = Mage.Mage()
        MyMage.IGN = Name
        for key, value in items:
            if key == 'level':
                MyMage.Level = int(value)
            elif key == 'class':
                MyMage.Class = int(value)
            elif key == 'int':
                MyMage.INT = int(value)
            elif key == 'matk':
                MyMage.MATK = int(value)
            elif key == 'amp level':
                MyMage.AssignAmpLevel(int(value))
            elif key == 'elemental staff?':
                MyMage.EleWand = int(value)
            elif key == 'link':
                MyMage.Link = value
        MyMage.CalculateDamage('NoAdjust')
        Levels.append([MyMage.Level, MyMage.IGN, MyMage.INT, MyMage.MATK,
                       MyMage.MinDamage, MyMage.MaxDamage, MyMage.Link])
        
        MyMage.CalculateDamage()
        
        if 230 <= MyMage.Class <= 232:
            Bishops.append([MyMage.MinDamage, MyMage.MaxDamage, MyMage.Level,
                            MyMage.INT, MyMage.MATK, MyMage.IGN, MyMage.Link])
        if 220 <= MyMage.Class <= 222:
            ILArchMage.append([MyMage.MinDamage, MyMage.MaxDamage, MyMage.Level,
                            MyMage.INT, MyMage.MATK, MyMage.IGN, MyMage.Link])
        if 210 <= MyMage.Class <= 212:
            FPArchMage.append([MyMage.MinDamage, MyMage.MaxDamage, MyMage.Level,
                            MyMage.INT, MyMage.MATK, MyMage.IGN, MyMage.Link])
    if os.access('OutputTable.txt', os.F_OK):
        os.unlink('OutputTable.txt')
    CreateTable(Bishops, 'Cleric/Priest/Bishop')
    CreateTable(ILArchMage, 'I/L Mages')
    CreateTable(FPArchMage, 'F/P Mages')
    CreateTableLevels(Levels, 'Without level adjustments and Archmage buffs...')

def CreateTableLevels(Levels, Header):
    if Levels != []:
        MyTable = Table(Header, 'Damage')
        Levels.sort()
        Levels.reverse()
        for EachPlayer in Levels:
            Level, IGN, INT, MATK, Min, Max, Link = EachPlayer
            MyTable.AddRow(IGN, Level, INT, MATK, Min, Max, Link)
        MyTable.Flush()

def CreateTable(List, Header):
    if List != []:
        MyTable = Table(Header)
        #sorts according to minimum damage    
        List.sort()
        List.reverse()
        for EachPlayer in List:
            Min, Max, Level, INT, MATK, IGN, Link = EachPlayer
            MyTable.AddRow(IGN, Level, INT, MATK, Min, Max, Link)
        MyTable.Flush()

class Table:
    def __init__(self, Header, BaseLevel='Damage at 150'):
        self.TableFile = 'OutputTable.txt'
        self.SpoilerAdded = 0
        self.Table = self.AddSpoiler(Header)
        self.BaseLevel = BaseLevel
        self.InitializeTable()

    def AddSpoiler(self, Header):
        self.SpoilerAdded = 1
        return '[spoiler=' + Header + ']\n'

    def InitializeTable(self):
        self.Table += '''[Table=head;autonum=1;width=400]'''
        self.Table += '[b]IGN[/b]|'
        self.Table += '[b]Level[/b]|'
        self.Table += '[b]%s[/b]|' % (self.BaseLevel)
        self.Table += '[b]INT[/b]|'
        self.Table += '[b]MATK[/b]'
        self.Table += '\n'

    def AddRow(self, IGN, Level, INT, MATK, Min, Max, Link):
        self.Table += self.AddValue(self.AddLink(IGN, Link))
        self.Table += self.AddValue(str(Level))
        self.Table += self.AddValue(str(Min) + ' ~ ' + str(Max))
        self.Table += self.AddValue(str(INT))
        self.Table += self.AddValue(str(MATK))
        self.Table += '\n'

    def AddLink(self, Text, Link):
        return '[url= + Link + ]' + Text + '[/url]'

    def AddValue(self, Value):
        return Value + '|'

    def Flush(self):
        if self.SpoilerAdded == 1:
            self.Table += '[/table][/spoiler]\n\n'
        else:
            self.Table += '[/table]\n\n'
        f = open(self.TableFile, 'a')
        f.write(self.Table)
        f.close()

Main()

So what you need to do:

Requirements:
1. You must be at least second job or higher to apply
2. You must post a screenshot of your entire stat window.
3. If you will be claiming that you have an elemental staff, you must be an f/p or i/l mage and post your inventory showing that you have it equipped.

If you are a cleric/priest/bishop, please fill out the following form:
[noparse]IGN:
Class:
Level:
INT:
MATK: [/noparse]

Otherwise, please fill out the following form:
[noparse]IGN:
Class:
Level:
INT:
MATK:
Amp Level:
Elemental Staff?: [/noparse]

For “Elemental Staff?”, please put a “1” if you have one and “0” if you do not.

Here's a hypothetical example of what I'm looking for:

IGN: MyMage
Class: I/L Archmage
Level: 123
INT: 999
MATK: 1999
Amp Level: 30
Elemental Staff?: 1

Layout:

There will be three spoilers, one for each branch of mages. In each spoiler, I will calculate the minimum and maximum damage of each mage and rank them from highest to lowest according to minimum damage.

In the final spoiler, “Levels”, all bonuses given to archmages are removed. This puts all three branches of the mage class on a very even playing field. Then the table is sorted according to descending level. This way you can compare how your damage ranks with your peers.