Deserves its own topic

Only open these spoilers if you can read computer code. You've been warned:

 CalcDamageByWT

Code:

double __cdecl CalcDamage__CalcDamageByWT(int a1, int a2, int a3, int a4)
{
  signed int v4; // ecx@1
  double result; // st7@3
  int v6; // edi@3
  int v7; // eax@3
  int v8; // edi@5
  int v9; // eax@5
  int v10; // edi@6
  int v11; // eax@6
  int v12; // edi@7
  int v13; // eax@7
  int v14; // edi@8
  int v15; // eax@8
  int v16; // edi@9
  int v17; // eax@9
  int v18; // edi@10
  int v19; // eax@10
  int v20; // edi@11
  int v21; // eax@11
  int v22; // edi@12
  int v23; // eax@12
  int v24; // edi@13
  int v25; // ebx@13
  int v26; // eax@13
  int v27; // edi@14
  int v28; // eax@14
  int v29; // edi@15
  int v30; // eax@15
  int v31; // edi@16
  int v32; // eax@16
  int v33; // edi@17
  int v34; // eax@17
  int v35; // edi@18
  int v36; // eax@18

  v4 = _ZtlSecureFuse((const __int32 *const )(a2 + 24), *(_DWORD *)(a2 + 32));
  if ( v4 % 1000 && v4 != 2001 )
  {
    switch ( a1 )
    {
      case 45:
        v8 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        v9 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        result = (double)_calc_base_damage(v9, v8, 0, a3, 1.2);
        break;
      case 46:
        v10 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        v11 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        result = (double)_calc_base_damage(v11, v10, 0, a3, 1.35);
        break;
      case 41:
      case 42:
        v12 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        v13 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        result = (double)_calc_base_damage(v13, v12, 0, a3, 1.32);
        break;
      case 43:
      case 44:
        v14 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        v15 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        result = (double)_calc_base_damage(v15, v14, 0, a3, 1.49);
        break;
      case 40:
        v16 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        v17 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        result = (double)_calc_base_damage(v17, v16, 0, a3, 1.32);
        break;
      case 37:
        v18 = _ZtlSecureFuse((const __int32 *const )(a2 + 72), *(_DWORD *)(a2 + 80));
        v19 = _ZtlSecureFuse((const __int32 *const )(a2 + 60), *(_DWORD *)(a2 + 68));
        result = (double)_calc_base_damage(v19, v18, 0, a4, 1.0);
        break;
      case 38:
        v20 = _ZtlSecureFuse((const __int32 *const )(a2 + 72), *(_DWORD *)(a2 + 80));
        v21 = _ZtlSecureFuse((const __int32 *const )(a2 + 60), *(_DWORD *)(a2 + 68));
        result = (double)_calc_base_damage(v21, v20, 0, a4, 1.0);
        break;
      case 31:
      case 32:
        v22 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        v23 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        result = (double)_calc_base_damage(v23, v22, 0, a3, 1.2);
        break;
      case 33:
        v24 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        v25 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        v26 = _ZtlSecureFuse((const __int32 *const )(a2 + 72), *(_DWORD *)(a2 + 80));
        result = (double)_calc_base_damage(v26, v25, v24, a3, 1.3);
        break;
      case 30:
        v27 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        v28 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        result = (double)_calc_base_damage(v28, v27, 0, a3, 1.2);
        break;
      case 47:
        v29 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        v30 = _ZtlSecureFuse((const __int32 *const )(a2 + 72), *(_DWORD *)(a2 + 80));
        result = (double)_calc_base_damage(v30, v29, 0, a3, 1.75);
        break;
      case 39:
        v31 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        v32 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        result = (double)_calc_base_damage(v32, v31, 0, 1, 1.43);
        break;
      case 48:
        v33 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        v34 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        result = (double)_calc_base_damage(v34, v33, 0, a3, 1.7);
        break;
      case 49:
        v35 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
        v36 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
        result = (double)_calc_base_damage(v36, v35, 0, a3, 1.5);
        break;
      default:
        result = 0.0;
        break;
    }
  }
  else
  {
    v6 = _ZtlSecureFuse((const __int32 *const )(a2 + 48), *(_DWORD *)(a2 + 56));
    v7 = _ZtlSecureFuse((const __int32 *const )(a2 + 36), *(_DWORD *)(a2 + 44));
    result = (double)_calc_base_damage(v7, v6, 0, a3, 1.2);
  }
  return result;
}

 _calc_base_damage

Code:

signed __int64 __cdecl _calc_base_damage(int a1, int a2, int a3, signed int a4, double a5)
{
  return (signed __int64)((double)(a3 + a2 + 4 * a1) * (double)a4 * a5 * 0.01 + 0.5);
}

I guess the "byWT" means Weapon Type, then.

And it's still rounding down, they just added 0.5 to it. Why?

just saw the function for max HP and max MP

Both maxHP and maxMP can go up to 99,999

I guess the "byWT" means Weapon Type, then.

And it's still rounding down, they just added 0.5 to it. Why?

If the resultant would "round up", by adding 0.5 to it and converting it to type int it would thus round up. If it were in a situation where it would round down, it would round down in that case still.

i.e. (int)(1.51 + 0.5) = 2
(int)(1.49 + 0.5) = 1
(int)(1.51) = 1

I find it odd they have wrote separate cases for Swords instead of putting them in the same cases as Blunt Weapons and Axes. May imply there's something else going on behind the scenes. Could of course just be idiocy seeing as they did the same for Staves and Wands.

The compiler is smarter than us. It's likely an assembly optimization.

if ( v4 % 1000 && v4 != 2001 )

Cygnus and Legend has it's own code
Nexon is stupid, can't they just make a function to return true/false for Legend/Cygnus instead of repeating job % 1000 == OR != 1000 / 2001.

I see plenty of it all over their code.

Way to go, data encapsulation.

If the resultant would "round up", by adding 0.5 to it and converting it to type int it would thus round up. If it were in a situation where it would round down, it would round down in that case still.

I mean, why add the half? Was it that important that damage formulas appear to round normally, instead of being the floor?

Code:

double __cdecl CalcDamage__CalcDamageByWT(int weap_type, int a2, int total_watk, int total_matk);
signed __int64 __cdecl _calc_base_damage(int prim_stat, int sec_stat_1, int sec_stat_2, signed int total_atk, double weap_multiplier);

the bits in a2 parameter in CalcDamage__CalcDamageByWT seem to define the character stats, each stat is 8 bits long and _ZtlSecureFuse is used to extract each stat from a2

Weap	Mult	weap_type
1H Sword	1.2	30/31/32
1H Axe	1.2	30/31/32
1H BW	1.2	30/31/32
Dagger	1.30	33
Wand	1.00	37/38
Staff	1.00	37/38
2H Sword	1.32	40/41/42
2H Axe	1.32	40/41/42
2H BW	1.32	40/41/42
Spear	1.49	43/44
Polearm	1.49	43/44
Bow	1.20	45
Crossbow	1.35	46
Claw	1.75	47
Knuckler	1.70	48
Gun	1.50	49
???	1.43	39

What's type 39, is it blade? It uses str as primary and dex as secondary though

39 is barehands which is used for brawlers without a knuckler equipped.

So this means some of the earlier discoveries of the Weapon Multipliers were wrong? Just checking =P

So this means some of the earlier discoveries of the Weapon Multipliers were wrong? Just checking =P

Or were rewritten.

So this means some of the earlier discoveries of the Weapon Multipliers were wrong? Just checking =P

Or were rewritten.

nope you guys were spot on, except barehands was left out

I mean, why add the half? Was it that important that damage formulas appear to round normally, instead of being the floor?

It's a fairly common convention to be a little more explicit in how the rounding works.

What I don't like about how the client is structured is that it has a class - CalcDamage - with tower functions CalcPDamage and CalcMDamage with ifs and thens and elses and loops and function calls everywhere. You'd think they'd have delegated each skill to have a function call but noooooooo. Why make it easy?

Argh. If I could only understand this without you explaining. •__•;

just saw the function for max HP and max MP

Both maxHP and maxMP can go up to 99,999

Does it mean there is no more 30000 limitation? (or only % HP/MP gear can pass this limitation?)
for example, HP washed 30000 and using HB = 48000 or still 30000?

Thanks for the information :p

It means warriors with 30k base before bb will automatically have 36k base, plus +% hp equips and HB.

It means warriors with 30k base before bb will automatically have 36k base, plus +% hp equips and HB.

Cool, so theoretically, if you save enough AP before BB, after BB, you can even HP washed to over 30k base HP? (without 20% hp boost skill, and without any % hp equips/HB)
I am wondering if nexon will release new boss that hit for over 30k damage in the future....

What is ZtlSecureFuse?